feat(WIKI): wiki 2025 BREAKING CHANGE: Older content is categorized into older folders
This commit is contained in:
camera-2018
262
2023旧版内容/4.人工智能/4.10LLMAgent之结构化输出.md
Normal file
262
2023旧版内容/4.人工智能/4.10LLMAgent之结构化输出.md
Normal file
@@ -0,0 +1,262 @@
|
||||
# LLM Agent 之结构化输出
|
||||
|
||||
author:Marlene
|
||||
|
||||
*Last revised 2023/07/26*
|
||||
|
||||
## 引言
|
||||
|
||||
自去年年底以来，GPT 的迅速发展诞生了一系列大模型。出现了更新、更大、更强的 GPT-4。OpenAI 不断推出 GPT-4，ChatGPT Plugins，代码解释器，Function calling，图片处理等等。7 月的 WAIC 上，笔者也有幸见到了国内一众企业相继展示自家的大模型。在这段时间里，LLM 从最初的 PE 工程走向智能体交互。而笔者从最开始考虑 LLM 能不能多人协作，思考”一个专家完成所有任务好还是很多人分工完成好“，到各种论文层出不穷，到如今火热的 LLM Agent 开发模式。可以说，如果你从大学里随便问某个人都知道 GPT，甚至大部分都用过。
|
||||
|
||||
好了，前言少叙。进入正题。众所周知，Agent 基本= LLM（大型语言模型）+ 记忆 + 规划技能 + 工具使用。
|
||||
|
||||
想要使用工具，让 GPT 掌握如何使用工具，常见的方法是告知 GPT 工具（通常是一个可以调用的函数）的参数，让 GPT 生成这些参数即可。那么如何让 GPT 可靠的生成这些规定的参数呢？换一种说法，如何让 GPT 输出结构化的数据信息呢？
|
||||
|
||||
## 原理及相关框架
|
||||
|
||||
现如今大部分的结构化输出工具的原理都是：告诉 GPT 要输出一个怎么样的结构即可。没错~当然，为什么会出现这么多开发工具都用来解决这个问题，明明是一个简单的原理呢？
|
||||
|
||||
```txt
|
||||
1. 通过 prompt 告知 LLM 我们所需要的返回格式，并进行生成。
|
||||
2. 通过一些规则来检查返回结果，如果不符合格式，生成相关错误信息。
|
||||
3. 将上一次的生成内容和检查的错误信息告知 LLM，进行下一次的修正生成。
|
||||
4. 重复 2-3 步骤，直到生成的内容完全符合我们的要求。
|
||||
```
|
||||
|
||||
首先，关于怎样描述这样一个结构的 prompt 模板，众口难调。有些人认为结构就应该用自然语言描述，这样足够简单，上手难度足够低，方便快速迭代开发。有些人认为结构描述？JSON Schema 不就够了？有些人觉得 YAML 也可以。有些人觉得上面这些对于我的需求还是够不着啊，于是自己造了一个伪代码描述。
|
||||
其次，自动处理修正机制也可以做很多文章。还有许多对性能和开销的优化。
|
||||
下文就是关于一众框架的简单分析。希望会对选择困难症的你有所帮助。
|
||||
|
||||
### **guardrails**
|
||||
|
||||
guardrails 这个项目，就是将上述的步骤做了进一步的抽象与封装，提供更加 high level 的配置与 API 来完成整个过程。
|
||||
优点：
|
||||
|
||||
1. 定义了一套 RAIL spec
|
||||
2. 更聚焦于错误信息
|
||||
|
||||
```markdown
|
||||
<rail version="0.1">
|
||||
|
||||
<output>
|
||||
<object name="patient_info">
|
||||
<string name="gender" description="Patient's gender" />
|
||||
<integer name="age" format="valid-range: 0 100" />
|
||||
<list
|
||||
name="symptoms"
|
||||
description="Symptoms that the patient is currently experiencing. Each symptom should be classified into a separate item in the list.">
|
||||
<object>
|
||||
<string name="symptom" description="Symptom that a patient is experiencing"/>
|
||||
<string
|
||||
name="affected area"
|
||||
description="What part of the body the symptom is affecting"
|
||||
format="valid-choices: {['head', 'neck', 'chest']}"
|
||||
on-fail-valid-choices="reask"
|
||||
/>
|
||||
</object>
|
||||
</list>
|
||||
<list name="current_meds" description="Medications the patient is currently taking and their response">
|
||||
<object>
|
||||
<string name="medication" description="Name of the medication the patient is taking" />
|
||||
<string
|
||||
name="response"
|
||||
description="How the patient is responding to the medication"
|
||||
/>
|
||||
</object>
|
||||
</list>
|
||||
</object>
|
||||
</output>
|
||||
|
||||
<prompt>
|
||||
|
||||
Given the following doctor's notes about a patient, please extract a dictionary that contains the patient's information.
|
||||
|
||||
{{doctors_notes}}
|
||||
|
||||
@complete_json_suffix_v2
|
||||
</prompt>
|
||||
</rail>
|
||||
```
|
||||
|
||||
可以看到，guardrails 定义了一套类似 xml 的语言用于结构化输出，又结合了自然语言的 prompt。虽然比起常见的模板语言要更加“繁琐”，但可以包含的内容也可以更加完善。比如可以提供字段的描述信息，检查规范，一定程度上也能帮助 LLM 更好地理解需求，生成预期的结果。
|
||||
|
||||
```markdown
|
||||
I was given the following JSON response, which had problems due to incorrect values.
|
||||
|
||||
{
|
||||
"patient_info": {
|
||||
"symptoms": [
|
||||
{
|
||||
"affected area": {
|
||||
"incorrect_value": "face & hair",
|
||||
"error_message": "Value face & hair is not in choices ['head', 'neck', 'chest']."
|
||||
}
|
||||
},
|
||||
{
|
||||
"affected area": {
|
||||
"incorrect_value": "beard, eyebrows & nares",
|
||||
"error_message": "Value beard, eyebrows & nares is not in choices ['head', 'neck', 'chest']."
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
Help me correct the incorrect values based on the given error messages.
|
||||
```
|
||||
|
||||
后续 LLM 的返回可以仅针对这部分问题的修正，而不需要再重复生成整个 json。生成的新结果会由 guardrails 再自动填写回原来的位置，非常丝滑。除了 json 格式的检查外，RAIL spec 中还提供了通过脚本检查的扩展支持，可以用来检查更加复杂的内容，例如 Python 代码是否合法，结果中是否有敏感信息，甚至通过 LLM 再来检查生成的内容是否有害，做结果过滤等。
|
||||
|
||||
### **NeMo-Guardrails**
|
||||
|
||||
来自 Nvidia 的一个同名项目，其目标相比 guardrails 更有野心，想要确保 LLM 应用整体的可信度，无害性以及数据安全性等，而不仅仅只是输出的结构化检查和修复。因此其实现思路上也复杂不少，设计了一种专门的 Colang 语言，来支持更加通用多样的业务流，而不仅仅是生成 -> 检查 -> 修复。不过它的设计都是基于对话做的。实际开发应用可能不太合适。
|
||||
|
||||
```markdown
|
||||
define user ask capabilities
|
||||
"What can you do?"
|
||||
"What can you help me with?"
|
||||
"tell me what you can do"
|
||||
"tell me about you"
|
||||
"How can I use your help?"
|
||||
|
||||
define flow
|
||||
user ask capabilities
|
||||
bot inform capabilities
|
||||
|
||||
define bot inform capabilities
|
||||
"I am an AI assistant which helps answer questions based on a given knowledge base. For this interaction, I can answer question based on the job report published by US Bureau of Labor Statistics."
|
||||
```
|
||||
|
||||
从代码可以看出其结合了 python 和自然语言，方便相似度检索。
|
||||
其整体的运作流程如下：
|
||||
|
||||
1. 根据用户输入识别用户意图。在这一步，系统会将用户的输入在 flow 定义的各种用户回复文本中做相似性查找，也就是上面文件中“What can you do?”这一连串内容。这些检索到的预设用户意图内容，结合其它信息如对话样例，最近聊天记录等，形成整体的 prompt，发给 LLM 来生成回复。最终再从回复中提取用户意图。
|
||||
2. 根据意图，判断下一步操作动作。这一步有两种做法，一是当前的状态能够匹配上预定义的 flow。例如用户就是提了一个 bot 能力的问题，那么就会匹配上面定义的 user ask capabilities，下一步动作自然就是 bot inform capabilities。如果没有匹配上，就要由 LLM 自己来决定下一步动作，这时候也会跟生成用户意图一样，对于 flow 定义做一个相似性查找，将相关信息发给 LLM 来做生成。
|
||||
3. 生成 bot 回复。如果上一步生成的 bot 回复意图已经有明确定义了（例如上面的 bot 能力的回复），那么就直接用预定义的回复内容来回复用户。如果没有，就跟生成用户意图一样，做意图的相似性查找，将相关信息给 LLM 来生成回复。注意到很多动态的问题例如 QA 场景，是很难预先定义好回复内容的，这里也支持对接知识库，同样是做 vector search 之后，将相关 context 信息发给 LLM 来生成具体回复。
|
||||
|
||||
### guidance
|
||||
|
||||
之前在 guardrails 中的做法是在 prompt 中给出说明和示范，希望 LLM 能够遵循指令来输出。但现实中往往会出现各种问题，例如额外带了一些其它的文字说明，或者生成的 json 格式不正确等，所以需要后续的 ReAsk 来进行修正。LangChain 里也提供了各种 output parser 来帮忙提取回复中的结构化信息部分，但也经常容易运行失败。
|
||||
|
||||
在 guidance 中，也是通过“模板语言”来定义 LLM 的输出结构，以确保输出格式的正确性。
|
||||
|
||||
```markdown
|
||||
# load a model locally (we use LLaMA here)
|
||||
guidance.llm = guidance.llms.Transformers("your_local_path/llama-7b", device=0)
|
||||
|
||||
# we can pre-define valid option sets
|
||||
valid_weapons = ["sword", "axe", "mace", "spear", "bow", "crossbow"]
|
||||
|
||||
# define the prompt
|
||||
program = guidance("""The following is a character profile for an RPG game in JSON format.
|
||||
json
|
||||
{
|
||||
"description": "{{description}}",
|
||||
"name": "{{gen 'name'}}",
|
||||
"age": {{gen 'age' pattern='[0-9]+' stop=','}},
|
||||
"armor": "{{#select 'armor'}}leather{{or}}chainmail{{or}}plate{{/select}}",
|
||||
"weapon": "{{select 'weapon' options=valid_weapons}}",
|
||||
"class": "{{gen 'class'}}",
|
||||
"mantra": "{{gen 'mantra'}}",
|
||||
"strength": {{gen 'strength' pattern='[0-9]+' stop=','}},
|
||||
"items": [{{#geneach 'items' num_iterations=3}}
|
||||
"{{gen 'this'}}",{{/geneach}}
|
||||
]
|
||||
}""")
|
||||
|
||||
# execute the prompt
|
||||
program(description="A quick and nimble fighter.", valid_weapons=valid_weapons)
|
||||
```
|
||||
|
||||
在之前传统的做法中，这一整个 json 都需要由 LLM 来生成。但是 json 的结构是我们预先定义的，例如有哪些字段，开闭的花括号等，其实都不需要 LLM 来生成。
|
||||
优点：
|
||||
|
||||
1. 生成的 json 结构是保证合法且可控的，不会出现语法错误或者缺失/错误字段等。
|
||||
2. 通过 LLM 生成的 token 数量减少了，理论上可以提升生成速度。
|
||||
|
||||
除了 prompt 模板，它还提供了：
|
||||
|
||||
- 支持 hidden block，例如 LLM 的一些推理过程可能并不需要暴露给最终用户，就可以灵活利用这个特性来生成一些中间结果。
|
||||
- Generation caching，自动把已经生成过的结果缓存起来，提升速度。
|
||||
- 支持 HuggingFace 模型的 guidance acceleration，进一步提升生成速度。
|
||||
- Token healing，不看这个我还不知道 LLM 有这种问题……
|
||||
- Regex pattern guide，在模板的基础上进一步通过正则表达来限定生成的内容规范。
|
||||
|
||||
从项目代码来看，还是有比较浓的“research 味道”的，可读性并不好。实际测试结果也比较翻车。
|
||||
|
||||
### lmql
|
||||
|
||||
在 guidance 的基础上，lmql 这个项目进一步把“prompt 模板”这个概念推进到了一种新的编程语言。从官网能看到给出的一系列示例。语法结构看起来有点像 SQL，但函数与缩进都是 Python 的风格。
|
||||
|
||||
从支持的功能来看，相比 guidance 毫不逊色。例如各种限制条件，代码调用，各种 caching 加速，工具集成等基本都具备。这个框架的格式化输出是其次，其各种可控的输出及语言本身或许更值得关注。
|
||||
|
||||
### TypeChat
|
||||
|
||||
TypeChat 将 prompt 工程替换为 schema 工程：无需编写非结构化的自然语言 prompt 来描述所需输出的格式，而是编写 TS 类型定义。TypeChat 可以帮助 LLM 以 JSON 的形式响应，并且响应结果非常合理：例如用户要求将这句话「我可以要一份蓝莓松饼和一杯特级拿铁咖啡吗？」转化成 JSON 格式，TypeChat 响应结果如下：
|
||||
|
||||
其本质原理是把 interface 之类的 ts 代码作为 prompt 模板。因此它不仅可以对输出结果进行 ts 校验，甚至能够输入注释描述，不可谓非常方便 js 开发者。不过，近日 typechat 爆火，很多开发者企图尝试将 typechat 移植到 python，笔者认为这是缘木求鱼，因为其校验本身依赖的是 ts。笔者在开发过程中，将 typechat 融合到自己的库中，效果不错。但是它本身自带的 prompt 和笔者输入的 prompt 还是存在冲突，还是需要扣扣源码。
|
||||
|
||||
### Langchain
|
||||
|
||||
如果你关注了过去几个月中人工智能的爆炸式发展，那你大概率听说过 LangChain。简单来说，LangChain 是一个 Python 和 JavaScript 库，由 Harrison Chase 开发，用于连接 OpenAI 的 GPT API（后续已扩展到更多模型）以生成人工智能文本。
|
||||
|
||||
langchain 具有特别多的结构化输出工具。例如使用 yaml 定义 Schema，输出结构化 JSON。使用 zodSchema 定义 Schema，输出结构化 JSON。使用 FunctionParameters 定义 Schema，输出结构化 JSON。
|
||||
|
||||
但是笔者这里不打算介绍 langchain。究其原因，是笔者被 langchain 折磨不堪。明明可以几行代码写清楚的东西，langchain 可以各种封装，花了好几十行才写出来。更何况，笔者是用 ts 开发，开发时甚至偷不了任何懒，甚至其文档丝毫不友好。这几天，《机器之心》发布文章表示放弃 langchain。要想让 LangChain 做笔者想让它做的事，就必须花大力气破解它，这将造成大量的技术负担。因为使用人工智能本身就需要花费足够的脑力。LangChain 是为数不多的在大多数常用情况下都会增加开销的软件之一。所以笔者建议非必要，不使用 langchain。
|
||||
|
||||
## LLM 对于结构化信息的理解
|
||||
|
||||
LLM 的可控性、稳定性、事实性、安全性等问题是推进企业级应用中非常关键的问题，上面分享的这些项目都是在这方面做了很多探索，也有很多值得借鉴的地方。总体思路上来说，主要是：
|
||||
|
||||
- 提供一套 prompt 模板定义，允许用户指定 LLM 生成的格式或内容主题。
|
||||
- 在模板基础上，也有不少项目进一步设计了相应的编程语言，让 LLM 与确定性程序的交互更加直观。
|
||||
- 提供各类 validator，保证生成内容符合预期，并且提供了自动处理/修正机制。
|
||||
- 更进一步，也可以在生成前进行干预，例如在 prompt 中给近似案例，修改模型 decode 时的概率分布等。
|
||||
- 其它在可控性基础上做的各种性能与开销的优化，例如缓存，减少 token 消耗量，对开源模型能力的挖掘等。
|
||||
|
||||
即使我们不直接使用上述的项目做开发，也可以从中学习到很多有用的思路。当然也非常期待这个领域出现更多有意思的想法与研究，以及 prompt 与编程语言结合能否碰撞出更多的火花。
|
||||
|
||||
同时笔者认为自动处理机制、自己设计的编程语言等等内容，随着时间发展，一定会层出不穷，不断迭代更新。笔者抛去这些时效性较弱的内容，从描述信息和位置信息两方面思考 peompt 模板该如何设计，当然只是浅浅的抛砖引玉一下。
|
||||
|
||||
### 描述信息
|
||||
|
||||
到底哪种方式更容易于 LLM 去理解？我们不谈框架的设计，只考虑 prompt 的设计。上述框架关于这方面有一些参考，例如有些直接拿 json 作为 prompt 模板，有些拿 xml 作为 prompt 模板，有些拿自己设计的语言作为 prompt，有些拿自然语言作为 prompt 模板。时至今日，选用哪种最适合 LLM 去理解格式化的信息，输出格式化的内容完全没有盖棺定论。甚至时至今日，格式化输出问题还是没有得到可靠稳定的解决，要不然笔者肯定不会介绍这么多框架实践了。
|
||||
|
||||
笔者认为不管哪种方式，都可以从两个方面考量：更简单，更结构。如果想要在开发的时候更简单，或者在使用时更简单，选择 md、yaml 方式描述结构化信息更合适。如果想要更结构化的方式，选择 json、xml、ts，输出都能更有结构，甚至之后做结构校验都更方便。
|
||||
|
||||
想要 LLM 结构化输出更加稳定和理想，笔者认为选择 prompt 模板时必须考虑每个字段是否有足够的辅助信息。例如 xml 描述时，每个标签都有一个描述属性描述这个标签时什么意思。
|
||||
|
||||
#### 额外引申
|
||||
|
||||
笔者之前在开发 LLM 应用时，也曾思考类似的问题。笔者需要将多模态的数据进行结构化的标注，方便 LLM 去理解。但是标注成什么样却是一个很大的难题。笔者选择的是 JSON。但是，关于里面许多内容的标注。笔者在众多方案中徘徊。在细节处深挖，如何设计一种既简单，又能表示各种结构复杂关系，还能够节约 token 的方案及其的难。
|
||||
> 关于后续如何解决，请容笔者卖个关子 sai~
|
||||
|
||||
### 位置信息
|
||||
|
||||
是否有人注意到 llm 对于关键信息在 prompt 中的位置会对结果产生影响呢？在设计 prompt 方面，人们通常建议为语言模型提供详尽的任务描述和背景信息。近期的一些语言模型有能力输入较长的上下文，但它究竟能多好地利用更长的上下文？这一点却相对少有人知。近日，有学者研究发现如果上下文太长，语言模型会更关注其中的前后部分，中间部分却几乎被略过不看，导致模型难以找到放在输入上下文中部的相关信息。下文部分是该论文一些核心内容：
|
||||
|
||||
这是由其本身训练和结构设计有关的，但却对于我们开发有着莫大的帮助和指导意义。
|
||||
|
||||
相比之下，在多文档问答任务上，查询感知型上下文化的影响很小。特别指出，当相关信息位于输入上下文的最开始时，它可以提高性能，但在其他设置中会稍微降低性能。借此，我们可以认为，将重要的信息放在开头，结尾放置结构化模板，或许是一种优质选择。
|
||||
|
||||
那么如果真的为其提供这么多 token，那会真的有用吗？这个问题的答案是：由下游任务决定。因为这取决于所添加上下文的边际价值以及模型有效使用长输入上下文的能力。所以如果能有效地对检索文档排序（让相关信息与输入上下文的起始处更近）或对已排序的列表进行截断处理（必要时返回更少的文档），那么也许可以提升基于语言模型的阅读器使用检索上下文的能力。
|
||||
|
||||
## 题外话
|
||||
|
||||
之前，妙鸭相机突然爆火。其只需 9.9 即可生成同款数字分身，效果拔群。但是很多人发现，其生成的内容极其容易造成肖像权侵犯，这显然是有问题的。更有甚至的是，用户发现妙鸭相机的用户协议存在问题。根据该应用最初版本的用户服务协议，用户需授权妙鸭相机在全世界（包括元宇宙等虚拟空间）范围内享有永久的、不可撤销的、可转让的、可转授权的、免费的和非独家的许可，使得妙鸭相机可以任何形式、任何媒体或技术（无论现在已知或以后开发）使用用户的内容。对于上述内容，妙鸭相机称系“为了使我方能够提供、确保和改进本服务（包括但不限于使用 AI 生成内容作为再训练数据等）”。
|
||||
|
||||
一句话理解，就是你的肖像它随便用，与你无关。
|
||||
|
||||
这不禁让我联想到一部非常发人深省的剧作：《黑镜》。它的第六季第一集讲述的同样是隐私的问题。该集中，主人公的生活隐私由于同意了用户协议，被无时无刻搜集。然后当天晚上就发现流媒体电视上居然出现了跟她同名的电视剧，内容与它当天的生活一模一样，台词甚至更加夸张。于是她的不方便公之于众的生活变得一塌涂地，但她甚至没有办法打官司，因为肯定会输。更令人深省的是，电视剧的主人公是 AI 生成的视频，其肖像确是根据现实存在的明星生成的。那位明星也无法对她的肖像有任何权利。这样一个荒诞的故事，但是仔细想想，却又非常可能发生。
|
||||
|
||||
如今的社会出现了各种大模型。大模型的发展必定需要大数据的支撑。企业为了盈利必定会想方设法的搜集数据，然后肆意使用，转卖。而很多用户对此不自知，更有甚至是非常乐意。例如抖音、B 站，当你对其交互时，你希望它推荐更适合你的视频，它也在搜集你的数据，这是明知且主动的。
|
||||
|
||||
隐私的掠夺是无声的。你认为你的一下点击是没啥价值的隐私数据，殊不知这正中了资本家的下怀。几年前，我也是这样的。高中的大门出现了闸机，可以刷脸进校园。我当时以为这需要像手机解锁一样需要扫描人脸 ID。结果发现，我可以直接进去，闸机上甚至会出现我的照片。我仔细看了看，发现是我入学的证件照。原来一张照片就能刷脸进校园。原来就连学校也可以不经同学同意，将照片用作其他用途。那更何况其他的呢。
|
||||
我想，未来，这样的隐私问题会越来越多。
|
||||
|
||||
## 参考
|
||||
|
||||
<https://mp.weixin.qq.com/s?__biz=MzA3MzI4MjgzMw==&mid=2650885029&idx=4&sn=ac01576a8957b41529dd3c877d262d5e&chksm=84e48fdbb39306cd8979a4fa7f7da14a9428dc28ccc47880d668ef6293b1a8b7b0964569ec36&mpshare=1&scene=23&srcid=0725w9FPsVnOOzkPGPB7lH8h&sharer_sharetime=1690303766527&sharer_shareid=d2396b329b12f49d34967e2b183540dd#rd>
|
||||
<https://mp.weixin.qq.com/s/BngY2WgCcpTOlvdyBNJxqA>
|
||||
<https://microsoft.github.io/TypeChat/>
|
||||
<https://mp.weixin.qq.com/s?__biz=MzA3MzI4MjgzMw==&mid=2650885029&idx=4&sn=ac01576a8957b41529dd3c877d262d5e&chksm=84e48fdbb39306cd8979a4fa7f7da14a9428dc28ccc47880d668ef6293b1a8b7b0964569ec36&mpshare=1&scene=23&srcid=0725w9FPsVnOOzkPGPB7lH8h&sharer_sharetime=1690303766527&sharer_shareid=d2396b329b12f49d34967e2b183540dd#rd>
|
||||
66
2023旧版内容/4.人工智能/4.11本章节内容的局限性.md
Normal file
66
2023旧版内容/4.人工智能/4.11本章节内容的局限性.md
Normal file
@@ -0,0 +1,66 @@
|
||||
# 本章节内容的局限性
|
||||
|
||||
作为一个本科生和部分研究生为主书写的教程，必须承认的是，我们在本章节内容，存在非常多的局限性，而本节内容，就是对目前存在的局限性和为什么还没有立马改进做的一定解释。
|
||||
|
||||
## 缺少一些前沿的内容
|
||||
|
||||
让我们时时刻刻都跟进最前沿的内容并且进行输出是相当困难的，当然我们也欢迎各位得贡献
|
||||
|
||||
## 少有机器学习的一些算法
|
||||
|
||||
机器学习领域有非常庞大的知识体系和一代人十几年的积累。
|
||||
|
||||
无数伟大的科学家究其一生的研究和探索它，但是你发现本章内容少有相关内容，还是以深度学习为主？为什么？
|
||||
|
||||
## 原因一：时代的浪潮
|
||||
|
||||
近乎全民深度学习的浪潮下，机器学习的知识被科研界一而再再而三的抛掷脑后，大家争先恐后的刷点，并使用深度学习的解决问题，因此深度学习领域的知识材料得到了井喷式的增长，而少有人愿意投入非常长的时间去研究机器学习的每一条数学公式的背后机理。
|
||||
|
||||
也正因如此，诸位花费自己的大学四年时光去钻研几条算法兴许是有意义的，但是对你拓展视野增长知识面的帮助没那么大，也没有办法帮助你引导到一些实操项目的工作中去，因此除了真正热爱的那一批人以外，过多的投入时间去学机器学习知识可能会让你感觉患得患失最后半途而废。
|
||||
|
||||
## 原因二：算法的性质
|
||||
|
||||
算法的性质就是严谨，一丝不苟的推导。因此，他涉及了大量的数学方程以及严谨的一步一步的推导过程。在学习的过程中，没有捷径，也没有更快的方法，你只能踏踏实实一步一步的进行积累。
|
||||
|
||||
而本教程的性质更偏向于导学，当你决心在机器学习算法深耕的时候，你已经脱离了需要导学的范畴更偏向于领域内容钻研，这是一项伟大的但是在当今时代略有吃力不讨好的工作，我真心祝愿你能乐在其中~感受到学习的快乐。
|
||||
|
||||
## 原因三：缺乏应用空间
|
||||
|
||||
ZZM 曾经尝试过投入大量时间去钻研数学以及机器学习相关的算法，但是发现了一个很残酷的现实就是，我们欠缺的积累和知识不是靠猛然突击可以弥补的，自己学都很吃力了，写出来不是误人子弟么 hhhh。
|
||||
|
||||
同时，尽管知识的内容让人很快乐，但是如果你不经常使用，或者实打实的拿一张白纸从头到尾推演一遍的话，你忘记的速度是非常快的，因此我们写下他，你们看一遍甚至说认真的阅览一遍，也不会留下太多内容。
|
||||
|
||||
## 如果真的感兴趣这方面内容呢
|
||||
|
||||
如果你阅览了本章节的数学相关知识和内容以及拓展感觉非常感兴趣并且毫无压力的话，我推荐你尝试去啃一啃大家公认的困难的书籍，比如说著名的花书，互联网上，社区内也有大量的辅助材料来帮助你更进一步的入门
|
||||
|
||||
## 科研导向明显
|
||||
|
||||
整篇教程大范围的在教怎么从科研角度去理解一些知识，感觉和工业上的逻有不符之处。
|
||||
|
||||
确实如此，工业界的逻辑和科研界的逻辑是截然不同的。
|
||||
|
||||
工业界的逻辑更偏向于低成本，高产出。而科研更偏向于你在一个好故事的背景下做了如何优雅的提升。
|
||||
|
||||
粗鲁地说就是工业更注重你这个项目，如果现在有一百万人用，能不能把百分之九十正确率的这个东西用好，科研更偏向于九十五到九十九。
|
||||
|
||||
我们自身并没有接触过太多的工业项目，也无法深入大厂去揭示他的算法，自然就算写东西写出来也不具备任何说服力。
|
||||
|
||||
因此如果你对这方面感兴趣，可能你需要别的途径去获取更多的思考和资源了。
|
||||
|
||||
## 繁杂的知识内容
|
||||
|
||||
这点非常抱歉，AI 领域的知识本身就是网状的，复杂的，甚至是互相引用的，这点会导致不可避免的内容变得冗长。
|
||||
|
||||
可能需要你花费大量的时间建立自己的知识框架和逻辑体系
|
||||
|
||||
而不是别人强行灌输给你的
|
||||
|
||||
## 还有更多？？？
|
||||
|
||||
联系 ZZM，我努力改
|
||||
::: tip 邮箱
|
||||
<1264517821@qq.com>
|
||||
:::
|
||||
|
||||
<img src="https://cdn.xyxsw.site/boxcnfYSoVgoERduiWP0jWNWMxf.jpg" width=200>
|
||||
99
2023旧版内容/4.人工智能/4.1前言.md
Normal file
99
2023旧版内容/4.人工智能/4.1前言.md
Normal file
@@ -0,0 +1,99 @@
|
||||
# 对 AI 大致方向的概述
|
||||
|
||||
## 前言
|
||||
|
||||
在这个时代，相关内容是非常泛滥的，我们在本章内容中，大致的写一些目前比较有名的方向以及它的简介（也许会比 wiki 和百度有趣一点？）
|
||||
|
||||
## 深度学习 的大致方向分类
|
||||
|
||||
本模块会粗略地介绍目前审读学习的研究与应用领域，在这里提前说明：笔者也只是一名普通的杭电学生，视野与认知有限，某些领域我们了解较多就会介绍地更加详细，某些领域了解较少或笔者中无人从事相关研究，就难免会简略介绍甚至有所偏颇，欢迎大家的指正。
|
||||
|
||||
### CV(计算机视觉)
|
||||
|
||||
计算机视觉旨在**用计算机模拟人类处理图片信息的能力**，就比如这里有一张图片——手写数字 9
|
||||
|
||||
|
||||
|
||||
对我们人类而言，能够很轻松地知道这张图片中包含的信息（数字 9），而对计算机来说这只是一堆像素。计算机视觉的任务就是让计算机能够从这堆像素中得到‘数字 9’这个信息。
|
||||
|
||||
相信你通过上面简单的介绍应该能够了解到计算机视觉是在干嘛了，接下来我会举几个相对复杂的例子来让大家了解一下目前的 cv 是在做怎样的研究：
|
||||
|
||||
::: warning 🐱 **图像分割**是在图片中对物体分类，并且把它们所对应的位置标示出来。下图就是把人的五官，面部皮肤和头发分割出来，效 (小) 果 (丑) 图如下：
|
||||
:::
|
||||
|
||||
<table>
|
||||
<tr>
|
||||
<td><img src=https://cdn.xyxsw.site/boxcnxn5GlJZmsrMV5qKNwMlDPc.jpg width=175></td>
|
||||
<td><img src=https://cdn.xyxsw.site/boxcnokdWGegr2XCi1vfg0ZZiWg.png width=200></td>
|
||||
<td><img src=https://cdn.xyxsw.site/boxcn2o9ilOZg6jI6ssTYWhoeme.png width=200></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
::: warning 🐱 **图像生成**相信大家一定不陌生，NovalAI 在 2022 年火的一塌糊涂，我觉得不需要我过多赘述，对它 (Diffusion model) 的改进工作也是层出不穷，这里就放一张由可控姿势网络 (ControlNet) 生成的图片吧：
|
||||
:::
|
||||
|
||||
|
||||
|
||||
::: warning 🐱 **三维重建**也是很多研究者关注的方向，指的是传入对同一物体不同视角的照片，来生成 3D 建模的任务。这方面比图像处理更加前沿并且难度更大。具体见[4.6.5.4 神经辐射场 (NeRF)](4.6.5.4%E7%A5%9E%E7%BB%8F%E8%BE%90%E5%B0%84%E5%9C%BA(NeRF).md) 章节。
|
||||
:::
|
||||
|
||||
如果对计算机视觉有兴趣，可以通过以下路线进行学习：深度学习快速入门—> 经典网络。本块内容的主要撰写者之一**SRT 社团**多数成员主要从事 CV 方向研究，欢迎与我们交流。
|
||||
|
||||
### NLP(自然语言处理)
|
||||
|
||||
这就更好理解了，让计算机能够像人类一样，理解文本中的“真正含义”。在计算机眼中，文本就是单纯的字符串，NLP 的工作就是把字符转换为计算机可理解的数据。举个例子，ChatGPT(或者 New Bing) 都是 NLP 的成果。在过去，NLP 领域被细分为了多个小任务，比如文本情感分析、关键段落提取等。而 ChatGPT 的出现可以说是集几乎所有小任务于大成，接下来 NLP 方向的工作会向 ChatGPT 的方向靠近。
|
||||
|
||||
<table>
|
||||
<tr>
|
||||
<td><img src=https://cdn.xyxsw.site/boxcnyh6pakAkcxCKq6pLylSdef.png width=580></td>
|
||||
<td><img src=https://cdn.xyxsw.site/boxcnwWnoEDulgWdqGkY0WeYogc.png width=200></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
### 多模态 (跨越模态的处理)
|
||||
|
||||
模态，可以简单理解为数据形式，比如图片是一种模态，文本是一种模态，声音是一种模态，等等……
|
||||
|
||||
而多模态就是让计算机能够将不同模态的信息相对应，一种常用的方法就是让计算机把图片的内容和文本的内容理解为相同的语义（在这个领域一般用一个较长的向量来表示语义）。
|
||||
|
||||
也就是说我**传入一张狗子的照片经过模型得到的向量**与**DOG 这个单词经过模型得到的向量**相近。
|
||||
|
||||
具体的任务比如说**图片问答**，传入一张图片，问 AI 这张图片里面有几只猫猫，它们是什么颜色，它告诉我有一只猫猫，是橙色的：
|
||||
|
||||
|
||||
|
||||
### 对比学习
|
||||
|
||||
因为传统 AI 训练一般都需要数据集标注，比如说图片分割数据集需要人工在数万张图片上抠出具体位置，才能进行训练，这样的人力成本是巨大的，而且难以得到更多数据。因此，对比学习应运而生，这是一种不需要进行标注或者只需要少量标注的训练方式
|
||||
|
||||
### 强化学习
|
||||
|
||||
强调模型如何依据环境（比如扫地机器人在学习家里的陈设，这时陈设就是环境）的变化而改进，以取得最大的收益（比如游戏得到最高分）。
|
||||
|
||||
强化学习是除了监督学习和非监督学习之外的第三种基本的机器学习方法。与监督学习不同的是，强化学习不需要带标签的输入输出对，同时也无需对非最优解的精确地纠正。其关注点在于寻找探索（对未知领域的）和利用（对已有知识的）的平衡。 -------wiki
|
||||
|
||||
强化学习主要理论来源于心理学中的动物学习和最优控制的控制理论。说的通俗点，强化学习就是操控智能体与环境交互、去不断试错，在这个过程中进行学习。因此，强化学习被普遍地应用于游戏、资源优化分配、机器人等领域。强化学习本身已经是个老东西了，但是和深度学习结合之后焕发出了第二春——深度强化学习（DRL）。
|
||||
|
||||
深度强化学习最初来源是 2013 年谷歌 DeepMind 团队发表的《Playing Atari with Deep Reinforcement Learning》一文，正式提出 Deep Q-network（DQN）算法。在这篇论文中，DeepMind 团队训练智能体 Agent 玩雅达利游戏，并取得了惊人的成绩。事实上，深度强化学习最为人熟知的成就是 AlphaGO Zero，它没有使用任何人类棋谱进行训练，训练了三天的成就就已经超过了人类几千年的经验积累<del>导致柯洁道心破碎</del>。
|
||||
|
||||
## 交叉学科&经典机器学习算法
|
||||
|
||||
交叉学科巨大的难度在于你往往需要掌握多个学科以及其相对应的知识。
|
||||
|
||||
举个例子：如果你想要做出一个可以识别病人是否得了某种疾病，现在你得到了一批数据，你首先得自己可以标注出或者找到这个数据中，哪些是有问题的，并且可以指明问题在哪，如果你想分出更具体的，比如具体哪里有问题，那你可能甚至需要熟悉他并且把他标注出来。
|
||||
|
||||
目前其实全学科都有向着 AI 走的趋势，例如量化金融，医疗，生物科学 (nature 的那篇有关氨基酸的重大发现真的很 cool)。他们很多都在用非常传统的机器学习算法，甚至有的大公司的算法岗在处理某些数据的时候，可能会先考虑用最简单的决策树试一试
|
||||
|
||||
当然，在大语言模型出现的趋势下，很多学科的应用会被融合会被简化会被大一统 (科研人的崇高理想)，但是不得不提的是，传统的机器学习算法和模型仍然希望你能去了解甚至更进一步学习。
|
||||
|
||||
除了能让你了解所谓前人的智慧，还可以给你带来更进一步的在数学思维，算法思维上的提高。
|
||||
|
||||
## And more?
|
||||
|
||||
我们对 AI 的定义如果仅仅只有这些内容，我认为还是太过于狭隘了，我们可以把知识规划，知识表征等等东西都可以将他划入 AI 的定义中去，当然这些还期待着你的进一步探索和思考~
|
||||
|
||||
## 特别致谢
|
||||
|
||||
非常荣幸能在本章中得到 IIPL 智能信息处理实验室 [http://iipl.net.cn](http://iipl.net.cn) 的宝贵贡献，衷心感谢他们的无私支持与帮助！
|
||||
|
||||
<!-- 希望加入 IIPL？欢迎移步[SRT 社团介绍](SRT.md)～ -->
|
||||
455
2023旧版内容/4.人工智能/4.2机器学习（AI）快速入门（quick start）.md
Normal file
455
2023旧版内容/4.人工智能/4.2机器学习（AI）快速入门（quick start）.md
Normal file
@@ -0,0 +1,455 @@
|
||||
# 机器学习（AI）快速入门（quick start）
|
||||
|
||||
::: warning 😇 本章内容需要你掌握一定的 python 基础知识。
|
||||
|
||||
如果你想要快速了解机器学习，并且动手尝试去实践他，你可以先阅览本部分内容。
|
||||
|
||||
里面包含 python 内容的一点点基本语法包括 if,for 等语句，函数等概念即可，你可以遇到了再去学。
|
||||
|
||||
就算没有编程基础也基本能看懂，选择着跳过吧
|
||||
|
||||
当然我需要承认一点，为了让大家都可以看懂，我做了很多抽象，具有了很多例子，某些内容不太准确，这是必然的，最为准确的往往是课本上精确到少一个字都不行的概念，这是难以理解的。
|
||||
|
||||
本篇内容只适合新手理解使用，所以不免会损失一些精度。
|
||||
:::
|
||||
|
||||
## 什么是机器学习
|
||||
|
||||
这个概念其实不需要那么多杂七杂八的概念去解释。
|
||||
|
||||
首先你要认识到他是人工智能的一部分，不需要写任何与问题有关的特定代码。你把数据输入相关的算法里面，他给你总结相应的规律。
|
||||
|
||||
我举个例子，你现在把他当成一个黑盒，不需要知道里面有什么，但是你知道他会回答你的问题。你想知道房价会怎么变动来决定现在买不买房。然后你给了他十年的房价数据，他发现每年都在涨，所以给你预测了一个数值。
|
||||
|
||||
然后你给了他更多信息，比如说国家给出了某些条例，他分析这个条例一出，房价就会降低，他给你了个新的数据。
|
||||
|
||||
因此我们得出一个结论：机器学习 ＝ 泛型算法。
|
||||
|
||||
甚至深度学习，也只是机器学习的一部分，不过使用了更多技巧和方法，增大了计算能力罢了。
|
||||
|
||||
|
||||
|
||||
## 两种机器学习算法
|
||||
|
||||
你可以把机器学习算法分为两大类：监督式学习（supervised Learning）和非监督式学习（unsupervised Learning）。要区分两者很简单，但也非常重要。
|
||||
|
||||
### 监督式学习
|
||||
|
||||
你是卖方的，你公司很大，因此你雇了一批新员工来帮忙。
|
||||
|
||||
但是问题来了——虽然你可以一眼估算出房子的价格，但新员工却不像你这样经验丰富，他们不知道如何给房子估价。
|
||||
|
||||
为了帮助你的新员工，你决定写一个可以根据房屋大小、地段以及同类房屋成交价等因素来评估一间房屋的价格的小软件。
|
||||
|
||||
近三个月来，每当你的城市里有人卖了房子，你都记录了下面的细节——卧室数量、房屋大小、地段等等。但最重要的是，你写下了最终的成交价：
|
||||
|
||||
|
||||
|
||||
然后你让新人根据着你的成交价来估计新的数量
|
||||
|
||||
|
||||
|
||||
这就是监督学习，你有一个参照物可以帮你决策。
|
||||
|
||||
### 无监督学习
|
||||
|
||||
没有答案怎么办？
|
||||
|
||||
你可以把类似的分出来啊！
|
||||
|
||||
我举个例子，比如说警察叔叔要查晚上的现金流，看看有没有谁干了不好的事情，于是把数据拎出来。
|
||||
|
||||
发现晚上十点到十二点间，多数的现金交易是几十块几百块。有十几个是交易几千块的。
|
||||
|
||||
然后再把交易给私人账户的和公司账户的分开，发现只有一个是给个人账户的，发现他还是在酒店交易的！
|
||||
|
||||
这下糟糕了，警察叔叔去那个酒店一查，果然发现了有人在干不好的事情。
|
||||
|
||||
这其实就是一种经典的聚类算法
|
||||
|
||||
|
||||
|
||||
可以把特征不一样的数据分开，有非常多的操作，你感兴趣可以选择性的去了解一下。
|
||||
|
||||
## 太酷炫了，但这也叫 AI？这也叫学习？
|
||||
|
||||
作为人类的一员，你的大脑可以应付绝大多数情况，并且在没有任何明确指令时也能够学习如何处理这些情况。而目前的机器学习就是在帮助我们机器建立起解决问题的能力。
|
||||
|
||||
但是目前的机器学习算法还没有那么强大——它们只能在非常特定的、有限的问题上有效。也许在这种情况下，「学习」更贴切的定义是「在少量样本数据的基础上找出一个公式来解决特定的问题」。
|
||||
|
||||
但是「机器在少量样本数据的基础上找出一个公式来解决特定的问题」不是个好名字。所以最后我们用「机器学习」取而代之。而深度学习，则是机器在数据的基础上通过很深的网络（很多的公式）找一个及解决方案来解决问题。
|
||||
|
||||
## 看看 Code
|
||||
|
||||
如果你完全不懂机器学习知识，你可能会用一堆 if else 条件判断语句来判断比如说房价
|
||||
|
||||
```python
|
||||
def estimate_house_sales_price(num_of_bedrooms, sqft, neighborhood):
|
||||
price = 0 # In my area, the average house costs $200 per sqft
|
||||
price_per_sqft = 200 i f neighborhood == "hipsterton":
|
||||
# but some areas cost a bit more
|
||||
price_per_sqft = 400 elif neighborhood == "skid row":
|
||||
# and some areas cost less
|
||||
price_per_sqft = 100 # start with a base price estimate based on how big the place is
|
||||
price = price_per_sqft * sqft # now adjust our estimate based on the number of bedrooms
|
||||
if num_of_bedrooms == 0:
|
||||
# Studio apartments are cheap
|
||||
price = price — 20000
|
||||
else:
|
||||
# places with more bedrooms are usually
|
||||
# more valuable
|
||||
price = price + (num_of_bedrooms * 1000)
|
||||
return price
|
||||
```
|
||||
|
||||
假如你像这样瞎忙几个小时，最后也许会得到一些像模像样的东西。但是永远感觉差点东西。
|
||||
|
||||
并且，你维护起来非常吃力，你只能不断地加 if else。
|
||||
|
||||
现在看起来还好，但是如果有一万行 if else 呢？
|
||||
|
||||
所以你最好考虑换一种方法：如果能让计算机找出实现上述函数功能的办法，岂不更好？只要返回的房价数字正确，谁会在乎函数具体干了些什么呢？
|
||||
|
||||
```python
|
||||
def estimate_house_sales_price(num_of_bedrooms, sqft, neighborhood):
|
||||
price = <电脑电脑快显灵>
|
||||
return price
|
||||
```
|
||||
|
||||
如果你可以找到这么一个公式：
|
||||
|
||||
Y(房价)=W(参数) \* X1(卧室数量) + W \*X2(面积) + W \* X3(地段)
|
||||
|
||||
你是不是会舒服很多，可以把他想象成，你要做菜，然后那些参数就是佐料的配比
|
||||
|
||||
有一种笨办法去求每一个参数的值：
|
||||
|
||||
第一步：将所有参数都设置为 1
|
||||
|
||||
```python
|
||||
def estimate_house_sales_price(num_of_bedrooms, sqft, neighborhood):
|
||||
price = 0 # a little pinch of this
|
||||
price += num_of_bedrooms *1.0 # and a big pinch of that
|
||||
price += sqft * 1.0 # maybe a handful of this
|
||||
price += neighborhood * 1.0 # and finally, just a little extra salt for good measure
|
||||
price += 1.0
|
||||
return price
|
||||
```
|
||||
|
||||
第二步把每个数值都带入进行运算。
|
||||
|
||||
|
||||
|
||||
比如说，如果第一套房产实际成交价为 25 万美元，你的函数估价为 17.8 万美元，这一套房产你就差了 7.2 万。
|
||||
|
||||
现在，将你的数据集中的每套房产估价偏离值平方后求和。假设你的数据集中交易了 500 套房产，估价偏离值平方求和总计为 86,123,373 美元。这个数字就是你的函数现在的「错误」程度。
|
||||
|
||||
现在，将总和除以 500，得到每套房产的估价偏差的平均值。将这个平均误差值称为你函数的代价（cost）。
|
||||
|
||||
如果你能通过调整权重，使得这个代价变为 0，你的函数就完美了。它意味着，根据输入的数据，你的程序对每一笔房产交易的估价都是分毫不差。所以这就是我们的目标——通过尝试不同的权重值，使代价尽可能的低。
|
||||
|
||||
第三步：
|
||||
|
||||
通过尝试所有可能的权重值组合，不断重复第二步。哪一个权重组合的代价最接近于 0，你就使用哪个。当你找到了合适的权重值，你就解决了问题！
|
||||
|
||||
兴奋的时刻到了！
|
||||
|
||||
挺简单的，对吧？想一想刚才你做了些什么。你拿到了一些数据，将它们输入至三个泛型的、简单的步骤中，最后你得到了一个可以对你所在区域任何房屋进行估价的函数。房价网站们，你们要小心了！
|
||||
|
||||
但是下面的一些事实可能会让你更兴奋：
|
||||
|
||||
1. 过去 40 年来，很多领域（如语言学、翻译学）的研究表明，这种「搅拌数字汤」（我编的词）的泛型学习算法已经超过了那些真人尝试明确规则的方法。机器学习的「笨」办法终于打败了人类专家。
|
||||
2. 你最后写出的程序是很笨的，它甚至不知道什么是「面积」和「卧室数量」。它知道的只是搅拌，改变数字来得到正确的答案。
|
||||
3. 你可能会对「为何一组特殊的权重值会有效」一无所知。你只是写出了一个你实际上并不理解却能证明有效的函数。
|
||||
4. 试想，如果你的预测函数输入的参数不是「面积」和「卧室数量」，而是一列数字，每个数字代表了你车顶安装的摄像头捕捉的画面中的一个像素。然后，假设预测的输出不是「价格」而是「方向盘转动角度」，这样你就得到了一个程序可以自动操纵你的汽车了！
|
||||
|
||||
这可行吗？瞎尝试这不得尝试到海枯石烂？
|
||||
|
||||
为了避免这种情况，数学家们找到了很多种[聪明的办法](https://en.wikipedia.org/wiki/Gradient_descent)来快速找到优秀的权重值。下面是一种：
|
||||
|
||||
|
||||
|
||||
这就是被称为 loss 函数的东西。
|
||||
|
||||
这是个专业属于，你可以选择性忽略他，我们将它改写一下
|
||||
|
||||
|
||||
|
||||
*θ 表示当前的权重值。J(θ) 表示「当前权重的代价」。*
|
||||
|
||||
这个等式表示，在当前权重值下，我们估价程序的偏离程度。
|
||||
|
||||
如果我们为这个等式中所有卧室数和面积的可能权重值作图的话，我们会得到类似下图的图表：
|
||||
|
||||
|
||||
|
||||
因此，我们需要做的只是调整我们的权重，使得我们在图上朝着最低点「走下坡路」。如果我们不断微调权重，一直向最低点移动，那么我们最终不用尝试太多权重就可以到达那里。
|
||||
|
||||
如果你还记得一点微积分的话，你也许记得如果你对一个函数求导，它会告诉你函数任意一点切线的斜率。换句话说，对于图上任意给定的一点，求导能告诉我们哪条是下坡路。我们可以利用这个知识不断走向最低点。
|
||||
|
||||
所以，如果我们对代价函数关于每一个权重求偏导，那么我们就可以从每一个权重中减去该值。这样可以让我们更加接近山底。一直这样做，最终我们将到达底部，得到权重的最优值。（读不懂？不用担心，继续往下读）。
|
||||
|
||||
这种为函数找出最佳权重的方法叫做批量梯度下降（Batch Gradient Descent）。
|
||||
|
||||
当你使用一个机器学习算法库来解决实际问题时，这些都已经为你准备好了。但清楚背后的原理依然是有用的。
|
||||
|
||||
|
||||
|
||||
枚举法
|
||||
|
||||
上面我描述的三步算法被称为多元线性回归（multivariate linear regression）。你在估算一个能够拟合所有房价数据点的直线表达式。然后，你再根据房子可能在你的直线上出现的位置，利用这个等式来估算你从未见过的房屋的价格。这是一个十分强大的想法，你可以用它来解决「实际」问题。
|
||||
|
||||
但是，尽管我展示给你的这种方法可能在简单的情况下有效，它却不能应用于所有情况。原因之一，就是因为房价不会是简简单单一条连续的直线。
|
||||
|
||||
不过幸运的是，有很多办法来处理这种情况。有许多机器学习算法可以处理非线性数据。除此之外，灵活使用线性回归也能拟合更复杂的线条。在所有的情况下，寻找最优权重这一基本思路依然适用。
|
||||
|
||||
**如果你还是无法理解，你可以将 cost 类比为你出错误的程度，而数学科学家找到各种方法来降低这种程度，当程度降到最低时，我们就可以知道我们要求的数值了**
|
||||
|
||||
另外，我忽略了过拟合（overfitting）的概念。得到一组能完美预测原始数据集中房价的权重组很简单，但用这组权重组来预测原始数据集之外的任何新房屋其实都不怎么准确。这也是有许多解决办法的（如[正则化](https://en.wikipedia.org/wiki/Regularization_(mathematics))以及使用[交叉验证](https://en.wikipedia.org/wiki/Cross-validation_(statistics))的数据集）。学习如何应对这一问题，是学习如何成功应用机器学习技术的重点之一。
|
||||
|
||||
换言之，尽管基本概念非常简单，要通过机器学习得到有用的结果还是需要一些技巧和经验的。但是，这是每个开发者都能学会的技巧。
|
||||
|
||||
## 更为智能的预测
|
||||
|
||||
我们通过上一次的函数假设已经得到了一些值。
|
||||
|
||||
```python
|
||||
def estimate_house_sales_price(num_of_bedrooms, sqft, neighborhood):
|
||||
price = 0# a little pinch of this
|
||||
price += num_of_bedrooms * 0.123# and a big pinch of that
|
||||
price += sqft * 0.41# maybe a handful of this
|
||||
price += neighborhood * 0.57
|
||||
return price
|
||||
```
|
||||
|
||||
我们换一个好看的形式给他展示
|
||||
|
||||
|
||||
|
||||
*箭头头表示了函数中的权重。*
|
||||
|
||||
然而，这个算法仅仅能用于处理一些简单的问题，就是那些输入和输出有着线性关系的问题。但如果真实价格和决定因素的关系并不是如此简单，那我们该怎么办？比如说，地段对于大户型和小户型的房屋有很大影响，然而对中等户型的房屋并没有太大影响。那我们该怎么在我们的模型中收集这种复杂的信息呢？
|
||||
|
||||
所以为了更加的智能化，我们可以利用不同的权重来多次运行这个算法，收集各种不同情况下的估价。
|
||||
|
||||
|
||||
|
||||
然后我们把四种整合到一起，就得到一个超级答案
|
||||
|
||||
|
||||
|
||||
这样我们相当于得到了更为准确的答案
|
||||
|
||||
## 神经网络是什么
|
||||
|
||||
|
||||
|
||||
我们把四个超级网络的结合图整体画出来，其实这就是个超级简单的神经网络，虽然我们省略了很多的内容，但是他仍然有了一定的拟合能力
|
||||
|
||||
最重要的是下面的这些内容：
|
||||
|
||||
我们制造了一个权重 × 因素的简单函数，我们把这个函数叫做神经元。
|
||||
|
||||
通过连接许许多多的简单神经元，我们能模拟那些不能被一个神经元所模拟的函数。
|
||||
|
||||
通过对这些神经元的有效拼接，我们可以得到我们想要的结果。
|
||||
|
||||
当我用 pytorch 写对一个函数拟合时
|
||||
|
||||
```python
|
||||
import torch
|
||||
|
||||
x_data =torch.Tensor ([[1.0],[2.0], [3.0]])
|
||||
y_data = torch.Tensor([[2.0], [4.0], [6.0]])
|
||||
|
||||
class LinearModel(torch.nn.Module):
|
||||
def __init__(self):
|
||||
super(LinearModel,self).__init__()
|
||||
self.linear=torch.nn.Linear(1,1)
|
||||
|
||||
def forward(self,x):
|
||||
y_pred=self.linear(x)
|
||||
return y_pred
|
||||
'''
|
||||
线性模型所必须的前馈传播，即 wx+b
|
||||
'''
|
||||
|
||||
model=LinearModel()
|
||||
#对于对象的直接使用
|
||||
criterion=torch.nn.MSELoss()
|
||||
#损失函数的计算
|
||||
optimizer=torch.optim.SGD(model.parameters(),lr=0.01)
|
||||
#优化器
|
||||
for epoch in range(100):
|
||||
y_pred=model(x_data)
|
||||
loss=criterion(y_pred,y_data)
|
||||
print(epoch,loss)
|
||||
|
||||
optimizer.zero_grad()
|
||||
loss.backward()
|
||||
#反向传播
|
||||
optimizer.step()
|
||||
#数值更新
|
||||
print('w=',model.linear.weight.item())
|
||||
print('b=',model.linear.bias.item())
|
||||
|
||||
x_test=torch.Tensor([[4.0]])
|
||||
y_test=model(x_test)
|
||||
print('y_pred=',y_test.data)
|
||||
```
|
||||
|
||||
## 由浅入深（不会涉及代码）
|
||||
|
||||
::: warning 😇 为什么不教我写代码？
|
||||
|
||||
因为你可能看这些基础知识感觉很轻松毫无压力，但是倘若附上很多代码，会一瞬间拉高这里的难度，虽然仅仅只是调包。
|
||||
|
||||
但是我还是会在上面贴上一点代码，但不会有很详细的讲解，因为很多都是调包，没什么好说的，如果你完全零基础，忽略这部分内容即可
|
||||
|
||||
:::
|
||||
|
||||
我们尝试做一个神奇的工作，那就是用神经网络来识别一下手写数字，听上去非常不可思议，但是我要提前说的一点是，图像也不过是数据的组合，每一张图片有不同程度的像素值，如果我们把每一个像素值都当成神经网络的输入值，然后经过一个黑盒，让他识别出一个他认为可能的数字，然后进行纠正即可。
|
||||
|
||||
机器学习只有在你拥有数据（最好是大量数据）的情况下，才能有效。所以，我们需要有大量的手写「8」来开始我们的尝试。幸运的是，恰好有研究人员建立了《MNIST 手写数字数据库》 ，它能助我们一臂之力。MNIST 提供了 60,000 张手写数字的图片，每张图片分辨率为 18×18。即有这么多的数据。
|
||||
|
||||
```python
|
||||
(X_train, y_train), (X_test, y_test) = mnist.load_data()
|
||||
#这段是导入 minist 的方法，但是你看不到，如果你想看到的话需要其他操作
|
||||
```
|
||||
|
||||
我们试着只识别一个数字 8
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
我们把一幅 18×18 像素的图片当成一串含有 324 个数字的数组，就可以把它输入到我们的神经网络里面了：
|
||||
|
||||
|
||||
|
||||
为了更好地操控我们的输入数据，我们把神经网络的输入节点扩大到 324 个：
|
||||
|
||||
|
||||
|
||||
请注意，我们的神经网络现在有了两个输出（而不仅仅是一个房子的价格）。第一个输出会预测图片是「8」的概率，而第二个则输出不是「8」的概率。概括地说，我们就可以依靠多种不同的输出，利用神经网络把要识别的物品进行分组。
|
||||
|
||||
```python
|
||||
model = Sequential([Dense(32, input_shape=(784,)),
|
||||
Activation('relu'),Dense(10),Activation('softmax')])
|
||||
# 你也可以通过 .add() 方法简单地添加层：
|
||||
model = Sequential()
|
||||
model.add(Dense(32, input_dim=784))
|
||||
model.add(Activation('relu'))# 激活函数，你可以理解为加上这个东西可以让他效果更好
|
||||
```
|
||||
|
||||
虽然我们的神经网络要比上次大得多（这次有 324 个输入，上次只有 3 个！），但是现在的计算机一眨眼的功夫就能够对这几百个节点进行运算。当然，你的手机也可以做到。
|
||||
|
||||
现在唯一要做的就是用各种「8」和非「8」的图片来训练我们的神经网络了。当我们喂给神经网络一个「8」的时候，我们会告诉它是「8」的概率是 100% ，而不是「8」的概率是 0%，反之亦然。
|
||||
|
||||
## 仅此而已吗
|
||||
|
||||
当数字并不是正好在图片中央的时候，我们的识别器就完全不工作了。一点点的位移我们的识别器就掀桌子不干了
|
||||
|
||||
|
||||
|
||||
这是因为我们的网络只学习到了正中央的「8」。它并不知道那些偏离中心的「8」长什么样子。它仅仅知道中间是「8」的图片规律。
|
||||
|
||||
在真实世界中，这种识别器好像并没什么卵用。真实世界的问题永远不会如此轻松简单。所以，我们需要知道，当「8」不在图片正中时，怎么才能让我们的神经网络识别它。
|
||||
|
||||
### 暴力方法：更多的数据和更深的网络
|
||||
|
||||
他不能识别靠左靠右的数据？我们都给他！给他任何位置的图片！
|
||||
|
||||
或者说，我们可以用一些库把图片进行一定的裁剪，翻转，甚至添加一些随机噪声。
|
||||
|
||||
如果这些都识别一遍，那不是都懂了吗？
|
||||
|
||||
当然，你同时也需要更强的拟合能力和更深的网络。
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
一层一层堆叠起来，这种方法很早就出现了。
|
||||
|
||||
### 更好的方法？
|
||||
|
||||
你可以通过卷积神经网络进行进一步的处理
|
||||
|
||||
作为人类，你能够直观地感知到图片中存在某种层级（hierarchy）或者是概念结构（conceptual structure）。比如说，你在看
|
||||
|
||||
|
||||
|
||||
你会快速的辨认出一匹马，一个人。
|
||||
|
||||
当这些东西换个地方出现的时候，他该是马还是马该是人还是人。
|
||||
|
||||
但是现在，我们的神经网络做不到这些。它认为「8」出现在图片的不同位置，就是不一样的东西。它不能理解「物体出现在图片的不同位置还是同一个物体」这个概念。这意味着在每种可能出现的位置上，它必须重新学习识别各种物体。
|
||||
|
||||
有人对此做过研究，人的眼睛可能会逐步判断一个物体的信息，比如说你看到一张图片，你会先看颜色，然后看纹理然后再看整体，那么我们需要一种操作来模拟这个过程，我们管这种操作叫卷积操作。
|
||||
|
||||
|
||||
|
||||
### 卷积是如何工作的
|
||||
|
||||
之前我们提到过，我们可以把一整张图片当做一串数字输入到神经网络里面。不同的是，这次我们会利用**平移不变性**的概念来把这件事做得更智能。
|
||||
|
||||
当然也有最新研究说卷积不具备平移不变性，但是我这里使用这个概念是为了大伙更好的理解，举个例子：你将 8 无论放在左上角还是左下角都改变不了他是 8 的事实
|
||||
|
||||
|
||||
|
||||
我们将一张图像分成这么多个小块，然后输入神经网络中的是一个小块。*每次判断一张小图块。*
|
||||
|
||||
然而，有一个非常重要的不同：对于每个小图块，我们会使用同样的神经网络权重。换一句话来说，我们平等对待每一个小图块。如果哪个小图块有任何异常出现，我们就认为这个图块是「异常」
|
||||
|
||||
|
||||
|
||||
换一句话来说，我们从一整张图片开始，最后得到一个稍小一点的数组，里面存储着我们图片中的哪一部分有异常。
|
||||
|
||||
### 池化层
|
||||
|
||||
图像可能特别大。比如说 1024*1024 再来个颜色 RGB
|
||||
|
||||
那就有 1024*1024*3 这么多的数据，这对计算机来说去处理是不可想象的占用计算资源，所以我们需要用一种方式来降低他的计算量并且尽可能地保证丢失的数据不多。
|
||||
|
||||
让我们先来看每个 2×2 的方阵数组，并且留下最大的数：
|
||||
|
||||
|
||||
|
||||
每一波我们只保留一个数，这样就大大减少了图片的计算量了。
|
||||
|
||||
当然你也可以不选最大的，池化有很多种方式。
|
||||
|
||||
这损失也太大了吧！
|
||||
|
||||
这样子搞不会很糟糕么？确实，他会损失大量的数据，也正因如此，我们需要往里面塞大量的数据，有的数据集大的超乎你的想象，你可以自行查阅 imagenet 这种大型数据集。
|
||||
|
||||
当然，还有一些未公开的商用数据集，它们的数量更为庞大，运算起来更为复杂。
|
||||
|
||||
尽管如此，我们依然要感谢先驱，他们让一件事从能变成了不能
|
||||
|
||||
我们也要感谢显卡，这项技术早就出现了但是一直算不了，有了显卡让这件事成为了可能。
|
||||
|
||||
### 作出预测
|
||||
|
||||
到现在为止，我们已经把一个很大的图片缩减到了一个相对较小的数组。
|
||||
|
||||
你猜怎么着？数组就是一串数字而已，所以我们我们可以把这个数组输入到另外一个神经网络里面去。最后的这个神经网络会决定这个图片是否匹配。为了区分它和卷积的不同，我们把它称作「全连接」网络
|
||||
|
||||
|
||||
|
||||
我们的图片处理管道是一系列的步骤：卷积、最大池化，还有最后的「全连接」网络。
|
||||
|
||||
你可以把这些步骤任意组合、堆叠多次，来解决真实世界中的问题！你可以有两层、三层甚至十层卷积层。当你想要缩小你的数据大小时，你也随时可以调用最大池化函数。
|
||||
|
||||
我们解决问题的基本方法，就是从一整个图片开始，一步一步逐渐地分解它，直到你找到了一个单一的结论。你的卷积层越多，你的网络就越能识别出复杂的特征。
|
||||
|
||||
比如说，第一个卷积的步骤可能就是尝试去识别尖锐的东西，而第二个卷积步骤则是通过找到的尖锐物体来找鸟类的喙，最后一步是通过鸟喙来识别整只鸟，以此类推。
|
||||
|
||||
## 结语
|
||||
|
||||
这篇文章仅仅只是粗略的讲述了一些机器学习的一些基本操作，如果你要更深一步学习的话你可能还需要更多的探索。
|
||||
|
||||
## 参考资料
|
||||
|
||||
[machine-learning-for-software-engineers/README-zh-CN.md at master · ZuzooVn/machine-learning-for-sof](https://github.com/ZuzooVn/machine-learning-for-software-engineers/blob/master/README-zh-CN.md#%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E6%A6%82%E8%AE%BA)
|
||||
209
2023旧版内容/4.人工智能/4.3.1.1程序示例——maze迷宫解搜索.md
Normal file
209
2023旧版内容/4.人工智能/4.3.1.1程序示例——maze迷宫解搜索.md
Normal file
@@ -0,0 +1,209 @@
|
||||
# 程序示例——maze 迷宫解搜索
|
||||
|
||||
::: warning 😋
|
||||
阅读程序中涉及搜索算法的部分，然后运行程序，享受机器自动帮你寻找路径的快乐！
|
||||
完成习题
|
||||
:::
|
||||
|
||||
::: tip 📥
|
||||
本节附件下载 <Download url="https://cdn.xyxsw.site/code/1-Lecture.zip"/>
|
||||
:::
|
||||
|
||||
## Node
|
||||
|
||||
```python
|
||||
# 节点类 Node
|
||||
class Node:
|
||||
def __init__(self, state, parent, action):
|
||||
self.state = state # 存储该结点的迷宫状态（即位置）
|
||||
self.parent = parent # 存储父结点
|
||||
self.action = action # 存储采取的行动
|
||||
```
|
||||
|
||||
## 节点复习
|
||||
|
||||
- 节点是一种包含以下数据的数据结构：
|
||||
- 状态——state
|
||||
- 其父节点，通过该父节点生成当前节点——parent node
|
||||
- 应用于父级状态以获取当前节点的操作——action
|
||||
- 从初始状态到该节点的路径成本——path cost
|
||||
|
||||
## 堆栈边域——DFS
|
||||
|
||||
```python
|
||||
class StackFrontier: # 堆栈边域
|
||||
def __init__(self):
|
||||
self.frontier = [] # 边域
|
||||
def add(self, node): # 堆栈添加结点
|
||||
self.frontier.append(node)
|
||||
def contains_state(self, state):
|
||||
return any(node.state == state for node in self.frontier)
|
||||
def empty(self): # 判断边域为空
|
||||
return len(self.frontier) == 0
|
||||
def remove(self): # 移除结点
|
||||
if self.empty():
|
||||
raise Exception("empty frontier")
|
||||
else:
|
||||
node = self.frontier[-1]
|
||||
self.frontier = self.frontier[:-1]
|
||||
return node
|
||||
```
|
||||
|
||||
## 深度优先搜索复习
|
||||
|
||||
深度优先搜索算法在尝试另一个方向之前耗尽每个方向。在这些情况下，边域作为堆栈数据结构进行管理。这里需要记住的流行语是“后进先出”。在将节点添加到边域后，第一个要删除和考虑的节点是最后一个要添加的节点。这导致了一种搜索算法，该算法在第一个方向上尽可能深入，直到尽头，同时将所有其他方向留到后面。“不撞南墙不回头”
|
||||
|
||||
## 队列边域——BFS
|
||||
|
||||
```python
|
||||
class QueueFrontier(StackFrontier): # 队列边域
|
||||
def remove(self):
|
||||
if self.empty():
|
||||
raise Exception("empty frontier")
|
||||
else:
|
||||
node = self.frontier[0]
|
||||
self.frontier = self.frontier[1:]
|
||||
return node
|
||||
```
|
||||
|
||||
## 广度优先搜索复习
|
||||
|
||||
广度优先搜索算法将同时遵循多个方向，在每个可能的方向上迈出一步，然后在每个方向上迈出第二步。在这种情况下，边域作为队列数据结构进行管理。这里需要记住的流行语是“先进先出”。在这种情况下，所有新节点都会排成一行，并根据先添加的节点来考虑节点（先到先得！）。这导致搜索算法在任何一个方向上迈出第二步之前，在每个可能的方向上迈出一步。
|
||||
|
||||
## 迷宫解——Maze_solution
|
||||
|
||||
```python
|
||||
class Maze:
|
||||
def __init__(self, filename): # 读入迷宫图
|
||||
# 读入文件，设置迷宫大小
|
||||
with open(filename) as f:
|
||||
contents = f.read()
|
||||
# 验证起点和目标
|
||||
if contents.count("A") != 1:
|
||||
raise Exception("maze must have exactly one start point")
|
||||
if contents.count("B") != 1:
|
||||
raise Exception("maze must have exactly one goal")
|
||||
# 绘制迷宫大小
|
||||
contents = contents.splitlines()
|
||||
self.height = len(contents)
|
||||
self.width = max(len(line) for line in contents)
|
||||
# 绘制迷宫墙，起点，终点
|
||||
self.walls = []
|
||||
for i in range(self.height):
|
||||
row = []
|
||||
for j in range(self.width):
|
||||
try:
|
||||
if contents[i][j] == "A": # 设置起点
|
||||
self.start = (i, j)
|
||||
row.append(False)
|
||||
elif contents[i][j] == "B":
|
||||
self.goal = (i, j) # 设置终点
|
||||
row.append(False)
|
||||
elif contents[i][j] == " ":
|
||||
row.append(False) # 设置墙体
|
||||
else:
|
||||
row.append(True) # 可移动的点为 True
|
||||
except IndexError:
|
||||
row.append(False)
|
||||
self.walls.append(row)
|
||||
self.solution = None
|
||||
# 打印结果
|
||||
def print(self):
|
||||
...
|
||||
# 寻找邻结点，返回元组 (动作，坐标 (x,y))
|
||||
def neighbors(self, state):
|
||||
row, col = state
|
||||
candidates = [
|
||||
("up", (row - 1, col)),
|
||||
("down", (row + 1, col)),
|
||||
("left", (row, col - 1)),
|
||||
("right", (row, col + 1))
|
||||
]
|
||||
result = []
|
||||
for action, (r, c) in candidates:
|
||||
if 0 <= r < self.height and 0 <= c < self.width and not self.walls[r][c]:
|
||||
result.append((action, (r, c)))
|
||||
return result
|
||||
def solve(self):
|
||||
# 搜索迷宫解
|
||||
self.num_explored = 0 # 已搜索的路径长度
|
||||
# 将边界初始化为起始位置
|
||||
start = Node(state=self.start, parent=None, action=None)
|
||||
frontier = StackFrontier() # 采用 DFS
|
||||
# frontier = QueueFrontier() # 采用 BFS
|
||||
frontier.add(start)
|
||||
# 初始化一个空的探索集
|
||||
self.explored = set() # 存储已搜索的结点
|
||||
# 保持循环直到找到解决方案
|
||||
while True:
|
||||
# 无解情况
|
||||
if frontier.empty():
|
||||
raise Exception("no solution")
|
||||
# 从边界中选择一个节点
|
||||
node = frontier.remove()
|
||||
self.num_explored += 1
|
||||
# 得到解决路径
|
||||
if node.state == self.goal:
|
||||
actions = []
|
||||
cells = []
|
||||
while node.parent is not None: # 遍历父节点得到路径动作
|
||||
actions.append(node.action)
|
||||
cells.append(node.state)
|
||||
node = node.parent
|
||||
actions.reverse()
|
||||
cells.reverse()
|
||||
self.solution = (actions, cells)
|
||||
return
|
||||
# 将节点标记为已探索
|
||||
self.explored.add(node.state)
|
||||
# 将邻居添加到边界（展开节点）
|
||||
for action, state in self.neighbors(node.state):
|
||||
if not frontier.contains_state(state) and state not in self.explored:
|
||||
child = Node(state=state, parent=node, action=action)
|
||||
frontier.add(child)
|
||||
def output_image(self, filename, show_solution=True, show_explored=False):
|
||||
...
|
||||
```
|
||||
|
||||
## Quiz
|
||||
|
||||
1. 在深度优先搜索（DFS）和广度优先搜索（BFS）之间，哪一个会在迷宫中找到更短的路径？
|
||||
1. DFS 将始终找到比 BFS 更短的路径
|
||||
2. BFS 将始终找到比 DFS 更短的路径
|
||||
3. DFS 有时（但并非总是）会找到比 BFS 更短的路径
|
||||
4. BFS 有时（但并非总是）会找到比 DFS 更短的路径
|
||||
5. 两种算法总是能找到相同长度的路径
|
||||
2. 下面的问题将问你关于下面迷宫的问题。灰色单元格表示墙壁。在这个迷宫上运行了一个搜索算法，找到了从 A 点到 B 点的黄色突出显示的路径。在这样做的过程中，红色突出显示的细胞是探索的状态，但并没有达到目标。
|
||||
|
||||
|
||||
|
||||
在讲座中讨论的四种搜索算法中——深度优先搜索、广度优先搜索、曼哈顿距离启发式贪婪最佳优先搜索和曼哈顿距离启发式$A^*$
|
||||
|
||||
搜索——可以使用哪一种（或多种，如果可能的话）？
|
||||
1. 只能是$A^*$
|
||||
2. 只能是贪婪最佳优先搜索
|
||||
3. 只能是 DFS
|
||||
4. 只能是 BFS
|
||||
5. 可能是$A^*$或贪婪最佳优先搜索
|
||||
6. 可以是 DFS 或 BFS
|
||||
7. 可能是四种算法中的任何一种
|
||||
8. 不可能是四种算法中的任何一种
|
||||
3. 为什么有深度限制的极大极小算法有时比没有深度限制的极大极小更可取？
|
||||
1. 深度受限的极大极小算法可以更快地做出决定，因为它探索的状态更少
|
||||
2. 深度受限的极大极小算法将在没有深度限制的情况下实现与极大极小算法相同的输出，但有时会使用较少的内存
|
||||
3. 深度受限的极大极小算法可以通过不探索已知的次优状态来做出更优化的决策
|
||||
4. 深度限制的极小极大值永远不会比没有深度限制的极大极小值更可取
|
||||
4. 下面的问题将询问您关于下面的 Minimax 树，其中绿色向上箭头表示 MAX 玩家，红色向下箭头表示 MIN 玩家。每个叶节点都标有其值。
|
||||
|
||||
|
||||
|
||||
根节点的值是多少？
|
||||
|
||||
1. 2
|
||||
2. 3
|
||||
3. 4
|
||||
4. 5
|
||||
5. 6
|
||||
6. 7
|
||||
7. 8
|
||||
8. 9
|
||||
65
2023旧版内容/4.人工智能/4.3.1.2项目：Tic-Tac-Toe井字棋.md
Normal file
65
2023旧版内容/4.人工智能/4.3.1.2项目：Tic-Tac-Toe井字棋.md
Normal file
@@ -0,0 +1,65 @@
|
||||
# 项目：Tic-Tac-Toe 井字棋
|
||||
|
||||
::: warning 😋 我们为你提供了一个简单有趣的项目，帮助你进行知识巩固，请认真阅读文档内容。
|
||||
|
||||
如果你卡住了，请记得回来阅读文档，或请求身边人的帮助。
|
||||
:::
|
||||
|
||||
::: tip 📥
|
||||
本节附件下载 <Download url="https://cdn.xyxsw.site/code/1-Projects.zip"/>
|
||||
:::
|
||||
|
||||
`pip3 install -r requirements.txt`
|
||||
|
||||
## 理解
|
||||
|
||||
这个项目有两个主要文件：`runner.py` 和 `tictactoe.py`。`tictactoe.py` 包含了玩游戏和做出最佳动作的所有逻辑。`runner.py` 已经为你实现，它包含了运行游戏图形界面的所有代码。一旦你完成了 `tictactoe.py` 中所有必需的功能，你就可以运行 `python runner.py` 来对抗你的人工智能了！
|
||||
|
||||
让我们打开 `tictactoe.py` 来了解所提供的内容。首先，我们定义了三个变量：X、O 和 EMPTY，以表示游戏的可能移动。
|
||||
|
||||
函数 `initial_state` 返回游戏的启动状态。对于这个问题，我们选择将游戏状态表示为三个列表的列表（表示棋盘的三行），其中每个内部列表包含三个值，即 X、O 或 EMPTY。以下是我们留给你实现的功能！
|
||||
|
||||
## 说明
|
||||
|
||||
实现 `player`, `actions`, `result`, `winner`, `terminal`, `utility`, 以及 `minimax`.
|
||||
|
||||
- `player` 函数应该以棋盘状态作为输入，并返回轮到哪个玩家（X 或 O）。
|
||||
|
||||
- 在初始游戏状态下，X 获得第一步。随后，玩家交替进行每一个动作。
|
||||
- 如果提供结束棋盘状态作为输入（即游戏已经结束），则任何返回值都是可接受的。
|
||||
- `actions` 函数应该返回一组在给定的棋盘状态上可以采取的所有可能的操作。
|
||||
|
||||
- 每个动作都应该表示为元组 `(i，j)`，其中 `i` 对应于移动的行（0、1 或 2），`j` 对应于行中的哪个单元格对应于移动（也是 0、1、或 2）。
|
||||
- 可能的移动是棋盘上任何没有 X 或 O 的单元格。
|
||||
- 如果提供结束棋盘状态作为输入，则任何返回值都是可接受的。
|
||||
- `result` 函数以一个棋盘状态和一个动作作为输入，并且应该返回一个新的棋盘状态，而不修改原始棋盘。
|
||||
|
||||
- 如果 `action` 函数接受了一个无效的动作，你的程序应该<u>raise an exception</u>.
|
||||
- 返回的棋盘状态应该是从原始输入棋盘，并让轮到它的玩家在输入动作指示的单元格处移动所产生的棋盘。
|
||||
- 重要的是，原始棋盘应该保持不变：因为 Minimax 最终需要在计算过程中考虑许多不同的棋盘状态。这意味着简单地更新棋盘上的单元格本身并不是 `result` 函数的正确实现。在做出任何更改之前，你可能需要先对棋盘状态进行<u>deep copy</u>。
|
||||
- `winner` 函数应该接受一个棋盘作为输入，如果游戏结束，则返回游戏的获胜者。
|
||||
|
||||
- 如果 X 玩家赢得了游戏，函数应该返回 X。如果 O 玩家赢得了比赛，函数应该返回 O。
|
||||
- 一个人可以通过水平、垂直或对角连续三次移动赢得比赛。
|
||||
- 你可以认为最多会有一个赢家（也就是说，没有一个棋盘会同时有两个玩家连着三个，因为这将是一个无效的棋盘状态）。
|
||||
- 如果游戏没有赢家（要么是因为游戏正在进行，要么是因为比赛以平局结束），函数应该返回 `None`。
|
||||
- `terminal` 函数应该接受一个棋盘作为输入，并返回一个布尔值，指示游戏是否结束。
|
||||
|
||||
- 如果游戏结束，要么是因为有人赢得了游戏，要么是由于所有单元格都已填充而没有人获胜，则函数应返回 `True`。
|
||||
- 否则，如果游戏仍在进行中，则函数应返回 `False`。
|
||||
- `utility` 函数应接受结束棋盘状态作为输入，并输出该棋盘的分数。
|
||||
|
||||
- 如果 X 赢得了比赛，则分数为 1。如果 O 赢得了比赛，则分数为 -1。如果比赛以平局结束，则分数为 0。
|
||||
- 你可以假设只有当 `terminal(board)` 为 True 时，才会在棋盘上调用 `utility`。
|
||||
- `minimax` 函数应该以一个棋盘作为输入，并返回玩家在该棋盘上移动的最佳移动。
|
||||
|
||||
- 返回的移动应该是最佳动作 `(i，j)`，这是棋盘上允许的动作之一。如果多次移动都是同样最佳的，那么这些移动中的任何一次都是可以接受的。
|
||||
- 如果该棋盘是结束棋盘状态，则 `minimax` 函数应返回 `None`。
|
||||
对于所有接受棋盘作为输入的函数，你可以假设它是一个有效的棋盘（即，它是包含三行的列表，每行都有三个值 X、O 或 EMPTY）。你不应该修改所提供的函数声明（每个函数的参数的顺序或数量）。、
|
||||
一旦所有功能都得到了正确的实现，你就应该能够运行 `python runner.py` 并与你的人工智能进行比赛。而且，由于井字棋是双方最佳比赛的平局，你永远不应该能够击败人工智能（尽管如果你打得不好，它可能会打败你！）
|
||||
|
||||
## 提示
|
||||
|
||||
- 如果你想在不同的 Python 文件中测试你的函数，你可以用类似于 `from tictactoe import initial_state` 的代码来导入它们。
|
||||
- 欢迎在 `tictactoe.py` 中添加其他辅助函数，前提是它们的名称不会与模块中已有的函数或变量名称冲突。
|
||||
- alpha-beta 剪枝是可选的，这可能会让你的人工智能运行更高效！
|
||||
356
2023旧版内容/4.人工智能/4.3.1搜索.md
Normal file
356
2023旧版内容/4.人工智能/4.3.1搜索.md
Normal file
@@ -0,0 +1,356 @@
|
||||
# 搜索
|
||||
|
||||
::: warning 😅 在我们日常生活中，其实有非常多的地方使用了所谓的 AI 算法，只是我们通常没有察觉。
|
||||
|
||||
比如美团的外卖程序里面，可以看到外卖员到达你所在的位置的路线，它是如何规划出相关路线的呢？
|
||||
|
||||
在我们和电脑下围棋下五子棋的时候，他是如何“思考”的呢？希望你在阅读完本章内容之后，可以有一个最基本的理解。并且，我们还会给你留下一个井字棋的小任务，可以让你的电脑和你下井字棋，是不是很 cool
|
||||
|
||||
让我们现在开始吧！
|
||||
:::
|
||||
|
||||
## 基本定义
|
||||
|
||||
::: warning 🤔 也许第一次看会觉得云里雾里，没有必要全部记住所有的概念。可以先大致浏览一遍之后，再后续的代码中与概念进行结合，相信你会有更深入的理解
|
||||
:::
|
||||
|
||||
> 即检索存储在某个[数据结构](https://zh.wikipedia.org/wiki/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84)中的信息，或者在问题域的搜索空间中计算的信息。 --wiki
|
||||
|
||||
从本质上来说，你将搜索问题理解为一个函数，那么它的输入将会是你用计算机的数据结构或计算机数据所构成的初始状态以及你期望他达成的目标状态，搜索问题将尝试从中得到解决方案。
|
||||
|
||||
导航是使用搜索算法的一个典型的搜索，它接收您的当前位置和目的地作为输入，并根据搜索算法返回建议的路径。
|
||||
|
||||
|
||||
|
||||
在计算机科学中，还有许多其他形式的搜索问题，比如谜题或迷宫。
|
||||
|
||||
<table>
|
||||
<tr>
|
||||
<td><img src=https://cdn.xyxsw.site/SYw4bOzqAo65PQxZQLucbZAxnHd.png width=520></td>
|
||||
<td><img src=https://cdn.xyxsw.site/LPgEbVQg2oZBSexmGWwcwfbdnVd.png width=520></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
## 举个例子
|
||||
|
||||
要找到一个数字华容道谜题的解决方案，需要使用搜索算法。
|
||||
|
||||
- 智能主体 (Agent)
|
||||
|
||||
感知其环境并对该环境采取行动的实体。
|
||||
|
||||
例如，在导航应用程序中，智能主体将是一辆汽车的代表，它需要决定采取哪些行动才能到达目的地。
|
||||
|
||||
- 状态 (State)
|
||||
|
||||
智能主体在其环境中的配置。
|
||||
|
||||
例如，在一个数字华容道谜题中，一个状态是所有数字排列在棋盘上的任何一种方式。
|
||||
|
||||
- 初始状态（Initial State）
|
||||
|
||||
搜索算法开始的状态。在导航应用程序中，这将是当前位置。
|
||||
|
||||
|
||||
|
||||
- 动作 (Action)
|
||||
|
||||
一个状态可以做出的选择。更确切地说，动作可以定义为一个函数。当接收到状态$s$作为输入时，$Actions(s)$将返回可在状态$s$ 中执行的一组操作作为输出。
|
||||
|
||||
例如，在一个数字华容道中，给定状态的操作是您可以在当前配置中滑动方块的方式。
|
||||
|
||||
|
||||
|
||||
- 过渡模型 (Transition Model)
|
||||
|
||||
对在任何状态下执行任何适用操作所产生的状态的描述。
|
||||
|
||||
更确切地说，过渡模型可以定义为一个函数。
|
||||
|
||||
在接收到状态$s$和动作$a$作为输入时，$Results(s，a)$返回在状态$s$中执行动作$a$ 所产生的状态。
|
||||
|
||||
例如，给定数字华容道的特定配置（状态$s$），在任何方向上移动正方形（动作$a$）将导致谜题的新配置（新状态）。
|
||||
|
||||
|
||||
|
||||
- 状态空间 (State Space)
|
||||
|
||||
通过一系列的操作目标从初始状态可达到的所有状态的集合。
|
||||
|
||||
例如，在一个数字华容道谜题中，状态空间由所有$\frac{16!}{2}$种配置，可以从任何初始状态达到。状态空间可以可视化为有向图，其中状态表示为节点，动作表示为节点之间的箭头。
|
||||
|
||||
|
||||
|
||||
- 目标测试 (Goal Test)
|
||||
|
||||
确定给定状态是否为目标状态的条件。例如，在导航应用程序中，目标测试将是智能主体的当前位置是否在目的地。如果是，问题解决了。如果不是，我们将继续搜索。
|
||||
|
||||
- 路径成本 (Path Cost)
|
||||
|
||||
完成给定路径相关的代价。例如，导航应用程序并不是简单地让你达到目标；它这样做的同时最大限度地减少了路径成本，为您找到了达到目标状态的最快方法。
|
||||
|
||||
## 解决搜索问题
|
||||
|
||||
### 解 (solution)
|
||||
|
||||
从初始状态到目标状态的一系列动作。
|
||||
|
||||
### 最优解 (Optimal Solution)
|
||||
|
||||
- 在所有解决方案中路径成本最低的解决方案。
|
||||
|
||||
- 在搜索过程中，数据通常存储在**节点 (Node)** 中，节点是一种包含以下数据的数据结构：
|
||||
|
||||
- 状态——state
|
||||
- 其父节点，通过该父节点生成当前节点——parent node
|
||||
- 应用于父级状态以获取当前节点的操作——action
|
||||
- 从初始状态到该节点的路径成本——path cost
|
||||
- 节点包含的信息使它们对于搜索算法非常有用。
|
||||
|
||||
它们包含一个状态，可以使用目标测试来检查该状态是否为最终状态。
|
||||
|
||||
如果是，则可以将节点的路径成本与其他节点的路径代价进行比较，从而可以选择最佳解决方案。
|
||||
|
||||
一旦选择了节点，通过存储父节点和从父节点到当前节点的动作，就可以追溯从初始状态到该节点的每一步，而这一系列动作就是解决方案。
|
||||
|
||||
然而，节点只是一个数据结构——它们不搜索，而是保存信息。为了实际搜索，我们使用了边域 (frontier)，即“管理”节点的机制。边域首先包含一个初始状态和一组空的已探索项目（探索集），然后重复以下操作，直到找到解决方案：
|
||||
|
||||
重复：
|
||||
|
||||
1. 如果边域为空
|
||||
- 停止，搜索问题无解
|
||||
2. 从边域中删除一个节点。这是将要考虑的节点。
|
||||
3. 如果节点包含目标状态。
|
||||
- 返回解决方案，停止
|
||||
否则:
|
||||
- 展开节点（找到可以从该节点到达的所有新节点），并将生成的节点添加到边域。
|
||||
- 将当前节点添加到探索集。
|
||||
|
||||
<table>
|
||||
<tr>
|
||||
<td><img src=https://cdn.xyxsw.site/K53FbGmswoM7JAxqJZxcQEjdnES.png width=520></td>
|
||||
<td><img src=https://cdn.xyxsw.site/THhpbemEHoxl80xHeTjc9d35nVh.png width=520></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
边域从节点 A 初始化开始
|
||||
|
||||
1. 取出边域中的节点 A，展开节点 A，将节点 B 添加到边域。
|
||||
2. 取出节点 B，展开，添加......
|
||||
3. 到达目标节点，停止，返回解决方案
|
||||
|
||||
<table>
|
||||
<tr>
|
||||
<td><img src=https://cdn.xyxsw.site/XmnObIGaUoF4ssxkgzUc4vTUnmf.png width=520></td>
|
||||
<td><img src=https://cdn.xyxsw.site/Wsntb9rLwogdAKxpJgLchrI8nae.png width=520></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
会出现什么问题？节点 A-> 节点 B-> 节点 A->......-> 节点 A。我们需要一个探索集，记录已搜索的节点！
|
||||
|
||||
### 不知情搜索 (Uninformed Search)
|
||||
|
||||
在之前对边域的描述中，有一件事没有被提及。在上面伪代码的第 1 阶段，应该删除哪个节点？这种选择对解决方案的质量和实现速度有影响。关于应该首先考虑哪些节点的问题，有多种方法，其中两种可以用堆栈（深度优先搜索）和队列（广度优先搜索）的数据结构来表示。
|
||||
|
||||
#### 深度优先搜索 (Depth-First Search)
|
||||
|
||||
深度优先搜索算法在尝试另一个方向之前耗尽每个方向。在这些情况下，边域作为堆栈数据结构进行管理。这里需要记住的流行语是“后进先出”。在将节点添加到边域后，第一个要删除和考虑的节点是最后一个要添加的节点。这导致了一种搜索算法，该算法在第一个方向上尽可能深入，直到尽头，同时将所有其他方向留到后面。“不撞南墙不回头”
|
||||
|
||||
（一个例子：以你正在寻找钥匙的情况为例。在深度优先搜索方法中，如果你选择从裤子里搜索开始，你会先仔细检查每一个口袋，清空每个口袋，仔细检查里面的东西。只有当你完全筋疲力尽时，你才会停止在裤子里搜索，开始在其他地方搜索。）
|
||||
|
||||
- 优点
|
||||
- 在最好的情况下，这个算法是最快的。如果它“运气好”，并且总是（偶然）选择正确的解决方案路径，那么深度优先搜索需要尽可能少的时间来找到解决方案。
|
||||
- 缺点
|
||||
- 所找到的解决方案可能不是最优的。
|
||||
- 在最坏的情况下，该算法将在找到解决方案之前探索每一条可能的路径，从而在到达解决方案之前花费尽可能长的时间。
|
||||
|
||||
<table>
|
||||
<tr>
|
||||
<td><img src=https://cdn.xyxsw.site/SGVWbCcTlobQwJxSjKvcNyJAnEG.png width=520></td>
|
||||
<td><img src=https://cdn.xyxsw.site/Vv9Sb26QfoMrkqx5apycIYPJnlf.png width=520></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<table>
|
||||
<tr>
|
||||
<td><img src=https://cdn.xyxsw.site/Gjd5bpdpcoIxGtxcUJ0c2OVfnOf.png width=520></td>
|
||||
<td><img src=https://cdn.xyxsw.site/M2vZbA5hpoT9RExuAGwcBHF1nmh.png width=520></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
- 代码实现
|
||||
|
||||
```python
|
||||
def remove(self):
|
||||
if self.empty():
|
||||
raise Exception("empty frontier")
|
||||
else:
|
||||
node = self.frontier[-1]
|
||||
self.frontier = self.frontier[:-1]
|
||||
return node
|
||||
```
|
||||
|
||||
#### 广度优先搜索 (Breadth-First Search)
|
||||
|
||||
广度优先搜索算法将同时遵循多个方向，在每个可能的方向上迈出一步，然后在每个方向上迈出第二步。在这种情况下，边域作为队列数据结构进行管理。这里需要记住的流行语是“先进先出”。在这种情况下，所有新节点都会排成一行，并根据先添加的节点来考虑节点（先到先得！）。这导致搜索算法在任何一个方向上迈出第二步之前，在每个可能的方向上迈出一步。
|
||||
|
||||
（一个例子：假设你正在寻找钥匙。在这种情况下，如果你从裤子开始，你会看你的右口袋。之后，你会在一个抽屉里看一眼，而不是看你的左口袋。然后在桌子上。以此类推，在你能想到的每个地方。只有在你用完所有位置后，你才会回到你的裤子上，在下一个口袋里找。）
|
||||
|
||||
- 优点
|
||||
- 该算法可以保证找到最优解。
|
||||
- 缺点
|
||||
- 几乎可以保证该算法的运行时间会比最短时间更长。
|
||||
- 在最坏的情况下，这种算法需要尽可能长的时间才能运行。
|
||||
|
||||
<table>
|
||||
<tr>
|
||||
<td><img src=https://cdn.xyxsw.site/S6SRbMUrcoYQCYxZGgJczkdcnBP.png width=520></td>
|
||||
<td><img src=https://cdn.xyxsw.site/Xg7Qbv59IoQB3bxPFO1ceXgRnkf.png width=520></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<table>
|
||||
<tr>
|
||||
<td><img src=https://cdn.xyxsw.site/X34Rb5R7AonUg3xYs7DcQzSfndg.png width=520></td>
|
||||
<td><img src=https://cdn.xyxsw.site/PQeZbJv3Bom6NYxa6lccT084nFn.png width=520></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
代码实现
|
||||
|
||||
```python
|
||||
def remove(self):
|
||||
if self.empty():
|
||||
raise Exception("empty frontier")
|
||||
else:
|
||||
node = self.frontier[0]
|
||||
self.frontier = self.frontier[1:]
|
||||
return node
|
||||
```
|
||||
|
||||
## 知情搜索 (Informed Search)
|
||||
|
||||
广度优先和深度优先都是不知情的搜索算法。也就是说，这些算法没有利用他们没有通过自己的探索获得的关于问题的任何知识。然而，大多数情况下，关于这个问题的一些知识实际上是可用的。例如，当人类进入一个路口时，人类可以看到哪条路沿着解决方案的大致方向前进，哪条路没有。人工智能也可以这样做。一种考虑额外知识以试图提高性能的算法被称为知情搜索算法。
|
||||
|
||||
### 贪婪最佳优先搜索 (Greedy Best-First Search)
|
||||
|
||||
贪婪最佳优先搜索扩展最接近目标的节点，如启发式函数$h(n)$所确定的。顾名思义，该函数估计下一个节点离目标有多近，但可能会出错。贪婪最佳优先算法的效率取决于启发式函数的好坏。例如，在迷宫中，算法可以使用启发式函数，该函数依赖于可能节点和迷宫末端之间的曼哈顿距离。曼哈顿距离忽略了墙壁，并计算了从一个位置到目标位置需要向上、向下或向两侧走多少步。这是一个简单的估计，可以基于当前位置和目标位置的$(x，y)$坐标导出。
|
||||
|
||||
|
||||
|
||||
然而，重要的是要强调，与任何启发式算法一样，它可能会出错，并导致算法走上比其他情况下更慢的道路。不知情的搜索算法有可能更快地提供一个更好的解决方案，但它比知情算法更不可能这样。
|
||||
|
||||
<table>
|
||||
<tr>
|
||||
<td><img src=https://cdn.xyxsw.site/SU2DbQeN2oxs5ex3K3NcMaJfnch.png width=520></td>
|
||||
<td><img src=https://cdn.xyxsw.site/HkvdbcEdmo6RtjxOqqic31XFnSh.png width=520></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
### $A^*$搜索
|
||||
|
||||
作为贪婪最佳优先算法的一种发展，$A^{*}$ 搜索不仅考虑了从当前位置到目标的估计成本 $h(n)$ ，还考虑了直到当前位置为止累积的成本 $g(n)$ 。通过组合这两个值，该算法可以更准确地确定解决方案的成本并在旅途中优化其选择。该算法跟踪（到目前为止的路径成本 + 到目标的估计成本， $g(n)+h(n)$ ），一旦它超过了之前某个选项的估计成本，该算法将放弃当前路径并返回到之前的选项，从而防止自己沿着 $h(n)$ 错误地标记为最佳的却长而低效的路径前进。
|
||||
|
||||
然而，由于这种算法也依赖于启发式，所以它依赖它所使用的启发式。在某些情况下，它可能比贪婪的最佳第一搜索甚至不知情的算法效率更低。对于最佳的$A^*$搜索，启发式函数$h(n)$应该：
|
||||
|
||||
- 可接受，从未高估真实成本。
|
||||
- 一致性，这意味着从新节点到目标的估计路径成本加上从先前节点转换到该新节点的成本应该大于或等于先前节点到目标的估计路径成本。用方程的形式表示，$h(n)$是一致的，如果对于每个节点 n$和后续节点 n'$,从 n$到$n'$的步长为 c$,满足$h(n) ≤ h(n') + c$.
|
||||
|
||||
<table>
|
||||
<tr>
|
||||
<td><img src=https://cdn.xyxsw.site/BbIiba1pwo3uI7x4k7QcwicznGc.png width=520></td>
|
||||
<td><img src=https://cdn.xyxsw.site/HhG9bcJP2okKMMxY0FGclP0AnXY.png width=520></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
## 对抗性搜索
|
||||
|
||||
尽管之前我们讨论过需要找到问题答案的算法，但在对抗性搜索中，算法面对的是试图实现相反目标的对手。通常，在游戏中会遇到使用对抗性搜索的人工智能，比如井字游戏。
|
||||
|
||||
### 极大极小算法 (Minimax)
|
||||
|
||||
- 作为对抗性搜索中的一种算法，Minimax 将获胜条件表示为$(-1)$表示为一方，$(+1)$表示为另一方。进一步的行动将受到这些条件的驱动，最小化的一方试图获得最低分数，而最大化的一方则试图获得最高分数。
|
||||
|
||||
|
||||
|
||||
#### 井字棋 AI 为例
|
||||
|
||||
- $s_0$: 初始状态（在我们的情况下，是一个空的 3X3 棋盘）
|
||||
|
||||
|
||||
|
||||
- $Players(s)$: 一个函数，在给定状态$s$的情况下，返回轮到哪个玩家（X 或 O）。
|
||||
|
||||
|
||||
|
||||
- $Actions(s)$: 一个函数，在给定状态$s$的情况下，返回该状态下的所有合法动作（棋盘上哪些位置是空的）。
|
||||
|
||||
|
||||
|
||||
- $Result(s, a)$: 一个函数，在给定状态$s$和操作$a$的情况下，返回一个新状态。这是在状态$s$上执行动作$a$（在游戏中移动）所产生的棋盘。
|
||||
|
||||
|
||||
|
||||
- $Terminal(s)$: 一个函数，在给定状态$s$的情况下，检查这是否是游戏的最后一步，即是否有人赢了或打成平手。如果游戏已结束，则返回 True，否则返回 False。
|
||||
|
||||
|
||||
|
||||
- $Utility(s)$: 一个函数，在给定终端状态 s 的情况下，返回状态的效用值：$-1、0 或 1$。
|
||||
|
||||
|
||||
|
||||
算法的工作原理：
|
||||
|
||||
- 该算法递归地模拟从当前状态开始直到达到终端状态为止可能发生的所有游戏状态。每个终端状态的值为$(-1)$、$0$或$(+1)$。
|
||||
|
||||
|
||||
- 根据轮到谁的状态，算法可以知道当前玩家在最佳游戏时是否会选择导致状态值更低或更高的动作。
|
||||
|
||||
通过这种方式，在最小化和最大化之间交替，算法为每个可能的动作产生的状态创建值。举一个更具体的例子，我们可以想象，最大化的玩家在每一个回合都会问：“如果我采取这个行动，就会产生一个新的状态。如果最小化的玩家发挥得最好，那么该玩家可以采取什么行动来达到最低值？”
|
||||
|
||||
然而，为了回答这个问题，最大化玩家必须问：“要想知道最小化玩家会做什么，我需要在最小化者的脑海中模拟同样的过程：最小化玩家会试图问：‘如果我采取这个动作，最大化玩家可以采取什么动作来达到最高值？’”
|
||||
|
||||
这是一个递归过程，你可能很难理解它；看看下面的伪代码会有所帮助。最终，通过这个递归推理过程，最大化玩家为每个状态生成值，这些值可能是当前状态下所有可能的操作所产生的。
|
||||
|
||||
在得到这些值之后，最大化的玩家会选择最高的一个。
|
||||
|
||||
|
||||
|
||||
具体算法：
|
||||
|
||||
- 给定状态 $s$
|
||||
- 最大化玩家在$Actions(s)$中选择动作$a$，该动作产生$Min-value(Result(s,a))$ 的最高值。
|
||||
- 最小化玩家在$Actions(s)$中选择动作$a$，该动作产生$Max-value(Result(s,a))$ 的最小值。
|
||||
|
||||
```txt
|
||||
Function Max-Value(state):
|
||||
v=-∞
|
||||
if Terminal(state):
|
||||
return Utility(state)
|
||||
for action in Actions(state):
|
||||
v = Max(v, Min-Value(Result(state, action)))
|
||||
return v
|
||||
Function Min-Value(state):
|
||||
v=+∞
|
||||
if Terminal(state):
|
||||
return Utility(state)
|
||||
for action in Actions(state):
|
||||
v = Min(v, Max-Value(Result(state, action)))
|
||||
return v
|
||||
```
|
||||
|
||||
不会理解递归？也许你需要看看这个：[阶段二：递归操作](../3.%E7%BC%96%E7%A8%8B%E6%80%9D%E7%BB%B4%E4%BD%93%E7%B3%BB%E6%9E%84%E5%BB%BA/3.6.4.2%E9%98%B6%E6%AE%B5%E4%BA%8C%EF%BC%9A%E9%80%92%E5%BD%92%E6%93%8D%E4%BD%9C.md)
|
||||
|
||||
### $\alpha$-$\beta$剪枝 (Alpha-Beta Pruning)
|
||||
|
||||
作为一种优化 Minimax 的方法，Alpha-Beta 剪枝跳过了一些明显不利的递归计算。在确定了一个动作的价值后，如果有初步证据表明接下来的动作可以让对手获得比已经确定的动作更好的分数，那么就没有必要进一步调查这个动作，因为它肯定比之前确定的动作不利。
|
||||
|
||||
这一点最容易用一个例子来说明：最大化的玩家知道，在下一步，最小化的玩家将试图获得最低分数。假设最大化玩家有三个可能的动作，第一个动作的值为 4。然后玩家开始为下一个动作生成值。要做到这一点，如果当前玩家做出这个动作，玩家会生成最小化者动作的值，并且知道最小化者会选择最低的一个。然而，在完成最小化器所有可能动作的计算之前，玩家会看到其中一个选项的值为 3。这意味着没有理由继续探索最小化玩家的其他可能行动。尚未赋值的动作的值无关紧要，无论是 10 还是（-10）。如果该值为 10，则最小化器将选择最低选项 3，该选项已经比预先设定的 4 差。如果尚未估价的行动结果是（-10），那么最小化者将选择（-10）这一选项，这对最大化者来说更加不利。因此，在这一点上为最小化者计算额外的可能动作与最大化者无关，因为最大化玩家已经有了一个明确的更好的选择，其值为 4。
|
||||
|
||||
|
||||
|
||||
### 深度限制的极大极小算法 (Depth-Limited Minimax)
|
||||
|
||||
- 总共有$255168$个可能的井字棋游戏，以及有$10^{29000}$个可能的国际象棋中游戏。到目前为止，最小最大算法需要生成从某个点到**终端条件**的所有假设游戏状态。虽然计算所有的井字棋游戏状态对现代计算机来说并不是一个挑战，但目前用来计算国际象棋是不可能的。
|
||||
|
||||
深度限制的 Minimax 算法在停止之前只考虑预先定义的移动次数，而从未达到终端状态。然而，这不允许获得每个动作的精确值，因为假设的游戏还没有结束。为了解决这个问题，深度限制 Minimax 依赖于一个评估函数，该函数从给定状态估计游戏的预期效用，或者换句话说，为状态赋值。例如，在国际象棋游戏中，效用函数会将棋盘的当前配置作为输入，尝试评估其预期效用（基于每个玩家拥有的棋子及其在棋盘上的位置），然后返回一个正值或负值，表示棋盘对一个玩家对另一个玩家的有利程度。这些值可以用来决定正确的操作，并且评估函数越好，依赖它的 Minimax 算法就越好。
|
||||
417
2023旧版内容/4.人工智能/4.3.2.1程序示例——命题逻辑与模型检测.md
Normal file
417
2023旧版内容/4.人工智能/4.3.2.1程序示例——命题逻辑与模型检测.md
Normal file
@@ -0,0 +1,417 @@
|
||||
# 程序示例——命题逻辑与模型检测
|
||||
|
||||
::: warning 😋
|
||||
阅读程序中涉及命题逻辑的部分，然后“玩一玩”程序！
|
||||
|
||||
完成习题
|
||||
:::
|
||||
|
||||
::: tip 📥
|
||||
本节附件下载 <Download url="https://cdn.xyxsw.site/code/2-Lecture.zip"/>
|
||||
:::
|
||||
|
||||
## Sentence——父类
|
||||
|
||||
```python
|
||||
class Sentence(): # 父类
|
||||
def evaluate(self, model):
|
||||
"""计算逻辑表达式的值"""
|
||||
raise Exception("nothing to evaluate")
|
||||
def formula(self):
|
||||
"""返回表示逻辑表达式的字符串形式。"""
|
||||
return ""
|
||||
def symbols(self):
|
||||
"""返回逻辑表达式中所有命题符号的集合。"""
|
||||
return set()
|
||||
@classmethod # @classmethod 装饰器 使得类方法可以在类上被调用 Sentence.validate(...)
|
||||
def validate(cls, sentence):
|
||||
"""验证操作数是否是 Sentence 或其子类"""
|
||||
if not isinstance(sentence, Sentence):
|
||||
raise TypeError("must be a logical sentence")
|
||||
@classmethod # @classmethod 装饰器 使得类方法可以在类上被调用 Sentence.parenthesize(...)
|
||||
def parenthesize(cls, s):
|
||||
"""如果表达式尚未加圆括号，则加圆括号。"""
|
||||
def balanced(s):
|
||||
"""检查字符串是否有配对的括号。"""
|
||||
count = 0
|
||||
for c in s:
|
||||
if c == "(":
|
||||
count += 1
|
||||
elif c == ")":
|
||||
if count <= 0:
|
||||
return False
|
||||
count -= 1
|
||||
return count == 0
|
||||
if not len(s) or s.isalpha() or (s[0] == "(" and s[-1] == ")" and balanced(s[1:-1])):
|
||||
return s
|
||||
else:
|
||||
return f"({s})"
|
||||
```
|
||||
|
||||
## Symbol——命题符号类
|
||||
|
||||
```python
|
||||
class Symbol(Sentence):
|
||||
def __init__(self, name):
|
||||
"""初始化命题符号"""
|
||||
self.name = name
|
||||
def __eq__(self, other):
|
||||
"""定义命题符号的相等"""
|
||||
return isinstance(other, Symbol) and self.name == other.name
|
||||
...
|
||||
def evaluate(self, model):
|
||||
"""命题符号在模型中赋值"""
|
||||
try:
|
||||
return bool(model[self.name])
|
||||
except KeyError:
|
||||
raise EvaluationException(f"variable {self.name} not in model")
|
||||
def formula(self):
|
||||
"""返回表示命题符号的字符串形式。"""
|
||||
return self.name
|
||||
def symbols(self):
|
||||
"""返回命题符号的集合。"""
|
||||
return {self.name}
|
||||
```
|
||||
|
||||
## Not——逻辑非类
|
||||
|
||||
```python
|
||||
class Not(Sentence):
|
||||
def __init__(self, operand):
|
||||
"""验证操作数是否是 Sentence 或其子类"""
|
||||
Sentence.validate(operand)
|
||||
self.operand = operand
|
||||
def __eq__(self, other):
|
||||
"""定义相等"""
|
||||
return isinstance(other, Not) and self.operand == other.operand
|
||||
...
|
||||
def evaluate(self, model):
|
||||
"""逻辑非在模型中的赋值"""
|
||||
return not self.operand.evaluate(model)
|
||||
def formula(self):
|
||||
"""返回表示逻辑非的字符串形式"""
|
||||
return "¬" + Sentence.parenthesize(self.operand.formula())
|
||||
def symbols(self):
|
||||
"""返回逻辑非中的命题符号的集合"""
|
||||
return self.operand.symbols()
|
||||
```
|
||||
|
||||
## And——逻辑乘类
|
||||
|
||||
```python
|
||||
class And(Sentence):
|
||||
def __init__(self, *conjuncts):
|
||||
for conjunct in conjuncts:
|
||||
"""验证操作数是否是 Sentence 或其子类"""
|
||||
Sentence.validate(conjunct)
|
||||
self.conjuncts = list(conjuncts)
|
||||
def __eq__(self, other):
|
||||
"""定义相等"""
|
||||
return isinstance(other, And) and self.conjuncts == other.conjuncts
|
||||
def add(self, conjunct):
|
||||
"""添加命题"""
|
||||
Sentence.validate(conjunct)
|
||||
self.conjuncts.append(conjunct)
|
||||
def evaluate(self, model):
|
||||
"""逻辑乘在模型中的赋值"""
|
||||
return all(conjunct.evaluate(model) for conjunct in self.conjuncts)
|
||||
def formula(self):
|
||||
"""返回表示逻辑乘的字符串形式"""
|
||||
if len(self.conjuncts) == 1:
|
||||
return self.conjuncts[0].formula()
|
||||
return " ∧ ".join([Sentence.parenthesize(conjunct.formula())
|
||||
for conjunct in self.conjuncts])
|
||||
def symbols(self):
|
||||
""""返回逻辑乘中的所有命题符号的集合"""
|
||||
return set.union(*[conjunct.symbols() for conjunct in self.conjuncts])
|
||||
```
|
||||
|
||||
## Or——逻辑和类
|
||||
|
||||
```python
|
||||
class Or(Sentence):
|
||||
def __init__(self, *disjuncts):
|
||||
for disjunct in disjuncts:
|
||||
"""验证操作数是否是 Sentence 或其子类"""
|
||||
Sentence.validate(disjunct)
|
||||
self.disjuncts = list(disjuncts)
|
||||
def __eq__(self, other):
|
||||
"""定义相等"""
|
||||
return isinstance(other, Or) and self.disjuncts == other.disjuncts
|
||||
...
|
||||
def evaluate(self, model):
|
||||
"""逻辑和在模型中的赋值"""
|
||||
return any(disjunct.evaluate(model) for disjunct in self.disjuncts)
|
||||
def formula(self):
|
||||
"""返回表示逻辑和的字符串形式"""
|
||||
if len(self.disjuncts) == 1:
|
||||
return self.disjuncts[0].formula()
|
||||
return " ∨ ".join([Sentence.parenthesize(disjunct.formula())
|
||||
for disjunct in self.disjuncts])
|
||||
def symbols(self):
|
||||
""""返回逻辑乘中的所有命题符号的集合"""
|
||||
return set.union(*[disjunct.symbols() for disjunct in self.disjuncts])
|
||||
```
|
||||
|
||||
## Implication——逻辑蕴含类
|
||||
|
||||
```python
|
||||
class Implication(Sentence):
|
||||
def __init__(self, antecedent, consequent):
|
||||
"""验证操作数是否是 Sentence 或其子类"""
|
||||
Sentence.validate(antecedent)
|
||||
Sentence.validate(consequent)
|
||||
"""前件"""
|
||||
self.antecedent = antecedent
|
||||
"""后件"""
|
||||
self.consequent = consequent
|
||||
def __eq__(self, other):
|
||||
"""定义相等"""
|
||||
return (isinstance(other, Implication)
|
||||
and self.antecedent == other.antecedent
|
||||
and self.consequent == other.consequent)
|
||||
...
|
||||
def evaluate(self, model):
|
||||
"""逻辑蕴含在模型中的赋值"""
|
||||
return ((not self.antecedent.evaluate(model))
|
||||
or self.consequent.evaluate(model))
|
||||
def formula(self):
|
||||
"""返回表示逻辑蕴含的字符串形式"""
|
||||
antecedent = Sentence.parenthesize(self.antecedent.formula())
|
||||
consequent = Sentence.parenthesize(self.consequent.formula())
|
||||
return f"{antecedent} => {consequent}"
|
||||
def symbols(self):
|
||||
""""返回逻辑蕴含中的所有命题符号的集合"""
|
||||
return set.union(self.antecedent.symbols(), self.consequent.symbols())
|
||||
```
|
||||
|
||||
## Biconditional——逻辑等值类
|
||||
|
||||
```python
|
||||
class Biconditional(Sentence):
|
||||
def __init__(self, left, right):
|
||||
"""验证操作数是否是 Sentence 或其子类"""
|
||||
Sentence.validate(left)
|
||||
Sentence.validate(right)
|
||||
self.left = left
|
||||
self.right = right
|
||||
def __eq__(self, other):
|
||||
"""定义相等"""
|
||||
return (isinstance(other, Biconditional)
|
||||
and self.left == other.left
|
||||
and self.right == other.right)
|
||||
...
|
||||
def evaluate(self, model):
|
||||
"""逻辑等值在模型中的赋值"""
|
||||
return ((self.left.evaluate(model)
|
||||
and self.right.evaluate(model))
|
||||
or (not self.left.evaluate(model)
|
||||
and not self.right.evaluate(model)))
|
||||
def formula(self):
|
||||
"""返回表示逻辑等值的字符串形式"""
|
||||
left = Sentence.parenthesize(str(self.left))
|
||||
right = Sentence.parenthesize(str(self.right))
|
||||
return f"{left} <=> {right}"
|
||||
def symbols(self):
|
||||
""""返回逻辑等值中的所有命题符号的集合"""
|
||||
return set.union(self.left.symbols(), self.right.symbols())
|
||||
```
|
||||
|
||||
## Model_check()——模型检测算法
|
||||
|
||||
```python
|
||||
def model_check(knowledge, query):
|
||||
"""
|
||||
检查知识库是否推理蕴含查询结论。
|
||||
>>> p = Symbol("p")
|
||||
>>> q = Symbol("q")
|
||||
>>> r = Symbol("r")
|
||||
>>> knowledge = And(p, q, Implication(And(p, q), r))
|
||||
>>> knowledge.formula()
|
||||
'p ∧ q ∧ ((p ∧ q) => r)'
|
||||
>>> query = r
|
||||
>>> model_check(knowledge,query)
|
||||
True
|
||||
"""
|
||||
def check_all(knowledge, query, symbols, model):
|
||||
"""检查给定特定模型的知识库是否推理蕴含查询结论。"""
|
||||
# 如果模型已经为所有的命题符号赋值
|
||||
if not symbols: # symbols 为空即所有 symbols 都在模型中被赋值
|
||||
# 若模型中的知识库为真，则查询结论也必须为真
|
||||
if knowledge.evaluate(model):
|
||||
return query.evaluate(model)
|
||||
return True
|
||||
else:
|
||||
# 递归生成并检测所有模型
|
||||
# 选择其余未使用的命题符号之一
|
||||
remaining = symbols.copy()
|
||||
p = remaining.pop()
|
||||
# 创建一个命题符号为 true 的模型
|
||||
model_true = model.copy()
|
||||
model_true[p] = True
|
||||
# 创建一个命题符号为 false 的模型
|
||||
model_false = model.copy()
|
||||
model_false[p] = False
|
||||
# 确保在两种模型中都进行蕴含推理
|
||||
return (check_all(knowledge, query, remaining, model_true) and
|
||||
check_all(knowledge, query, remaining, model_false))
|
||||
# 获取知识库和查询结论中的所有命题符号
|
||||
symbols = set.union(knowledge.symbols(), query.symbols())
|
||||
# 进行模型检测
|
||||
return check_all(knowledge, query, symbols, dict())
|
||||
```
|
||||
|
||||
## 线索游戏
|
||||
|
||||
在游戏中，一个人在某个地点使用工具实施了谋杀。人、工具和地点用卡片表示。每个类别的一张卡片被随机挑选出来，放在一个信封里，由参与者来揭开真相。参与者通过揭开卡片并从这些线索中推断出信封里必须有什么来做到这一点。我们将使用之前的模型检查算法来揭开这个谜团。在我们的模型中，我们将已知与谋杀有关的项目标记为 True，否则标记为 False。
|
||||
|
||||
```python
|
||||
import termcolor
|
||||
from logic import *
|
||||
mustard = Symbol("ColMustard")
|
||||
plum = Symbol("ProfPlum")
|
||||
scarlet = Symbol("MsScarlet")
|
||||
characters = [mustard, plum, scarlet]
|
||||
|
||||
ballroom = Symbol("ballroom")
|
||||
kitchen = Symbol("kitchen")
|
||||
library = Symbol("library")
|
||||
rooms = [ballroom, kitchen, library]
|
||||
|
||||
knife = Symbol("knife")
|
||||
revolver = Symbol("revolver")
|
||||
wrench = Symbol("wrench")
|
||||
weapons = [knife, revolver, wrench]
|
||||
|
||||
symbols = characters + rooms + weapons
|
||||
def check_knowledge(knowledge):
|
||||
for symbol in symbols:
|
||||
if model_check(knowledge, symbol):
|
||||
termcolor.cprint(f"{symbol}: YES", "green")
|
||||
elif not model_check(knowledge, Not(symbol)):
|
||||
# 模型检测无法确定知识库可以得出 Not(symbol) 即 symbol 是可能的
|
||||
print(f"{symbol}: MAYBE")
|
||||
else:
|
||||
termcolor.cprint(f"{symbol}: No", "red")
|
||||
# 必须有人、房间和武器。
|
||||
knowledge = And(
|
||||
Or(mustard, plum, scarlet),
|
||||
Or(ballroom, kitchen, library),
|
||||
Or(knife, revolver, wrench)
|
||||
)
|
||||
# 初始卡牌
|
||||
knowledge.add(And(
|
||||
Not(mustard), Not(kitchen), Not(revolver)
|
||||
))
|
||||
# 未知卡牌
|
||||
knowledge.add(Or(
|
||||
Not(scarlet), Not(library), Not(wrench)
|
||||
))
|
||||
# 已知卡牌
|
||||
knowledge.add(Not(plum))
|
||||
knowledge.add(Not(ballroom))
|
||||
check_knowledge(knowledge)
|
||||
```
|
||||
|
||||
## Mastermind 游戏
|
||||
|
||||
在这个游戏中，玩家一按照一定的顺序排列颜色，然后玩家二必须猜测这个顺序。每一轮，玩家二进行猜测，玩家一返回一个数字，指示玩家二正确选择了多少颜色。让我们用四种颜色模拟一个游戏。假设玩家二猜测以下顺序：
|
||||
|
||||
|
||||
|
||||
玩家一回答“二”。因此，我们知道其中一些两种颜色位于正确的位置，而另两种颜色则位于错误的位置。根据这些信息，玩家二试图切换两种颜色的位置。
|
||||
|
||||
|
||||
|
||||
现在玩家一回答“零”。因此，玩家二知道切换后的颜色最初位于正确的位置，这意味着未被切换的两种颜色位于错误的位置。玩家二切换它们。
|
||||
|
||||
|
||||
|
||||
在命题逻辑中表示这一点需要我们有 (颜色的数量)$^2$个原子命题。所以，在四种颜色的情况下，我们会有命题 red0，red1，red2，red3，blue0…代表颜色和位置。下一步是用命题逻辑表示游戏规则（每个位置只有一种颜色，没有颜色重复），并将它们添加到知识库中。最后一步是将我们所拥有的所有线索添加到知识库中。在我们的案例中，我们会补充说，在第一次猜测中，两个位置是错误的，两个是正确的，而在第二次猜测中没有一个是对的。利用这些知识，模型检查算法可以为我们提供难题的解决方案。
|
||||
|
||||
```python
|
||||
from logic import *
|
||||
colors = ["red", "blue", "green", "yellow"]
|
||||
symbols = []
|
||||
for i in range(4):
|
||||
for color in colors:
|
||||
symbols.append(Symbol(f"{color}{i}"))
|
||||
knowledge = And()
|
||||
# 每种颜色都有一个位置。
|
||||
for color in colors:
|
||||
knowledge.add(Or(
|
||||
Symbol(f"{color}0"),
|
||||
Symbol(f"{color}1"),
|
||||
Symbol(f"{color}2"),
|
||||
Symbol(f"{color}3")
|
||||
))
|
||||
# 每种颜色只有一个位置。
|
||||
for color in colors:
|
||||
for i in range(4):
|
||||
for j in range(4):
|
||||
if i != j:
|
||||
knowledge.add(Implication(
|
||||
Symbol(f"{color}{i}"), Not(Symbol(f"{color}{j}"))
|
||||
))
|
||||
# 每个位置只有一种颜色。
|
||||
for i in range(4):
|
||||
for c1 in colors:
|
||||
for c2 in colors:
|
||||
if c1 != c2:
|
||||
knowledge.add(Implication(
|
||||
Symbol(f"{c1}{i}"), Not(Symbol(f"{c2}{i}"))
|
||||
))
|
||||
knowledge.add(Or(
|
||||
And(Symbol("red0"), Symbol("blue1"), Not(Symbol("green2")), Not(Symbol("yellow3"))),
|
||||
And(Symbol("red0"), Symbol("green2"), Not(Symbol("blue1")), Not(Symbol("yellow3"))),
|
||||
And(Symbol("red0"), Symbol("yellow3"), Not(Symbol("blue1")), Not(Symbol("green2"))),
|
||||
And(Symbol("blue1"), Symbol("green2"), Not(Symbol("red0")), Not(Symbol("yellow3"))),
|
||||
And(Symbol("blue1"), Symbol("yellow3"), Not(Symbol("red0")), Not(Symbol("green2"))),
|
||||
And(Symbol("green2"), Symbol("yellow3"), Not(Symbol("red0")), Not(Symbol("blue1")))
|
||||
))
|
||||
knowledge.add(And(
|
||||
Not(Symbol("blue0")),
|
||||
Not(Symbol("red1")),
|
||||
Not(Symbol("green2")),
|
||||
Not(Symbol("yellow3"))
|
||||
))
|
||||
print(knowledge.formula())
|
||||
for symbol in symbols:
|
||||
if model_check(knowledge, symbol):
|
||||
print(symbol)
|
||||
```
|
||||
|
||||
## Quiz
|
||||
|
||||
1. 下面的问题将问你关于以下逻辑句子的问题。1.如果 Hermione 在图书馆，那么 Harry 在图书馆。2.Hermione 在图书馆里。3.Ron 在图书馆，Ron 不在图书馆。4.Harry 在图书馆。5.Harry 不在图书馆，或者 Hermione 在图书馆。6.Rom 在图书馆，或者 Hermione 在图书馆。
|
||||
|
||||
以下哪一个逻辑蕴含推理是正确的？
|
||||
|
||||
1. $1\vDash 4$
|
||||
2. $5\vDash 6$
|
||||
3. $1\vDash 2$
|
||||
4. $6\vDash 2$
|
||||
5. $2\vDash 5$
|
||||
6. $6\vDash 3$
|
||||
|
||||
2. 除了讲义上讨论的连接词之外，还有其他的逻辑连接词。其中最常见的是“异或”（用符号$\oplus$表示）。表达式$A\oplus B$表示句子“A 或 B，但不是两者都有。”以下哪一个在逻辑上等同于$A\oplus B$？
|
||||
1. $(A ∨ B) ∧ ¬ (A ∨ B)$
|
||||
2. $(A ∨ B) ∧ (A ∧ B)$
|
||||
3. $(A ∨ B) ∧ ¬ (A ∧ B)$
|
||||
4. $(A ∧ B) ∨ ¬ (A ∨ B)$
|
||||
|
||||
3. 设命题变量$R$为“今天下雨”，变量$C$为“今天多云”，变量$S$ 为“今天晴”。下面哪一个是“如果今天下雨，那么今天多云但不是晴天”这句话的命题逻辑表示？
|
||||
|
||||
1. $(R → C) ∧ ¬S$
|
||||
2. $R → C → ¬S$
|
||||
3. $R ∧ C ∧ ¬S$
|
||||
4. $R → (C ∧ ¬S)$
|
||||
5. $(C ∨ ¬S) → R$
|
||||
|
||||
4. 在一阶逻辑中，考虑以下谓词符号。$Student(x)$表示“x 是学生”的谓词。$Course(x)$代表“x 是课程”的谓词，$Enrolled(x,y)$表示“x 注册了 y”的谓词以下哪一项是“有一门课程是 Harry 和 Hermione 都注册的”这句话的一阶逻辑翻译？
|
||||
1. $∀x(Course(x)∧Enrolled(Harry, x) ∧ Enrolled(Hermione, x))$
|
||||
2. $∀x(Enrolled(Harry, x) ∨ Enrolled(Hermione, x))$
|
||||
3. $∀x(Enrolled(Harry, x) ∧ ∀y Enrolled(Hermione, y))$
|
||||
4. $∃xEnrolled(Harry, x) ∧ ∃y Enrolled(Hermione, y)$
|
||||
5. $∃x(Course(x) ∧ Enrolled(Harry, x) ∧ Enrolled(Hermione, x))$
|
||||
6. $∃x(Enrolled(Harry, x) ∨ Enrolled(Hermione, x))$
|
||||
234
2023旧版内容/4.人工智能/4.3.2.2项目：扫雷，骑士与流氓问题.md
Normal file
234
2023旧版内容/4.人工智能/4.3.2.2项目：扫雷，骑士与流氓问题.md
Normal file
@@ -0,0 +1,234 @@
|
||||
# 项目：扫雷，骑士与流氓问题
|
||||
|
||||
::: warning 😋 我们为你提供了两个简单有趣的项目，帮助你进行知识巩固，请认真阅读文档内容。
|
||||
|
||||
如果你卡住了，请记得回来阅读文档，或请求身边人的帮助。
|
||||
:::
|
||||
|
||||
::: tip 📥
|
||||
本节附件下载 <Download url="https://cdn.xyxsw.site/code/2-Projects.zip"/>
|
||||
:::
|
||||
|
||||
`pip3 install -r requirements.txt`
|
||||
|
||||
## 骑士与流氓问题
|
||||
|
||||
### 背景
|
||||
|
||||
在 1978 年，逻辑学家雷蒙德·斯穆里安（Raymond Smullyan）出版了《这本书叫什么名字？》，这是一本逻辑难题的书。在书中的谜题中，有一类谜题被斯穆里安称为“骑士与流氓”谜题。
|
||||
|
||||
在骑士与流氓谜题中，给出了以下信息：每个角色要么是骑士，要么是流氓。骑士总是会说实话：如果骑士陈述了一句话，那么这句话就是真的。相反，流氓总是说谎：如果流氓陈述了一个句子，那么这个句子就是假的。
|
||||
|
||||
谜题的目标是，给出每个角色说的一组句子，确定每个角色是骑士还是流氓。
|
||||
|
||||
比如，这里有一个简单的谜题只有一个名为 A 的角色。A 说：“我既是骑士又是流氓。”
|
||||
|
||||
从逻辑上讲，我们可以推断，如果 A 是骑士，那么这句话一定是真的。但我们知道这句话不可能是真的，因为 A 不可能既是骑士又是流氓——我们知道每个角色要么是骑士，要么是流氓，不会出现是流氓的骑士或是骑士的流氓。所以，我们可以得出结论，A 一定是流氓。
|
||||
|
||||
那个谜题比较简单。随着更多的字符和更多的句子，谜题可以变得更加棘手！你在这个问题中的任务是确定如何使用命题逻辑来表示这些谜题，这样一个运行模型检查算法的人工智能可以为我们解决这些谜题。
|
||||
|
||||
### 理解
|
||||
|
||||
看一下 `logic.py`，你可能还记得讲义的内容。无需了解此文件中的所有内容，但请注意，此文件为不同类型的逻辑连接词定义了多个类。这些类可以相互组合，所以表达式 `And(Not(A), Or(B, C))` 代表逻辑语句：命题 A 是不正确的，同时，命题 B 或者命题 C 是正确的。（这里的“或”是同或，不是异或）
|
||||
|
||||
回想一下 `logic.py`，它还包含一个 函数 `model_check` 。`model_check` 输入知识库和查询结论。知识库是一个逻辑命题：如果知道多个逻辑语句，则可以将它们连接在一个表达式中。递归考虑所有可能的模型，如果知识库推理蕴含查询结论，则返回 `True`，否则返回 `False`。
|
||||
|
||||
现在，看看 `puzzle.py`，在顶部，我们定义了六个命题符号。例如，`AKnight` 表示“A 是骑士”的命题，`AKnave` 而表示“A 是流氓”的句子。我们也为字符 B 和 C 定义了类似的命题符号。
|
||||
|
||||
接下来是四个不同的知识库 `knowledge0`, `knowledge1`, `knowledge2`, and `knowledge3`，它们将分别包含推断即将到来的谜题 0、1、2 和 3 的解决方案所需的知识。请注意，目前，这些知识库中的每一个都是空的。这就是你进来的地方！
|
||||
|
||||
这个 `puzzle.py` 的 `main` 函数在所有谜题上循环，并使用模型检查来计算，给定谜题的知识，无论每个角色是骑士还是无赖，打印出模型检查算法能够得出的任何结论。
|
||||
|
||||
### 明确
|
||||
|
||||
将知识添加到知识库 `knowledge0`, `knowledge1`, `knowledge2`, 和 `knowledge3` 中，以解决以下难题。
|
||||
|
||||
- 谜题 0 是背景中的谜题。它只包含一个简单的角色 A
|
||||
|
||||
A 说：“我既是骑士又是流氓。”
|
||||
|
||||
- 谜题 1 有两个角色：A 和 B
|
||||
|
||||
A 说：“我们都是流氓。”
|
||||
|
||||
B 什么都没说。
|
||||
|
||||
- 谜题 2 有两个角色：A 和 B
|
||||
|
||||
A 说：“我们是同一种身份。”
|
||||
|
||||
B 说：“我们不是同一种身份。”
|
||||
|
||||
- 谜题 3 有三个角色：A，B 和 C
|
||||
|
||||
A 说：“我是骑士”或者 A 说：“我是流氓”（这里“或”是异或，不是同或），但你不知道 A 说的是哪句话。
|
||||
|
||||
B 说：“A 说过‘我是流氓’。”
|
||||
|
||||
B 又说：“C 是流氓。”
|
||||
|
||||
C 说：“A 是骑士。”
|
||||
|
||||
上述每个谜题中，每个角色要么是骑士，要么是流氓。骑士说的每一句话都是真的，流氓说的每一句话都是假的。
|
||||
|
||||
一旦你完成了一个问题的知识库，你应该能够运行 `python puzzle.py` 来查看谜题的解决方案。
|
||||
|
||||
### 提示
|
||||
|
||||
对于每个知识库，你可能想要编码两种不同类型的信息：（1）关于问题本身结构的信息（即骑士与流氓谜题定义中给出的信息），以及（2）关于角色实际说了什么的信息。
|
||||
|
||||
考虑一下，如果一个句子是由一个角色说出的，这意味着什么。在什么条件下这句话是真的？在什么条件下这个句子是假的？你如何将其表达为一个合乎逻辑的句子？
|
||||
|
||||
每个谜题都有多个可能的知识库，可以计算出正确的结果。你应该尝试选择一个能对谜题中的信息进行最直接的知识库，而不是自己进行逻辑推理。你还应该考虑谜题中信息最简洁的表达方式是什么。
|
||||
|
||||
例如，对于谜题 0，设置 `knowledge0=AKnave` 将产生正确的输出，因为通过我们自己的推理，我们知道 A 一定是一个无赖。但这样做违背了这个问题的精神：目标是让你的人工智能为你做推理。
|
||||
|
||||
您不需要（也不应该）修改 `logic.py` 来完成这个问题。
|
||||
|
||||
## 扫雷
|
||||
|
||||
写一个 AI 来玩扫雷游戏。
|
||||
|
||||
|
||||
|
||||
### 背景
|
||||
|
||||
#### 扫雷游戏
|
||||
|
||||
扫雷器是一款益智游戏，由一个单元格网格组成，其中一些单元格包含隐藏的“地雷”。点击包含地雷的单元格会引爆地雷，导致用户输掉游戏。单击“安全”单元格（即不包含地雷的单元格）会显示一个数字，指示有多少相邻单元格包含地雷，其中相邻单元格是指从给定单元格向左、向右、向上、向下或对角线一个正方形的单元格。
|
||||
例如，在这个 3x3 扫雷游戏中，三个 1 值表示这些单元格中的每个单元格都有一个相邻的单元格，该单元格是地雷。四个 0 值表示这些单元中的每一个都没有相邻的地雷。
|
||||
|
||||
|
||||
|
||||
给定这些信息，玩家根据逻辑可以得出结论，右下角单元格中一定有地雷，左上角单元格中没有地雷，因为只有在这种情况下，其他单元格上的数字标签才会准确。
|
||||
|
||||
游戏的目标是标记（即识别）每个地雷。在游戏的许多实现中，包括本项目中的实现中，玩家可以通过右键单击单元格（或左键双击，具体取决于计算机）来标记地雷。
|
||||
|
||||
#### 命题逻辑
|
||||
|
||||
你在这个项目中的目标是建立一个可以玩扫雷游戏的人工智能。回想一下，基于知识的智能主体通过考虑他们的知识库来做出决策，并根据这些知识做出推断。
|
||||
|
||||
我们可以表示人工智能关于扫雷游戏的知识的一种方法是，使每个单元格成为命题变量，如果单元格包含地雷，则为真，否则为假。
|
||||
|
||||
|
||||
|
||||
我们现在掌握了什么信息？我们现在知道八个相邻的单元格中有一个是地雷。因此，我们可以写一个逻辑表达式，如下所示，表示其中一个相邻的单元格是地雷。
|
||||
|
||||
- `Or(A,B,C,D,E,F,G,H)`
|
||||
|
||||
但事实上，我们知道的比这个表达所说的要多。上面的逻辑命题表达了这样一种观点，即这八个变量中至少有一个是真的。但我们可以做一个更有力的陈述：我们知道八个变量中有一个是真的。这给了我们一个命题逻辑命题，如下所示。
|
||||
|
||||
```txt
|
||||
Or(
|
||||
And(A, Not(B), Not(C), Not(D), Not(E), Not(F), Not(G), Not(H)),
|
||||
And(Not(A), B, Not(C), Not(D), Not(E), Not(F), Not(G), Not(H)),
|
||||
And(Not(A), Not(B), C, Not(D), Not(E), Not(F), Not(G), Not(H)),
|
||||
And(Not(A), Not(B), Not(C), D, Not(E), Not(F), Not(G), Not(H)),
|
||||
And(Not(A), Not(B), Not(C), Not(D), E, Not(F), Not(G), Not(H)),
|
||||
And(Not(A), Not(B), Not(C), Not(D), Not(E), F, Not(G), Not(H)),
|
||||
And(Not(A), Not(B), Not(C), Not(D), Not(E), Not(F), G, Not(H)),
|
||||
And(Not(A), Not(B), Not(C), Not(D), Not(E), Not(F), Not(G), H)
|
||||
)
|
||||
```
|
||||
|
||||
这是一个相当复杂的表达！这只是为了表达一个单元格中有 1 意味着什么。如果一个单元格有 2、3 或其他值，这个表达式可能会更长。
|
||||
|
||||
试图对这类问题进行模型检查也会很快变得棘手：在 8x8 网格（微软初级游戏模式使用的大小）上，我们有 64 个变量，因此需要检查$2^{64}$个可能的模型——太多了，计算机无法在任何合理的时间内计算。对于这个问题，我们需要更好地表达知识。
|
||||
|
||||
#### 知识表示
|
||||
|
||||
相反，我们将像下面这样表示人工智能知识的每一句话。
|
||||
|
||||
- `{A, B, C, D, E, F, G, H} = 1`
|
||||
|
||||
这种表示法中的每个逻辑命题都有两个部分：一个是网格中与提示数字有关的一组单元格 `cell`，另一个是数字计数 `count`，表示这些单元格中有多少是地雷。上面的逻辑命题说，在单元格 A、B、C、D、E、F、G 和 H 中，正好有 1 个是地雷。
|
||||
|
||||
为什么这是一个有用的表示？在某种程度上，它很适合某些类型的推理。考虑下面的游戏。
|
||||
|
||||
|
||||
|
||||
利用左下数的知识，我们可以构造命题 `{D，E，G}=0`，意思是在 D、E 和 G 单元中，正好有 0 个是地雷。凭直觉，我们可以从这句话中推断出所有的单元格都必须是安全的。通过推理，每当我们有一个 `count` 为 0 的命题时，我们就知道该命题的所有 `cell` 都必须是安全的。
|
||||
|
||||
同样，考虑下面的游戏。
|
||||
|
||||
|
||||
|
||||
我们的人工智能会构建命题 `{E，F，H}=3`。凭直觉，我们可以推断出所有的 E、F 和 H 都是地雷。更一般地说，任何时候 `cell` 的数量等于 `count`，我们都知道这个命题的所有单元格都必须是地雷。
|
||||
|
||||
一般来说，我们只希望我们的命题是关于那些还不知道是安全的还是地雷的 `cell`。这意味着，一旦我们知道一个单元格是否是地雷，我们就可以更新我们的知识库来简化它们，并可能得出新的结论。
|
||||
|
||||
例如，如果我们的人工智能知道命题 `{A，B，C}=2`，那么我们还没有足够的信息来得出任何结论。但如果我们被告知 C 是安全的，我们可以将 C 从命题中完全删除，留下命题 `{A，B}=2`（顺便说一句，这确实让我们得出了一些新的结论）
|
||||
|
||||
同样，如果我们的人工智能知道命题 `{A，B，C}＝2`，并且我们被告知 C 是一颗地雷，我们可以从命题中删除 C，并减少计数的值（因为 C 是导致该计数的地雷），从而得到命题 `{A、B}＝1`。这是合乎逻辑的：如果 A、B 和 C 中有两个是地雷，并且我们知道 C 是地雷，那么 A 和 B 中一定有一个是地雷。
|
||||
|
||||
如果我们更聪明，我们可以做最后一种推理。
|
||||
|
||||
|
||||
|
||||
考虑一下我们的人工智能根据中间顶部单元格和中间底部单元格会知道的两个命题。从中上角的单元格中，我们得到 `{A，B，C}=1`。从底部中间单元格中，我们得到 `{A，B，C，D，E}=2`。从逻辑上讲，我们可以推断出一个新的知识，即 `{D，E}＝1`。毕竟，如果 A、B、C、D 和 E 中有两个是地雷，而 A、B 和 C 中只有一个是地雷的话，那么 D 和 E 必须是另一个地雷。
|
||||
|
||||
更一般地说，任何时候我们有两个命题满足 `set1=count1` 和 `set2=count2`，其中 `set1` 是 `set2` 的子集，那么我们可以构造新的命题 `set2-set1=count2-count1`。考虑上面的例子，以确保你理解为什么这是真的。
|
||||
|
||||
因此，使用这种表示知识的方法，我们可以编写一个人工智能智能主体，它可以收集有关扫雷的知识，并希望选择它知道安全的单元格！
|
||||
|
||||
### 理解
|
||||
|
||||
这个项目有两个主要文件：`runner.py` 和 `minesweeper.py`。`minesweeper.py` 包含游戏本身和 AI 玩游戏的所有逻辑。`runner.py` 已经为你实现，它包含了运行游戏图形界面的所有代码。一旦你完成了 `minesweeper.py` 中所有必需的功能，你就可以运行 `python runner.py` 来玩扫雷了（或者让你的 AI 为你玩）！
|
||||
|
||||
让我们打开 `minesweeper.py` 来了解提供了什么。这个文件中定义了三个类，`Minesweeper`，负责处理游戏；`Sentence`，表示一个既包含一组 `cell` 又包含一个 `count` 的逻辑命题；以及 `MinesweeperAI`，它处理根据知识做出的推断。
|
||||
|
||||
`Minesweeper` 类已经完全实现了。请注意，每个单元格都是一对 `(i，j)`，其中 `i` 是行号 (范围从 `0` 到 `height-1`)，`j` 是列号 (范围从 `0` 到 `width-1`)。
|
||||
|
||||
`Sentence` 类将用于表示背景中描述的形式的逻辑命题。每个命题中都有一组 `cell`，以及 `count` 表示其中有多少单元格是地雷。该类还包含函数 `known_mines` 和 `known_safes`，用于确定命题中的任何单元格是已知的地雷还是已知的安全单元格。它还包含函数 `mark_mine` 和 `mark_safe`，用于响应有关单元格的新信息来更新命题。
|
||||
|
||||
最后，`MinesweeperAI` 类将实现一个可以玩扫雷的 AI。AI 类跟踪许多值。`self.moves_made` 包含一组已经点击过的所有单元格，因此人工智能知道不要再选择这些单元格。`self.mines` 包含一组已知为地雷的所有单元格。`self.safes` 包含一组已知安全的所有单元格。而 `self.knowledge` 包含了人工智能知道是真的所有命题的列表。
|
||||
|
||||
`mark_mine` 函数为 `self.mines` 添加了一个单元格，因此 AI 知道这是一个地雷。它还循环遍历人工智能知识中的所有命题，并通知每个命题该单元格是地雷，这样，如果命题包含有关地雷的信息，它就可以相应地更新自己。`mark_safe` 函数也做同样的事情，只是针对安全单元格。
|
||||
|
||||
剩下的函数 `add_knowledge`、`make_safe_move` 和 `make_random_move` 由你完成！
|
||||
|
||||
### 明确
|
||||
|
||||
完成 `minesweeper.py` 中的 `Sentence` 类和 `MinesweeperAI` 类的实现。
|
||||
在 `Sentence` 类中，完成 `known_mines`、`known_safes`、`mark_mine` 和 `mark_safe` 的实现。
|
||||
|
||||
- `known_mines` 函数应该返回 `self.cells` 中已知为地雷的所有单元格的集合。
|
||||
- `known_safes` 函数应该返回 `self.cells` 中已知安全的所有单元格的集合。
|
||||
- `mark_mine` 函数应该首先检查单元格是否是命题中包含的单元格之一。
|
||||
- 如果 `cell` 在命题中，函数应该更新命题，使单元格不再在命题中但仍然表示一个逻辑正确的命题，因为该 `cell` 已知是地雷。
|
||||
- 如果命题中没有 `cell`，则不需要采取任何行动。
|
||||
- `mark_safe` 函数应该首先检查单元格是否是命题中包含的单元格之一。
|
||||
- 如果 `cell` 在命题中，则函数应更新命题，使单元格不再在命题中但仍然表示一个逻辑正确的命题，因为该 `cell` 已知是安全的。
|
||||
- 如果命题中没有 `cell`，则不需要采取任何行动。
|
||||
|
||||
在 `MinesweeperAI` 类中，完成 `add_knowledge`、`make_safe_move` 和 `make_random_move` 的实现。
|
||||
|
||||
- `add_knowledge` 应该接受一个单元格（表示为元组 `(i，j)`）及其相应的 `count`，并使用 AI 可以推断的任何新信息更新 `self.mines`、`self.safes`、`self.moves_made` 和 `self.knowledge`，因为该单元格是已知的安全单元格，其附近有计数地雷。
|
||||
- 该函数应将该 `cell` 标记为游戏中的一个动作。
|
||||
- 函数应该将 `cell` 标记为安全单元格，同时更新包含该单元格的任何命题。
|
||||
- 该函数应该根据 `cell` 和 `count` 的值，在人工智能的知识库中添加一个新命题，以表明 `cell` 的邻居有 `count` 是地雷。请确保在命题中只包含状态尚未确定的单元格。
|
||||
- 如果根据 `self.knowledge` 中的任何一个命题，新的单元格可以被标记为安全的或地雷，那么函数应该这样做。
|
||||
- 如果根据 `self.knowledge` 中的任何一个命题，可以推断出新的命题（使用背景技术中描述的子集方法），那么这些命题也应该添加到知识库中。
|
||||
- 请注意，每当你对人工智能的知识做出任何改变时，都有可能得出以前不可能的新推论。如果可能的话，请确保将这些新的推断添加到知识库中。
|
||||
|
||||
- `make_safe_move` 应该返回一个已知安全的选择 `(i，j)`。
|
||||
- 必须知道返回的动作是安全的，而不是已经做出的动作。
|
||||
- 如果无法保证安全移动，则函数应返回 `None`。
|
||||
- 该函数不应修改 `self.moves_made`、`self.mines`、`self.safes` 或 `self.knowledge`。
|
||||
|
||||
- `make_random_move` 应该返回一个随机选择 `(i，j)`。
|
||||
- 如果无法安全移动，将调用此功能：如果人工智能不知道移动到哪里，它将选择随机移动。
|
||||
- 此举不得是已经采取的行动。
|
||||
- 此举决不能是已知的地雷行动。
|
||||
- 如果无法进行此类移动，则函数应返回 `None`。
|
||||
|
||||
### 提示
|
||||
|
||||
- 确保你已经彻底阅读了背景部分，以了解知识在这个人工智能中是如何表现的，以及人工智能是如何进行推理的。
|
||||
- 如果对面向对象编程感觉不太舒服，你可能会发现[<u>python 关于类</u>](https://docs.python.org/3/tutorial/classes.html)的文档很有帮助。
|
||||
- 你可以在[<u>python 关于集合</u>](https://docs.python.org/3/library/stdtypes.html#set)的文档中找到一些常见的集合操作。
|
||||
- 在 `Sentence` 类中实现 `known_mines` 和 `known_safes` 时，请考虑：在什么情况下，你确信命题的单元格是安全的？在什么情况下，你确定一个命题的单元格是地雷？
|
||||
- `add_knowledge` 做了很多工作，可能是迄今为止你为该项目编写的最长的函数。一步一步地实现此函数的行为可能会有所帮助。
|
||||
- 如果愿意，欢迎您向任何类添加新方法，但不应修改任何现有函数的定义或参数。
|
||||
- 当你运行你的人工智能（如点击“AI Move”）时，请注意它并不总是获胜！在某些情况下，人工智能必须进行猜测，因为它缺乏足够的信息来进行安全行动。这是意料之中的事。`runner.py` 将打印人工智能是否正在进行其认为安全的移动，或者是否正在进行随机移动。
|
||||
- 在对集合进行迭代时，请注意不要修改它。这样做可能会导致错误！
|
||||
350
2023旧版内容/4.人工智能/4.3.2知识推理.md
Normal file
350
2023旧版内容/4.人工智能/4.3.2知识推理.md
Normal file
@@ -0,0 +1,350 @@
|
||||
# 知识推理
|
||||
|
||||
人类根据现有的知识进行推理并得出结论。表示知识并从中得出结论的概念也被用于人工智能中，在本章中我们将探讨如何实现这种行为。
|
||||
|
||||
::: warning <font size=5>**说好的 AI 呢？怎么感觉越来越偏了？**</font>
|
||||
|
||||
如果有这样的疑问的同学，可能存在一定的误区，认为人工智能就是局限在深度学习的算法或者说机器学习的部分算法上，其实这是对这个领域一个巨大的误解。
|
||||
|
||||
在 AI 的发展历程上，曾经存在一次符号主义（Symbolic）与联结主义（Connectionism）之争。
|
||||
|
||||
联结主义的中心原则是使用，简单且经常一致的单元互联网络，来描述各种现象，即简单的复杂叠加。在目前的深度学习网络中有着最为广泛的应用。
|
||||
|
||||
符号主义则相信，智能的许多特征可以透过[符号](https://zh.wikipedia.org/wiki/%E7%89%A9%E7%90%86%E7%AC%A6%E8%99%9F%E7%B3%BB%E7%B5%B1)处理来实现。最为显著的应用即是早期的专家系统。
|
||||
|
||||
从本质上来说，二者都存在用机器可以理解的语言表征知识，随后让机器依照人为制定的理论或数据依照概率或推理得到人所期望获得的的知识或结果。
|
||||
|
||||
而在本章的内容中，知识推理目标是让机器存储相应的知识，并且能够按照某种规则推理演绎得到新的知识，与 AI 的主体逻辑是相融洽的。目前的主流 AI 领域，知识图谱的重要组成部分，便包括了知识推理这个步骤，即从已知到未知。
|
||||
|
||||
那么如何构建让计算机可以理解的知识体系呢？如何让机器从已告知他的逻辑延伸到未告知他逻辑呢？数学家和计算机科学家甚至为此构建了相较而言非常完善的理论体系，包括但不限于离散数学，计算理论甚至是抽象数学，我在最后补充三本阅读材料，各位如果想要深入了解，可以进行进一步的阅读和理解。
|
||||
|
||||
较为基础的知识各位可以看以下的内容。
|
||||
:::
|
||||
|
||||
## 基础知识
|
||||
|
||||
### 基于知识的智能主体 (Knowledge-Based Agents)
|
||||
|
||||
智能主体通过对内部的知识表征进行操作来推理得出结论。
|
||||
|
||||
“根据知识推理得出结论”是什么意思？
|
||||
|
||||
让我们开始用哈利波特的例子来回答这个问题。考虑以下句子：
|
||||
|
||||
1. 如果没有下雨，哈利今天会去拜访海格。
|
||||
2. 哈利今天拜访了海格或邓布利多，但没有同时拜访他们。
|
||||
3. 哈利今天拜访了邓布利多。
|
||||
基于这三个句子，我们可以回答“今天下雨了吗？”这个问题，尽管没有一个单独的句子告诉我们今天是否下雨，根据推理我们可以得出结论“今天下雨了”。
|
||||
|
||||
### 陈述句 (Sentence)
|
||||
|
||||
陈述句是知识表示语言中关于世界的断言。陈述句是人工智能存储知识并使用它来推断新信息的方式。
|
||||
|
||||
## 命题逻辑 (Propositional Logic)
|
||||
|
||||
命题逻辑基于命题。命题是关于世界的陈述，可以是真也可以是假，正如上面例子中的句子。
|
||||
|
||||
### 命题符号 (Propositional Symbols)
|
||||
|
||||
命题符号通常是用于表示命题的字母$P、Q、R$
|
||||
|
||||
### 逻辑连接词 (Logical Connectives)
|
||||
|
||||
逻辑连接词是连接命题符号的逻辑符号，以便以更复杂的方式对世界进行推理。
|
||||
|
||||
- <strong>Not</strong><strong> </strong><strong>(</strong>$\lnot$<strong>)</strong> 逻辑非：命题真值的反转。例如，如果 $P$：“正在下雨”，那么 $¬P$：“没有下雨”。
|
||||
真值表用于将所有可能的真值赋值与命题进行比较。该工具将帮助我们更好地理解与不同逻辑连接词相关联的命题的真值。例如，下面是我们的第一个真值表：
|
||||
|
||||
| $P$ | $\lnot P$ |
|
||||
| -------- | --------- |
|
||||
| false(0) | true(1) |
|
||||
| true(1) | false(0) |
|
||||
|
||||
- **And(**$\land$**)** 逻辑乘 (合取): 连接两个不同的命题。当这两个命题$P$和$Q$用$∧$连接时，得到的命题$P∧Q$只有在$P$和$Q$都为真的情况下才为真。
|
||||
|
||||
| $P$ | $Q$ | $P\land Q$ |
|
||||
| --- | --- | ---------- |
|
||||
| 0 | 0 | 0 |
|
||||
| 0 | 1 | 0 |
|
||||
| 1 | 0 | 0 |
|
||||
| 1 | 1 | 1 |
|
||||
|
||||
- **Or(**$\lor$**)** 逻辑和 (析取): 只要它的任何一个参数为真，它就为真。这意味着要使 $P ∨ Q$为真，$P$ 或 $Q$ 中至少有一个必须为真。
|
||||
|
||||
| $P$ | $Q$ | $P\lor Q$ |
|
||||
| --- | --- | --------- |
|
||||
| 0 | 0 | 0 |
|
||||
| 0 | 1 | 1 |
|
||||
| 1 | 0 | 1 |
|
||||
| 1 | 1 | 1 |
|
||||
|
||||
值得一提的是，Or 有两种类型：同或 Or 和异或 Or。在异或中，如果$P\lor Q$为真，则$P∧Q$为假。也就是说，一个异或要求它只有一个论点为真，而不要求两者都为真。如果$P、Q$或$P∧Q$中的任何一个为真，则包含或为真。在 Or($\lor$) 的情况下，意图是一个包含的 Or。
|
||||
|
||||
- **Implication (→)** 逻辑蕴含：表示“如果$P$，则$Q$的结构。例如，如果$P$：“正在下雨”，$Q$：“我在室内”，则$P→ Q$的意思是“如果下雨，那么我在室内。”在$P$的情况下，意味着$Q$，$P$被称为前件，$Q$ 被称为后件。
|
||||
|
||||
当前件为真时，在后件为真的情况下，整个蕴含逻辑为真（这是有道理的：如果下雨，我在室内，那么“如果下雨，那么我在室内”这句话是真的）。当前件为真时，如果后件为假，则蕴含逻辑为假（如果下雨时我在外面，那么“如果下雨，那么我在室内”这句话是假的）。然而，当前件为假时，无论后件如何，蕴含逻辑总是真的。这有时可能是一个令人困惑的概念。从逻辑上讲，我们不能从蕴含中学到任何东西$(P→ Q)$如果前件 ($P$) 为假。看一下我们的例子，如果没有下雨，这个蕴含逻辑并没有说我是否在室内的问题。我可能是一个室内型的人，即使不下雨也不在外面走，或者我可能是一个室外型的人，不下雨的时候一直在外面。当前件是假的，我们说蕴含逻辑是真的。
|
||||
|
||||
| $P$ | $Q$ | $P\to Q$ |
|
||||
| --- | --- | -------- |
|
||||
| 0 | 0 | 1 |
|
||||
| 0 | 1 | 1 |
|
||||
| 1 | 0 | 0 |
|
||||
| 1 | 1 | 1 |
|
||||
|
||||
|
||||
- <strong>Biconditional (</strong>$\leftrightarrow$<strong>)</strong> :是一个双向的蕴含。你可以把它读成“如果且仅当”$P↔ Q$等同$P→ Q$和$Q→ P$合在一起。例如，如果$P$：“正在下雨”，$Q$：“我在室内”，那么$P↔ Q$的意思是“如果下雨，那么我在室内”，“如果我在室内，那么就在下雨。”这意味着我们可以推断出比简单蕴含更多的东西。如果$P$为假，那么$Q$ 也为假；如果不下雨，我们知道我也不在室内。
|
||||
|
||||
| $P$ | $Q$ | $P\leftrightarrow Q$ |
|
||||
| --- | --- | -------------------- |
|
||||
| 0 | 0 | 1 |
|
||||
| 0 | 1 | 0 |
|
||||
| 1 | 0 | 0 |
|
||||
| 1 | 1 | 1 |
|
||||
|
||||
### 模型 (Model)
|
||||
|
||||
模型是对每个命题的真值赋值。重申一下，命题是关于世界的陈述，可以是真也可以是假。然而，关于世界的知识体现在这些命题的真值中。模型是提供有关世界的信息的真值赋值。
|
||||
|
||||
例如，如果 $P$：“正在下雨。”和 $Q$：“今天是星期二。”，模型可以是以下真值赋值：$\set{P = True, Q = False}$。此模型表示正在下雨，但不是星期二。然而，在这种情况下有更多可能的模型（例如，$\set{P = True, Q = True}$，星期二并且下雨）。事实上，可能模型的数量是命题数量的 2 次方。在这种情况下，我们有 2 个命题，所以 $2^2=4$ 个可能的模型。
|
||||
|
||||
### 知识库 (Knowledge Base (KB))
|
||||
|
||||
知识库是基于知识的智能主题已知的一组陈述句。这是关于人工智能以命题逻辑语句的形式提供的关于世界的知识，可用于对世界进行额外的推理。
|
||||
|
||||
### 蕴含推理 (Entailment ($\vDash$))
|
||||
|
||||
如果 $α ⊨ β$（$α$蕴含推理出 $β$），那么在任何 $α$为真的世界中，$β$也为真。
|
||||
|
||||
例如，如果 $α$：“今天是一月的星期二”和 $β$：“今天是星期二”，那么我们知道 $α ⊨ β$。如果确实是一月的星期二，我们也知道这是星期二。蕴含推理不同于逻辑蕴含。逻辑蕴涵是两个命题之间的逻辑连接。另一方面，推理蕴含关系是指如果 $α$中的所有信息都为真，则 $β$中的所有信息都为真。
|
||||
|
||||
## 推理 (Inference)
|
||||
|
||||
推理是从原有命题推导出新命题的过程。
|
||||
|
||||
### 模型检查算法 (Model Checking algorithm)
|
||||
|
||||
确定是否$KB ⊨ α$(换句话说，回答问题：“我们能否根据我们的知识库得出结论 $α$为真？”)
|
||||
|
||||
- 枚举所有可能的模型。
|
||||
- 如果在 $KB$为真的每个模型中，$α$也为真，则 $KB ⊨ α$。
|
||||
|
||||
#### 一个例子
|
||||
|
||||
$P$: 今天是星期四，$Q$: 今天下雨，$R$: 我将出门跑步$
|
||||
|
||||
$KB$: 如果今天是星期四并且不下雨，那我将出门跑步；今天是星期四；今天不下雨。$(P\land\lnot Q)\to R,P,\lnot Q$
|
||||
|
||||
查询结论 (query): $R$
|
||||
|
||||
|
||||
|
||||
接下来，让我们看看如何将知识和逻辑表示为代码。
|
||||
|
||||
```python
|
||||
from logic import * # 创建新类，每个类都有一个名称或一个符号，代表每个命题。
|
||||
rain = Symbol("rain") # 今天下雨
|
||||
hagrid = Symbol("hagrid") # 哈利拜访了海格
|
||||
dumbledore = Symbol("dumbledore") # 哈利拜访了邓布利多
|
||||
# 知识库中的陈述句
|
||||
knowledge = And( # 从“和”逻辑连接词开始，因为每个命题都代表我们知道是真实的知识。
|
||||
Implication(Not(rain), hagrid), # ¬(今天下雨) → (哈利拜访了海格)
|
||||
Or(hagrid, dumbledore), # (哈利拜访了海格) ∨ (哈利拜访了邓布利多).
|
||||
Not(And(hagrid, dumbledore)), # ¬(哈利拜访了邓布利多 ∧ 哈利拜访了海格) i.e. 哈利没有同时去拜访海格和邓布利多。
|
||||
dumbledore # 哈利拜访了邓布利多。请注意，虽然之前的命题包含多个带有连接符的符号，但这是一个由一个符号组成的命题。这意味着我们将在这个 KB 中，Harry 拜访了 Dumbledore 作为事实。
|
||||
)
|
||||
```
|
||||
|
||||
要运行模型检查算法，需要以下信息：
|
||||
|
||||
- 知识库 (KB)，将用于得出推论
|
||||
- 一个查询结论 (query)，或者我们感兴趣的命题是否被$KB$包含
|
||||
- 命题符号，所有使用的符号（或原子命题）的列表（在我们的例子中，这些是 rain、hagrid 和 dumbledore）
|
||||
- 模型，将真值和假值分配给命题
|
||||
|
||||
模型检查算法如下所示：
|
||||
|
||||
```python
|
||||
def check_all(knowledge, query, symbols, model):# 如果模型对每个符号都有一个赋值
|
||||
# (下面的逻辑可能有点混乱：我们从命题符号列表开始。该函数是递归的，每次调用自身时，它都会从命题符号列表中弹出一个命题符号并从中生成模型。因此，当命题符号列表为空时，我们知道我们已经完成生成模型，其中包含每个可能的命题真值分配。)
|
||||
if not symbols:
|
||||
# 如果知识库在模型中为真，则查询结论也必须为真
|
||||
if knowledge.evaluate(model):
|
||||
return query.evaluate(model)
|
||||
return True
|
||||
else:
|
||||
# 选择剩余未使用的符号之一
|
||||
remaining = symbols.copy()
|
||||
p = remaining.pop()
|
||||
# 创建一个模型，其中命题符号为真
|
||||
model_true = model.copy()
|
||||
model_true[p] = True
|
||||
# 创建一个模型，其中命题符号为假
|
||||
model_false = model.copy()
|
||||
model_false[p] = False
|
||||
# 确保两种模型都进行蕴含推理
|
||||
return(check_all(knowledge, query, remaining, model_true) and check_all(knowledge, query, remaining, model_false))
|
||||
```
|
||||
|
||||
请注意，我们只对$KB$为真的模型感兴趣。如果$KB$为假，那么我们知道真实的条件并没有出现在这些模型中，使它们与我们的案例无关。
|
||||
|
||||
> 另一个例子：假设 $P$：Harry 扮演找球手，$Q$：Oliver 扮演守门员，$R$：Gryffindor 获胜。我们的$KB$指定$P$, $Q$, $(P ∧ Q) \to R$。换句话说，我们知道$P$为真，即 Harry 扮演找球手，$Q$为真，即 Oliver 扮演守门员，并且如果$P$和$Q$都为真，那么$R$也为真，这意味着 Gryffindor 赢得了比赛。现在想象一个模型，其中 Harry 扮演击球手而不是找球手 (因此，Harry 没有扮演找球手，$¬P$)。嗯，在这种情况下，我们不关心 Gryffindor 是否赢了 (无论$R$是否为真)，因为我们的$KB$中有信息表明 Harry 扮演的是找球手而不是击球手。我们只对$P$和$Q$ 为真的模型感兴趣。）
|
||||
|
||||
此外，`check_all` 函数的工作方式是递归的。也就是说，它选择一个命题符号，创建两个模型，其中一个符号为真，另一个为假，然后再次调用自己，现在有两个模型因该命题符号的真值分配不同而不同。该函数将继续这样做，直到所有符号都已在模型中分配了真值，使 `symbol` 符号为空。一旦它为空（由 `if not symbols` 行标识），在函数的每个实例中（其中每个实例都包含不同的模型），函数检查$KB$是否为给定的有效模型。如果$KB$在此模型中为真，函数将检查查询结论是否为真，如前所述。
|
||||
|
||||
## 知识工程 (Knowledge Engineering)
|
||||
|
||||
知识工程是弄清楚如何在 AI 中表示命题和逻辑的工程。
|
||||
|
||||
### 推理规则 (Inference Rules)
|
||||
|
||||
模型检查不是一种有效的算法，因为它必须在给出答案之前考虑每个可能的模型（提醒：如果在$KB$为真的所有模型（真值分配）下，查询结论$R$为真，则$R$ 也为真）。推理规则允许我们根据现有知识生成新信息，而无需考虑所有可能的模型。
|
||||
|
||||
推理规则通常使用将顶部部分（前提）与底部部分（结论）分开的水平条表示。前提是我们有什么知识，结论是根据这个前提可以产生什么知识。
|
||||
|
||||
|
||||
|
||||
#### 肯定前件 (Modus Ponens)
|
||||
|
||||
如果我们知道一个蕴涵及其前件为真，那么后件也为真。
|
||||
|
||||
|
||||
|
||||
#### 合取消除 (And Elimination)
|
||||
|
||||
如果 And 命题为真，则其中的任何一个原子命题也为真。例如，如果我们知道哈利与罗恩和赫敏是朋友，我们就可以得出结论，哈利与赫敏是朋友。
|
||||
|
||||
|
||||
|
||||
#### 双重否定消除 (Double Negation Elimination)
|
||||
|
||||
被两次否定的命题为真。例如，考虑命题“哈利没有通过考试是不正确的”。这两个否定相互抵消，将命题“哈利通过考试”标记为真。
|
||||
|
||||
|
||||
|
||||
#### 蕴含消除 (Implication Elimination)
|
||||
|
||||
蕴涵等价于被否定的前件和后件之间的 Or 关系。例如，命题“如果正在下雨，哈利在室内”等同于命题“(没有下雨) 或 (哈利在室内)”。
|
||||
|
||||
|
||||
|
||||
| $P$ | $Q$ | $P\to Q$ | $\lnot P\lor Q$ |
|
||||
| --- | --- | -------- | --------------- |
|
||||
| 0 | 0 | 1 | 1 |
|
||||
| 0 | 1 | 1 | 1 |
|
||||
| 1 | 0 | 0 | 0 |
|
||||
| 1 | 1 | 1 | 1 |
|
||||
|
||||
#### 等值消除 (Biconditional Elimination)
|
||||
|
||||
等值命题等价于蕴涵及其逆命题的 And 关系。例如，“当且仅当 Harry 在室内时才下雨”等同于 (“如果正在下雨，Harry 在室内”和“如果 Harry 在室内，则正在下雨”)。
|
||||
|
||||
|
||||
|
||||
#### 德摩根律 (De Morgan’s Law)
|
||||
|
||||
可以将 And 连接词变成 Or 连接词。考虑以下命题：“哈利和罗恩都通过了考试是不正确的。”由此，可以得出“哈利通过考试不是真的”或者“罗恩不是真的通过考试”的结论。也就是说，要使前面的 And 命题为真，Or 命题中至少有一个命题必须为真。
|
||||
|
||||
|
||||
|
||||
同样，可以得出相反的结论。考虑这个命题“哈利或罗恩通过考试是不正确的”。这可以改写为“哈利没有通过考试”和“罗恩没有通过考试”。
|
||||
|
||||
|
||||
|
||||
#### 分配律 (Distributive Property)
|
||||
|
||||
具有两个用 And 或 Or 连接词分组的命题可以分解为由 And 和 Or 组成的更小单元。
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
### 知识和搜索问题
|
||||
|
||||
推理可以被视为具有以下属性的搜索问题：
|
||||
|
||||
- 初始状态：知识库
|
||||
- 动作：推理规则
|
||||
- 过渡模型：推理后的新知识库
|
||||
- 目标测试：检查我们要证明的语句是否在知识库中
|
||||
- 路径成本：证明中的步骤数
|
||||
|
||||
这显示了搜索算法的通用性，使我们能够使用推理规则根据现有知识推导出新信息。
|
||||
|
||||
## 归结 (Resolution)
|
||||
|
||||
归结是一个强大的推理规则，它规定如果 Or 命题中的两个原子命题之一为假，则另一个必须为真。例如，给定命题“Ron 在礼堂”或“Hermione 在图书馆”，除了命题“Ron 不在礼堂”之外，我们还可以得出“Hermione 在图书馆”的结论。更正式地说，我们可以通过以下方式定义归结：
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
归结依赖于互补文字，两个相同的原子命题，其中一个被否定而另一个不被否定，例如$P$和$¬P$。
|
||||
|
||||
归结可以进一步推广。假设除了“Rom 在礼堂”或“Hermione 在图书馆”的命题外，我们还知道“Rom 不在礼堂”或“Harry 在睡觉”。我们可以从中推断出“Hermione 在图书馆”或“Harry 在睡觉”。正式地说：
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
互补文字使我们能够通过解析推理生成新句子。因此，推理算法定位互补文字以生成新知识。
|
||||
|
||||
从句 (Clause) 是多个原子命题的析取式（命题符号或命题符号的否定，例如$P$, $¬P$）。析取式由 Or 逻辑连接词 ($P ∨ Q ∨ R$) 相连的命题组成。另一方面，连接词由 And 逻辑连接词 ($P ∧ Q ∧ R$) 相连的命题组成。从句允许我们将任何逻辑语句转换为合取范式 (CNF)，它是从句的合取，例如：$(A ∨ B ∨ C) ∧ (D ∨ ¬E) ∧ (F ∨ G)$。
|
||||
|
||||
命题转换为合取范式的步骤、
|
||||
|
||||
1. 等值消除
|
||||
- 将$(α↔ β)$转化为$(α→ β)∧ (β → α)$
|
||||
2. 蕴含消除
|
||||
- 将$(α→ β)$转化为$\lnotα∧β$
|
||||
3. 使用德摩根定律，将否定向内移动，直到只有原子命题被否定（而不是从句）
|
||||
- 将$\lnot(\alpha∧β)$转换为$\lnotα\lor\lnotβ$
|
||||
4. 下面是一个转换$(P∧Q)\to R$到合取范式的例子：
|
||||
- $(P ∨ Q) → R$
|
||||
- $\lnot(P\lor Q)\lor R$蕴含消除
|
||||
- $(\lnot P\land\lnot Q)\lor R$德摩根律
|
||||
- $(\lnot P\lor R)\land(\lnot Q\lor R)$分配律
|
||||
|
||||
归结命题及其否定，即$\lnot P$和$P$，得到空从句$()$。空从句总是假的，这是有道理的，因为$P$和$\lnot P$ 不可能都是真的。归结算法使用了这个事实。
|
||||
|
||||
- 确定是否$KB⊨α$：
|
||||
- 检查：$(KB∧\lnotα)$是矛盾的吗？
|
||||
- 如果是这样，那么$KB⊨α$。
|
||||
- 否则，$KB$无法蕴含推理出$\alpha$。
|
||||
|
||||
矛盾证明是计算机科学中经常使用的一种工具。如果我们的知识库是真的，并且它与$\lnot α$相矛盾，那就意味着$\lnot\alpha$是假的，因此$α$必须是真的。从技术上讲，该算法将执行以下操作：
|
||||
|
||||
- 确定是否$KB⊨α$：
|
||||
- 将$(KB∧\lnotα)$转换为合取范式。
|
||||
- 继续检查，看看我们是否可以使用归结来生成一个新的从句。
|
||||
- 如果我们生成了空从句（相当于 False），那么恭喜你！我们得出了一个矛盾，从而证明了$KB⊨α$。
|
||||
- 然而，如果没有实现矛盾，并且不能推断出更多的从句，那么就没有蕴含性。
|
||||
- 以下是一个示例，说明了该算法的工作原理：
|
||||
- $(A ∨ B) ∧ (¬B ∨ C) ∧ (¬C)\vDash A?$
|
||||
- $(A ∨ B) ∧ (¬B ∨ C) ∧ (¬C) ∧ (¬A)$
|
||||
- $(\lnot B\lor C)\land\lnot C\vDash\lnot B\implies(A ∨ B) ∧ (¬B ∨ C) ∧ (¬C) ∧ (¬A)\land (\lnot B)$
|
||||
- $(A\lor B)\land\lnot B\vDash A\implies(A ∨ B) ∧ (¬B ∨ C) ∧ (¬C) ∧ (¬A)\land (\lnot B)\land(A)$
|
||||
- $(\lnot A\land A)\vDash ()\implies(A ∨ B) ∧ (¬B ∨ C) ∧ (¬C) ∧ (¬A)\land (\lnot B)\land(A)\land ()\implies False$
|
||||
|
||||
## 一阶逻辑 (First Order Logic)
|
||||
|
||||
一阶逻辑是另一种类型的逻辑，它使我们能够比命题逻辑更简洁地表达更复杂的想法。一阶逻辑使用两种类型的符号：常量符号和谓词符号。常量符号表示对象，而谓词符号类似于接受参数并返回 true 或 false 值的关系或函数。
|
||||
|
||||
例如，我们回到霍格沃茨不同的人和家庭作业的逻辑谜题。常量符号是指人或房子，如 Minerva、Pomona、Gryffindor、Hufflepuff 等。谓语符号是一些常量符号的真或虚的属性。例如，我们可以使用句子 `person(Minerva)` 来表达 Minerva 是一个人的想法。同样，我们可以用 `house(Gryffindor)` 这个句子来表达 Gryffindor 是一所房子的想法。所有的逻辑连接词都以与以前相同的方式在一阶逻辑中工作。例如，$\lnot$`House(Minerva)` 表达了 Minerva 不是房子的想法。谓词符号也可以接受两个或多个自变量，并表达它们之间的关系。例如，BelongsTo 表达了两个论点之间的关系，即人和人所属的房子。因此，Minerva 拥有 Gryffindor 的想法可以表达为 `BelongsTo(Minerva，Gryffindor)`。一阶逻辑允许每个人一个符号，每个房子一个符号。这比命题逻辑更简洁，因为命题逻辑中每个人的房屋分配都需要不同的符号。
|
||||
|
||||
### 全称量化 (Universal Quantification)
|
||||
|
||||
量化是一种可以在一阶逻辑中使用的工具，可以在不使用特定常量符号的情况下表示句子。全称量化使用符号$∀$来表示“所有”。例如，$\forall x(BelongsTo(x, Gryffindor) → ¬BelongsTo(x, Hufflepuff))$表达了这样一种观点，即对于每个符号来说，如果这个符号属于 Gryffindor，那么它就不属于 Hufflepuff。
|
||||
|
||||
### 存在量化 (Existential Quantification)
|
||||
|
||||
存在量化是一个与全称量化平行的概念。然而，虽然全称量化用于创建对所有$x$都成立的句子，但存在量化用于创建至少对一个$x$成立的句子。它使用符号$∃$表示。例如，$∃x(House(x) ∧ BelongsTo(Minerva, x))$ 意味着至少有一个符号既是房子，又是属于 Minerva。换句话说，这表达了 Minerva 拥有房子的想法。
|
||||
|
||||
存在量化和全称量化可以用在同一个句子中。例如，$∀x(Person(x) → (∃y(House(y) ∧ BelongsTo(x, y))))$表达了这样一种观点，即如果$x$是一个人，那么这个人至少拥有一个房子$y$。换句话说，这句话的意思是每个人都拥有一所房子。
|
||||
|
||||
还有其他类型的逻辑，它们之间的共同点是，它们都是为了表示信息而存在的。这些是我们用来在人工智能中表示知识的系统。
|
||||
|
||||
## 补充材料
|
||||
|
||||
Introduction to the Theory of Computation, Third International Edition (Michael Sipser)
|
||||
|
||||
具体数学：计算机科学基础。第 2 版
|
||||
56
2023旧版内容/4.人工智能/4.3.3.1程序示例.md
Normal file
56
2023旧版内容/4.人工智能/4.3.3.1程序示例.md
Normal file
@@ -0,0 +1,56 @@
|
||||
# 程序示例
|
||||
|
||||
::: tip
|
||||
阅读程序，然后“玩一玩”程序！
|
||||
|
||||
完成习题
|
||||
:::
|
||||
|
||||
::: tip 📥
|
||||
本节附件下载 <Download url="https://cdn.xyxsw.site/code/3-Lecture.zip"/>
|
||||
:::
|
||||
|
||||
本节代码不做额外梳理，[不确定性问题](./4.3.3%E4%B8%8D%E7%A1%AE%E5%AE%9A%E6%80%A7%E9%97%AE%E9%A2%98.md) 中已有解释。
|
||||
|
||||
## Quiz
|
||||
|
||||
1. 考虑一副标准的 52 张牌，在四种花色（梅花、方块、红心、黑桃）中各有 13 种牌值（A、K、Q、J 和 2-10）。如果随机抽出一张牌，它是黑桃或 2 的概率是多少？
|
||||
1. About 0.019
|
||||
2. About 0.077
|
||||
3. About 0.17
|
||||
4. About 0.25
|
||||
5. About 0.308
|
||||
6. About 0.327
|
||||
7. About 0.5
|
||||
8. None of the above
|
||||
2. 想象一下，抛出两枚硬币，每枚硬币都有正面和反面，50% 的时间出现正面，50% 的时间出现反面。抛出这两枚硬币后，其中一枚是正面，另一枚是反面的概率是多少？
|
||||
1. 0
|
||||
2. 0.125
|
||||
3. 0.25
|
||||
4. 0.375
|
||||
5. 0.5
|
||||
6. 0.625
|
||||
7. 0.75
|
||||
8. 0.875
|
||||
9. 1
|
||||
3. 回答关于贝叶斯网络的问题，问题如下：
|
||||
|
||||
以下哪句话是真的？
|
||||
|
||||
1. 假设我们知道有轨道维护，那么是否有雨并不影响列车准时到达的概率。
|
||||
2. 假设我们知道有雨，那么是否有轨道维修并不影响列车准时到达的概率。
|
||||
3. 假设我们知道火车是准时的，是否有雨会影响到赴约的概率。
|
||||
4. 假设我们知道火车是准时的，那么是否有轨道维修并不影响赴约的概率。
|
||||
5. 假设我们知道有轨道维护，那么是否有雨并不影响参加约会的概率。
|
||||
4. 两家工厂--A 厂和 B 厂--设计用于手机的电池。A 厂生产 60% 的电池，B 厂生产另外 40%。A 厂 2% 的电池有缺陷，B 厂 4% 的电池有缺陷。一个电池既由 A 厂生产又有缺陷的概率是多少？
|
||||
1. 0.008
|
||||
2. 0.012
|
||||
3. 0.024
|
||||
4. 0.028
|
||||
5. 0.02
|
||||
6. 0.06
|
||||
7. 0.12
|
||||
8. 0.2
|
||||
9. 0.429
|
||||
10. 0.6
|
||||
11. None of the above
|
||||
119
2023旧版内容/4.人工智能/4.3.3.2项目：遗传.md
Normal file
119
2023旧版内容/4.人工智能/4.3.3.2项目：遗传.md
Normal file
@@ -0,0 +1,119 @@
|
||||
# 项目：遗传
|
||||
|
||||
::: tip
|
||||
我们为你提供了一个简单有趣的项目，帮助你进行知识巩固，请认真阅读文档内容。
|
||||
|
||||
如果你卡住了，请记得回来阅读文档，或请求身边人的帮助。
|
||||
:::
|
||||
|
||||
::: tip 📥
|
||||
本节附件下载 <Download url="https://cdn.xyxsw.site/code/3-Projects.zip"/>
|
||||
:::
|
||||
|
||||
## 背景
|
||||
|
||||
GJB2 基因的突变版本是导致新生儿听力障碍的主要原因之一。每个人都携带两个版本的基因，因此每个人都有可能拥有 0、1 或 2 个听力障碍版本的 GJB2 基因。不过，除非一个人接受基因测试，否则要知道一个人拥有多少个变异的 GJB2 基因并不那么容易。这是一些 "隐藏状态"：具有我们可以观察到的影响（听力损伤）的信息，但我们不一定直接知道。毕竟，有些人可能有 1 或 2 个突变的 GJB2 基因，但没有表现出听力障碍，而其他人可能没有突变的 GJB2 基因，但仍然表现出听力障碍。
|
||||
|
||||
每个孩子都会从他们的父母那里继承一个 GJB2 基因。如果父母有两个变异基因，那么他们会将变异基因传给孩子；如果父母没有变异基因，那么他们不会将变异基因传给孩子；如果父母有一个变异基因，那么该基因传给孩子的概率为 0.5。不过，在基因被传递后，它有一定的概率发生额外的突变：从导致听力障碍的基因版本转变为不导致听力障碍的版本，或者反过来。
|
||||
|
||||
我们可以尝试通过对所有相关变量形成一个贝叶斯网络来模拟所有这些关系，就像下面这个网络一样，它考虑了一个由两个父母和一个孩子组成的家庭。
|
||||
|
||||
|
||||
|
||||
家庭中的每个人都有一个 `Gene` 随机变量，代表一个人有多少个特定基因（例如，GJB2 的听力障碍版本）：一个 0、1 或 2 的值。家族中的每个人也有一个 `Trait` 随机变量，它是 `yes` 或 `no`，取决于该人是否表达基于该基因的性状（例如，听力障碍）。从每个人的 `Gene` 变量到他们的 `Trait` 变量之间有一个箭头，以编码一个人的基因影响他们具有特定性状的概率的想法。同时，也有一个箭头从母亲和父亲的 `Gene` 随机变量到他们孩子的 `Gene` 随机变量：孩子的基因取决于他们父母的基因。
|
||||
|
||||
你在这个项目中的任务是使用这个模型对人群进行推断。给出人们的信息，他们的父母是谁，以及他们是否具有由特定基因引起的特定可观察特征（如听力损失），你的人工智能将推断出每个人的基因的概率分布，以及任何一个人是否会表现出有关特征的概率分布。
|
||||
|
||||
## 理解
|
||||
|
||||
打开 `data/family0.csv`，看看数据目录中的一个样本数据集（你可以在文本编辑器中打开，或者在 Google Sheets、Excel 或 Apple Numbers 等电子表格应用程序中打开）。注意，第一行定义了这个 CSV 文件的列：`name`, `mother`, `father`, 和 `trait`。下一行表明 Harry 的母亲是 Lily，父亲是 James，而 `Trait` 的空单元格意味着我们不知道 Harry 是否有这种性状。同时，James 在我们的数据集中没有列出父母（如母亲和父亲的空单元格所示），但确实表现出了性状（如 `Trait` 单元格中的 1 所示）。另一方面，Lily 在数据集中也没有列出父母，但没有表现出这种性状（如 `Trait` 单元格中的 0 表示）。
|
||||
|
||||
打开 `heredity.py`，首先看一下 `PROBS` 的定义。`PROBS` 是一个包含若干常数的字典，代表各种不同事件的概率。所有这些事件都与一个人拥有多少个特定的突变基因，以及一个人是否基于该基因表现出特定的性状有关。这里的数据松散地基于 GJB2 基因的听力障碍版本和听力障碍性状的概率，但通过改变这些值，你也可以用你的人工智能来推断其他的基因和性状！
|
||||
|
||||
首先，`PROBS["gene"]` 代表了该基因的无条件概率分布（即如果我们对该人的父母一无所知的概率）。根据分布代码中的数据，在人群中，有 1% 的机会拥有该基因的 2 个副本，3% 的机会拥有该基因的 1 个副本，96% 的机会拥有该基因的零副本。
|
||||
|
||||
接下来，`PROBS["trait"]` 表示一个人表现出某种性状（如听力障碍）的条件概率。这实际上是三个不同的概率分布：基因的每个可能值都有一个。因此，`PROBS["trait"][2]` 是一个人在有两个突变基因的情况下具有该特征的概率分布：在这种情况下，他们有 65% 的机会表现出该特征，而有 35% 的机会不表现出该特征。同时，如果一个人有 0 个变异基因，他们有 1% 的机会表现出该性状，99% 的机会不表现出该性状。
|
||||
|
||||
最后，`PROBS["mutation"]` 是一个基因从作为相关基因突变为不是该基因的概率，反之亦然。例如，如果一个母亲有两个变异基因，并因此将其中一个传给她的孩子，就有 1% 的机会突变为不再是变异基因。相反，如果一个母亲没有任何变异基因，因此没有把变异基因传给她的孩子，但仍有 1% 的机会突变为变异基因。因此，即使父母双方都没有变异基因，他们的孩子也可能有 1 个甚至 2 个变异基因。
|
||||
|
||||
最终，你计算的概率将以 `PROBS` 中的这些数值为基础。
|
||||
|
||||
现在，看一下 `main` 函数。该函数首先将数据从一个文件加载到一个字典 `people` 中。`people` 将每个人的名字映射到另一个包含他们信息的字典中：包括他们的名字，他们的母亲（如果数据集中有一个母亲），他们的父亲（如果数据集中有一个父亲），以及他们是否被观察到有相关的特征（如果有则为 `True`，没有则为 `False`，如果我们不知道则为 `None`）。
|
||||
接下来，`main` 中定义了一个字典 `probabilities`，所有的概率最初都设置为 0。这就是你的项目最终要计算的内容：对于每个人，你的人工智能将计算他们有多少个变异基因的概率分布，以及他们是否具有该性状。例如，`probabilities["Harry"]["gene"][1]` 将是 Harry 有 1 个变异基因的概率，而 `probabilities["Lily"]["trait"][False]` 将是 Lily 没有表现出该性状的概率。
|
||||
|
||||
如果不熟悉的话，这个 `probabilities` 字典是用 [python 字典](https://www.python.org/dev/peps/pep-0274/)创建的，在这种情况下，它为我们的 `people` 中的每个 `person` 创建一个键/值对。
|
||||
|
||||
最终，我们希望根据一些证据来计算这些概率：鉴于我们知道某些人有或没有这种特征，我们想确定这些概率。你在这个项目中的任务是实现三个函数来做到这一点： `joint_probability` 计算一个联合概率，`update` 将新计算的联合概率添加到现有的概率分布中，然后 `normalize` 以确保所有概率分布最后和为 1。
|
||||
|
||||
## 明确
|
||||
|
||||
完成 `joint_probability`、`update` 和 `normalize` 的实现。
|
||||
|
||||
`joint_probability` 函数应该接受一个 `people` 的字典作为输入，以及关于谁拥有多少个变异基因，以及谁表现出该特征的数据。该函数应该返回所有这些事件发生的联合概率。
|
||||
|
||||
- 该函数接受四个数值作为输入：`people`, `one_gene`, `two_genes`, 和 `have_trait`。
|
||||
|
||||
- `people` 是一个在 "理解"一节中描述的人的字典。键代表名字，值是包含 `mother` 和 `father` 键的字典。你可以假设 `mother` 和 `father` 都是空白的（数据集中没有父母的信息），或者 `mother` 和 `father` 都会指代 `people` 字典中的其他人物。
|
||||
- `one_gene` 是一个集合，我们想计算所有集合元素有一个变异基因的概率。
|
||||
- `two_genes` 是一个集合，我们想计算所有集合元素有两个变异基因的概率。
|
||||
- `have_trait` 是一个集合，我们想计算所有集合元素拥有该性状的概率。
|
||||
- 对于不在 `one_gene` 或 t `wo_genes` 中的人，我们想计算他们没有变异基因的概率；对于不在 `have_trait` 中的人，我们想计算他们没有该性状的概率。
|
||||
|
||||
- 例如，如果这个家庭由 Harry、James 和 Lily 组成，那么在 `one_gene = {"Harry"}`、`two_genes = {"James"}` 和 `trait = {"Harry"、"James"}` 的情况下调用这个函数，应该计算出 Lily 没有变异基因、Harry 拥有一个变异基因、James 拥有两个变异基因、Harry 表现出该性状、James 表现出该性状和 Lily 没有表现出该性状的联合概率。
|
||||
- 对于数据集中没有列出父母的人，使用概率分布 `PROBS["gene"]` 来确定他们有特定数量基因的概率。
|
||||
- 对于数据集中有父母的人来说，每个父母都会把他们的两个基因中的一个随机地传给他们的孩子，而且有一个 `PROBS["mutation"]` 的机会，即它会发生突变（从变异基因变成正常基因，或者相反）。
|
||||
- 使用概率分布 `PROBS["trait"]` 来计算一个人具有或不具有形状的概率。
|
||||
|
||||
`update` 函数将一个新的联合分布概率添加到 `probabilities` 中的现有概率分布中。
|
||||
|
||||
- 该函数接受五个值作为输入：`probabilities`, `one_gene`, `two_genes`, `have_trait`, 和 `p`。
|
||||
|
||||
- `probabilities` 是一个在 "理解 "部分提到的字典。每个人都被映射到一个 `"gene"` 分布和一个 `"trait"` 分布。
|
||||
- `one_gene` 是一个集合，我们想计算所有集合元素有一个变异基因的概率。
|
||||
- `two_genes` 是一个集合，我们想计算所有集合元素有两个变异基因的概率。
|
||||
- `have_trait` 是一个集合，我们想计算所有集合元素拥有该性状的概率。
|
||||
- `p` 是联合分布的概率。
|
||||
- 对于概率中的每个人，该函数应该更新 `probabilities[person]["gene"]` 分布和 `probabilities[person]["trait"]` 分布，在每个分布中的适当数值上加上 `p`。所有其他数值应保持不变。
|
||||
- 例如，如果"Harry"同时出现在 `two_genes` 和 `have_trait` 中，那么 `p` 将被添加到 `probabilities["Harry"]["gene"][2]` 和 `probabilities["Harry"]["trait"][True]`。
|
||||
- 该函数不应返回任何值：它只需要更新 `probabilities` 字典。
|
||||
|
||||
`normalize` 函数更新 `probabilities` 字典，使每个概率分布被归一化（即和为 1，相对比例相同）。
|
||||
|
||||
- 该函数接受一个单一的值：`probabilities`。
|
||||
|
||||
- `probabilities` 是一个在"理解"部分提到的字典。每个人都被映射到一个 `"gene"` 分布和一个 `"trait"` 分布。
|
||||
- 对于 `probabilities` 中每个人的两个分布，这个函数应该将该分布归一化，使分布中的数值之和为 1，分布中的相对数值是相同的。
|
||||
- 例如，如果 `probabilities["Harry"]["trait"][True]` 等于 `0.1`，概率 `probabilities["Harry"]["trait"][False]` 等于 `0.3`，那么你的函数应该将前一个值更新为 `0.25`，后一个值更新为 `0.75`: 现在数字之和为 1，而且后一个值仍然比前一个值大三倍。
|
||||
- 该函数不应返回任何值：它只需要更新 `probabilities` 字典。
|
||||
|
||||
除了规范中要求你实现的三个函数外，你不应该修改 `heredity.py` 中的任何其他东西，尽管你可以编写额外的函数和/或导入其他 Python 标准库模块。如果熟悉的话，你也可以导入 `numpy` 或 `pandas`，但是你不应该使用任何其他第三方 Python 模块。
|
||||
|
||||
## 一个联合概率例子
|
||||
|
||||
为了帮助你思考如何计算联合概率，我们在下面附上一个例子。
|
||||
|
||||
请考虑以下 `people` 的值：
|
||||
|
||||
```python
|
||||
{
|
||||
'Harry': {'name': 'Harry', 'mother': 'Lily', 'father': 'James', 'trait': None},
|
||||
'James': {'name': 'James', 'mother': None, 'father': None, 'trait': True},
|
||||
'Lily': {'name': 'Lily', 'mother': None, 'father': None, 'trait': False}
|
||||
}
|
||||
```
|
||||
|
||||
这里我们将展示 `joint_probability(people, {"Harry"}, {"James"}, {"James"})` 的计算。根据参数，`one_gene` 是 `{"Harry"}`，`two_genes` 是 `{"James"}`，而 `has_trait` 是 `{"James"}`。因此，这代表了以下的概率：Lily 没有变异基因，不具有该性状；Harry 有一个变异基因，不具有该性状；James 有 2 个变异基因，具有该性状。
|
||||
|
||||
我们从 Lily 开始（我们考虑人的顺序并不重要，只要我们把正确的数值乘在一起，因为乘法是可交换的）。Lily 没有变异基因，概率为 `0.96`（这就是 `PROBS["gene"][0]`）。鉴于她没有变异基因，她没有这个性状的概率为 `0.99`（这是 `PROBS["trait"][0][False]`）。因此，她没有变异基因且没有该性状的概率是 `0.96*0.99=0.9504`。
|
||||
|
||||
接下来，我们考虑 James。James 有 2 个变异基因，概率为 `0.01`（这是 `PROBS["gene"][2]`）。鉴于他有 2 个变异基因，他确实具有该性状的概率为 `0.65`。因此，他有 2 个变异基因并且他确实具有该性状的概率是 `0.01*0.65=0.0065`。
|
||||
|
||||
最后，我们考虑 Harry。Harry 有 1 个变异基因的概率是多少？有两种情况可以发生。要么他从母亲那里得到这个基因，而不是从父亲那里，要么他从父亲那里得到这个基因，而不是从母亲那里。他的母亲 Lily 没有变异基因，所以 Harry 会以 `0.01` 的概率从他母亲那里得到这个基因（这是 `PROBS["mutation"]`），因为从他母亲那里得到这个基因的唯一途径是基因突变；相反，Harry 不会从他母亲那里得到这个基因，概率是 `0.99`。他的父亲 James 有 2 个变异基因，所以 Harry 会以 `0.99` 的概率从他父亲那里得到这个基因（这是 `1-PROBS["mutation"]`），但会以 `0.01` 的概率从他母亲那里得到这个基因（突变的概率）。这两种情况加在一起可以得到 `0.99*0.99+0.01*0.01=0.9802`，即 Harry 有 1 个变异基因的概率。
|
||||
|
||||
考虑到 Harry 有 1 个变异基因，他没有该性状的概率是 `0.44`（这是 `PROBS["trait"][1][false]`）。因此，哈利有 1 个变异基因而没有该性状的概率是 `0.9802 * 0.44 = 0.431288`。
|
||||
|
||||
因此，整个联合概率是三个人中每个人的所有这些数值相乘的结果：`0.9504 * 0.0065 * 0.431288 = 0.0026643247488`。
|
||||
|
||||
## 提示
|
||||
|
||||
- 回顾一下，要计算多个事件的联合概率，你可以通过将这些概率相乘来实现。但请记住，对于任何孩子来说，他们拥有一定数量的基因的概率是以他们的父母拥有什么基因为条件的。
|
||||
485
2023旧版内容/4.人工智能/4.3.3不确定性问题.md
Normal file
485
2023旧版内容/4.人工智能/4.3.3不确定性问题.md
Normal file
@@ -0,0 +1,485 @@
|
||||
# 不确定性问题
|
||||
|
||||
上一讲中，我们讨论了人工智能如何表示和推导新知识。然而，在现实中，人工智能往往对世界只有部分了解，这给不确定性留下了空间。尽管如此，我们还是希望我们的人工智能在这些情况下做出尽可能好的决定。例如，在预测天气时，人工智能掌握了今天的天气信息，但无法 100% 准确地预测明天的天气。尽管如此，我们可以做得比偶然更好，今天的讲座是关于我们如何创造人工智能，在有限的信息和不确定性的情况下做出最佳决策。
|
||||
|
||||
## 概率 (Probability)
|
||||
|
||||
不确定性可以表示为多个事件以及每一个事件发生的可能性或概率。
|
||||
|
||||
### 概率世界
|
||||
|
||||
每一种可能的情况都可以被视为一个世界，由小写的希腊字母$ω$表示。例如，掷骰子可以产生六个可能的世界：骰子出现 1 的世界，骰子出现 2 的世界，依此类推。为了表示某个世界的概率，我们写$P(ω)$。
|
||||
|
||||
### 概率公理
|
||||
|
||||
- $0<P(ω)<1$ ：表示概率的每个值必须在 0 和 1 之间。
|
||||
- 0 是一个不可能发生的事件，就像掷一个标准骰子并出现 7 一样。
|
||||
- 1 是肯定会发生的事件，比如掷标准骰子，得到的值小于 10。
|
||||
- 一般来说，值越高，事件发生的可能性就越大。
|
||||
- 每一个可能发生的事件的概率加在一起等于 1。
|
||||
|
||||
$$\sum_{\omega\in\Omega}P(\omega)=1$$
|
||||
|
||||
用标准骰子掷出数字 R 的概率可以表示为 $P(R)$ 。在我们的例子中，$P(R)=1/6$ ，因为有六个可能的世界（从 1 到 6 的任何数字），并且每个世界有相同的可能性发生。现在，考虑掷两个骰子的事件。现在，有 36 个可能的事件，同样有相同的可能性发生。
|
||||
|
||||
|
||||
|
||||
然而，如果我们试图预测两个骰子的总和，会发生什么？在这种情况下，我们只有 11 个可能的值（总和必须在 2 到 12 之间），而且它们的出现频率并不相同。
|
||||
|
||||
|
||||
|
||||
为了得到事件发生的概率，我们将事件发生的世界数量除以可能发生的世界总数。例如，当掷两个骰子时，有 36 个可能的世界。只有在其中一个世界中，当两个骰子都得到 6 时，我们才能得到 12 的总和。因此，$P(12)＝\frac{1}{36}$，或者，换句话说，掷两个骰子并得到两个和为 12 的数字的概率是$\frac{1}{36}$。$P(7)$是多少？我们数了数，发现和 7 出现在 6 个世界中。因此，$P(7)＝\frac{6}{36}＝\frac{1}{6}$。
|
||||
|
||||
### 无条件概率 (Unconditional Probability)
|
||||
|
||||
无条件概率是指在没有任何其他证据的情况下对命题发生的概率。到目前为止，我们所问的所有问题都是无条件概率的问题，因为掷骰子的结果并不取决于之前的事件。
|
||||
|
||||
## 条件概率 (Conditional Probability)
|
||||
|
||||
条件概率是在给定一些已经揭示的证据的情况下，命题发生的概率。正如引言中所讨论的，人工智能可以利用部分信息对未来进行有根据的猜测。为了使用这些影响事件在未来发生概率的信息，我们需要依赖条件概率。
|
||||
|
||||
条件概率用以下符号表示：$P(a|b)$，意思是“如果我们知道事件$b$已经发生，事件$a$发生的概率”，或者更简洁地说，“给定$b$的概率”。现在我们可以问一些问题，比如如果昨天下雨，今天下雨的概率是多少$P(今天下雨 | 昨天下雨)$，或者给定患者的测试结果，患者患有该疾病的概率 $P(疾病 | 测试结果)$ 是多少。
|
||||
|
||||
在数学上，为了计算给定$b$的条件概率，我们使用公式：$P(a|b)=\frac{P(a\land b)}{P(b)}$
|
||||
|
||||
换句话说，给定$b$为真的概率等于$a$并且$b$为真，除以$b$的概率。对此进行推理的一种直观方式是认为“我们对$a$并且$b$都为真的事件（分子）感兴趣，但只对我们知道$b$为真（分母）的世界感兴趣。“除以 $b$ 将可能的世界限制在 $b$ 为真的世界。以下是上述公式的代数等价形式：
|
||||
|
||||
$P(a\land b)=P(b)P(a|b)$
|
||||
|
||||
$P(a\land b)=P(a)P(b|a)$
|
||||
|
||||
例如，考虑$P(总和为 12|在一个骰子上掷出 6)$，或者掷两个骰子假设我们已经掷了一个骰子并获得了六，得到十二的概率。为了计算这一点，我们首先将我们的世界限制在第一个骰子的值为六的世界：
|
||||
|
||||
|
||||
|
||||
现在我们问，在我们将问题限制在（除以$P(6)$，或第一个骰子产生 6 的概率）的世界中，事件 a（和为 12）发生了多少次？
|
||||
|
||||
|
||||
|
||||
## 随机变量 (Random Variables)
|
||||
|
||||
随机变量是概率论中的一个变量，它有一个可能取值的域。例如，为了表示掷骰子时的可能结果，我们可以定义一个随机变量 Roll，它可以取值$\set{0，1，2，3，4，5，6}$。为了表示航班的状态，我们可以定义一个变量 flight，它采用$\set{准时、延迟、取消}$的值。
|
||||
|
||||
通常，我们对每个值发生的概率感兴趣。我们用概率分布来表示这一点。例如：
|
||||
|
||||
$P(Flight=准时)=0.6$
|
||||
|
||||
$P(Flight=延迟)=0.3$
|
||||
|
||||
$P(Flight=取消)=0.1$
|
||||
|
||||
用文字来解释概率分布，这意味着航班准时的可能性为 60%，延误的可能性为 30%，取消的可能性为 10%。注意，如前所述，所有可能结果的概率之和为 1。
|
||||
|
||||
概率分布可以更简洁地表示为向量。例如，$P(Flight)=<0.6，0.3，0.1>$。为了便于解释，这些值有一个固定的顺序（在我们的情况下，准时、延迟、取消）。
|
||||
|
||||
### 独立性 (Independence)
|
||||
|
||||
独立性是指一个事件的发生不会影响另一个事件发生的概率。例如，当掷两个骰子时，每个骰子的结果与另一个骰子的结果是独立的。用第一个骰子掷出 4 不会影响我们掷出的第二个骰子的值。这与依赖事件相反，比如早上的云和下午的雨。如果早上多云，下午更有可能下雨，所以这些事件是有依赖性的。
|
||||
|
||||
独立性可以用数学定义：事件$a$和$b$是独立的，当且仅当$a$并且$b$的概率等于$a$的概率乘以$b$的概率：$P(a∧b)=P(a)P(b)$。
|
||||
|
||||
## 贝叶斯规则 (Bayes’Rule)
|
||||
|
||||
贝叶斯规则在概率论中常用来计算条件概率。换句话说，贝叶斯规则说，给定$b$条件下$a$的概率等于给定$a$的条件下$b$概率，乘以$b$的概率除以$a$ 的概率。
|
||||
|
||||
$P(b|a)=\frac{P(a|b)P(b)}{P(a)}$
|
||||
|
||||
例如，如果早上有云，我们想计算下午下雨的概率，或者$P(雨 | 云)$。我们从以下信息开始：
|
||||
|
||||
- 80% 的雨天下午开始于多云的早晨，或$P(云 | 雨)$。
|
||||
- 40% 的日子早晨多云，或$P(云)$。
|
||||
- 10% 的日子有下雨的下午，或$P(雨)$。
|
||||
|
||||
应用贝叶斯规则，我们计算$\frac{0.8*0.1}{0.4}=0.2$。也就是说，考虑到早上多云，下午下雨的可能性是 20%。
|
||||
|
||||
除了$P(a)$和$P(b)$之外，知道$P(a|b)$还允许我们计算$P(b|a)$。这是有帮助的，因为知道给定未知原因的可见效应的条件概率$P(可见效应 | 未知原因)$，可以让我们计算给定可见效应的未知原因的概率$P(未知原因 | 可见效应)$。例如，我们可以通过医学试验来学习$P(医学测试结果 | 疾病)$，在医学试验中，我们对患有该疾病的人进行测试，并观察测试结果发生的频率。知道了这一点，我们就可以计算出$P(疾病 | 医学检测结果)$，这是有价值的诊断信息。
|
||||
|
||||
## 联合概率 (Joint Probability)
|
||||
|
||||
联合概率是指多个事件全部发生的可能性。
|
||||
|
||||
让我们考虑下面的例子，关于早上有云，下午有雨的概率。
|
||||
|
||||
| C=云 | C=$\lnot$云 |
|
||||
| ---- | ----------- |
|
||||
| 0.4 | 0.6 |
|
||||
|
||||
| R=雨 | R=$\lnot$雨 |
|
||||
| ---- | ----------- |
|
||||
| 0.1 | 0.9 |
|
||||
|
||||
从这些数据来看，我们无法判断早上的云是否与下午下雨的可能性有关。为了做到这一点，我们需要看看这两个变量所有可能结果的联合概率。我们可以将其表示在下表中：
|
||||
|
||||
| | R=雨 | R=$\lnot$ 雨 |
|
||||
| ----------- | ---- | ------------ |
|
||||
| C=云 | 0.08 | 0.32 |
|
||||
| C=$\lnot$云 | 0.02 | 0.58 |
|
||||
|
||||
现在我们可以知道有关这些事件同时发生的信息了。例如，我们知道某一天早上有云，下午有雨的概率是 0.08。早上没有云，下午没有雨的概率是 0.58。
|
||||
|
||||
使用联合概率，我们可以推导出条件概率。例如，如果我们感兴趣的是在下午下雨的情况下，早上云层的概率分布。$P(C|雨)=\frac{P(C，雨)}{P(雨)}$旁注：在概率上，逗号和$∧$可以互换使用。因此，$P(C，雨)=P(C\land 雨)$。换句话说，我们将降雨和云层的联合概率除以降雨的概率。
|
||||
|
||||
在最后一个方程中，可以将$P(雨)$视为$P(C，雨)$乘以的某个常数$\alpha=\frac{1}{P(雨)}$。因此，我们可以重写$P(C|雨)=\frac{P(C，雨)}{P(雨)}=αP(C，雨)$，或$α<0.08,0.02>=<0.8,0.2>$。考虑到下午有雨，将$α$分解后，我们可以得到 C 的可能值的概率比例。也就是说，如果下午有雨，那么早上有云和早上没有云的概率的比例是$0.08:0.02$。请注意，0.08 和 0.02 的总和不等于 1；然而，由于这是随机变量 C 的概率分布，我们知道它们应该加起来为 1。因此，我们需要通过算$α$来归一化这些值，使得$α0.08+α0.02=1$。最后，我们可以说$P(C|雨)=<0.8,0.2>$。
|
||||
|
||||
## 概率规则 (Probability Rules)
|
||||
|
||||
- 否定 (Negation): $P(\lnot a)=1-P(a)$。这源于这样一个事实，即所有可能世界的概率之和为 1，互补事件$\lnot a$和 $a$ 包括所有可能世界。
|
||||
- 包含 - 排除 Inclusion-Exclusion：$P(a\lor b)=P(a)+P(b)-P(a\land b)$。这可以用以下方式解释：$a$或$b$为真的世界等于$a$为真的所有世界，加上$b$为真的所有世界。然而，在这种情况下，有些世界被计算两次（a 和$b$都为真的世界）。为了消除这种重叠，我们将$a$和$b$ 都为真的世界减去一次（因为它们被计算了两次）。
|
||||
|
||||
> 下面是一个例子，可以说明这一点。假设我 80% 的时间吃冰淇淋，70% 的时间吃饼干。如果我们计算今天我吃冰淇淋或饼干的概率，不减去$P(冰淇淋∧饼干)$，我们错误地得出 0.7+0.8=1.5。这与概率在 0 和 1 之间的公理相矛盾。为了纠正我同时吃冰淇淋和饼干的天数计算两次的错误，我们需要减去$P(冰淇淋∧饼干)$一次。
|
||||
- 边缘化 (Marginalization)：$P(a)=P(a,b)+P(a,\lnot b)$。这里的观点是，$b$和$\lnot b$是独立的概率。也就是说，$b$和$\lnot b$同时发生的概率为 0。我们也知道$b$和$\lnot b$的总和为 1。因此，当$a$发生时，$b$可以发生也可以不发生。当我们把$a$和$b$发生的概率加上$a$和$\lnot b$的概率时，我们得到的只是$a$ 的概率。
|
||||
|
||||
随机变量的边缘化可以用：$P(X=x_i)=\sum_jP(X=x_i,Y=y_j)$表示
|
||||
|
||||
方程的左侧表示“随机变量$X$具有$x_i$值的概率”例如，对于我们前面提到的变量 C，两个可能的值是早上有云和早上没有云。等式的正确部分是边缘化的概念。$P(X=x_i)$等于$x_i$以及随机变量$Y$的每一个值的所有联合概率之和。例如，$P(C=云)=P(C=云，R=雨)+P(C=云，R=\lnot 雨)=0.08+0.32=0.4$。
|
||||
|
||||
- 条件边缘化：$P(a)=P(a|b)P(b)+P(a|\lnot b)P(\lnot b)$。这是一个类似于边缘化的想法。事件$a$发生的概率等于给定$b$的概率乘以$b$的概率，再加上给定$\lnot b$的概率乘以$\lnot b$ 的概率。
|
||||
|
||||
$P(X=x_i)=\sum_jP(X=x_i|Y=y_i)P(Y=y_i)$
|
||||
|
||||
在这个公式中，随机变量$X$取$x_i$值概率等于$x_i$以及随机变量$Y$的每个值的联合概率乘以变量$Y$取该值的概率之和。如果我们还记得$P(a|b)=\frac{P(a，b)}{P(b)}$，就可以理解这个公式。如果我们将这个表达式乘以$P(b)$，我们得到$P(a,b)$，从这里开始，我们做的与边缘化相同。
|
||||
|
||||
## 贝叶斯网络 (Bayesian Networks)
|
||||
|
||||
贝叶斯网络是一种表示随机变量之间相关性的数据结构。贝叶斯网络具有以下属性：
|
||||
|
||||
- 它们是有向图。
|
||||
- 图上的每个节点表示一个随机变量。
|
||||
- 从 X 到 Y 的箭头表示 X 是 Y 的父对象。也就是说，Y 的概率分布取决于 X 的值。
|
||||
- 每个节点 X 具有概率分布$P(X|Parents(X))$。
|
||||
|
||||
让我们考虑一个贝叶斯网络的例子，该网络包含影响我们是否按时赴约的随机变量。
|
||||
|
||||
|
||||
|
||||
让我们从上到下描述这个贝叶斯网络：
|
||||
|
||||
- rain 是这个网络的根节点。这意味着它的概率分布不依赖于任何先前的事件。在我们的例子中，Rain 是一个随机变量，可以采用以下概率分布的值$\set{none，light，heavy}$：
|
||||
|
||||
| none | light | heavy |
|
||||
| ---- | ----- | ----- |
|
||||
| 0.7 | 0.2 | 0.1 |
|
||||
|
||||
- Maintenance 对是否有列车轨道维护进行编码，取值为$\set{yes，no}$。Rain 是 Maintenance 的父节点，这意味着 Maintenance 概率分布受到 Rain 的影响。
|
||||
|
||||
| R | yes | no |
|
||||
| ----- | --- | --- |
|
||||
| none | 0.4 | 0.6 |
|
||||
| light | 0.2 | 0.8 |
|
||||
| heavy | 0.1 | 0.9 |
|
||||
|
||||
- Train 是一个变量，用于编码列车是准时还是晚点，取值为$\set{on\ time，delayed}$。请注意，列车上被“Maintenance”和“rain”指向。这意味着两者都是 Train 的父对象，它们的值会影响 Train 的概率分布。
|
||||
|
||||
| R | M | On time | Delayed |
|
||||
| ------ | --- | ------- | ------- |
|
||||
| none | yes | 0.8 | 0.2 |
|
||||
| none | no | 0.9 | 0.1 |
|
||||
| light | yes | 0.6 | 0.4 |
|
||||
| light | no | 0.7 | 0.3 |
|
||||
| heavry | yes | 0.4 | 0.6 |
|
||||
| heavy | no | 0.5 | 0.5 |
|
||||
|
||||
- Appointment 是一个随机变量，表示我们是否参加约会，取值为$\set{attend, miss}$。请注意，它唯一的父级是 Train。关于贝叶斯网络的这一点值得注意：父子只包括直接关系。的确，Maintenance 会影响 Train 是否准时，而 Train 是否准时会影响我们是否赴约。然而，最终，直接影响我们赴约机会的是 Train 是否准时，这就是贝叶斯网络所代表的。例如，如果火车准时到达，可能会有大雨和轨道维护，但这对我们是否赴约没有影响。
|
||||
|
||||
| T | attend | miss |
|
||||
| ------- | ------ | ---- |
|
||||
| on time | 0.9 | 0.1 |
|
||||
| delayed | 0.6 | 0.4 |
|
||||
|
||||
例如，如果我们想找出在没有维护和小雨的一天火车晚点时错过约会的概率，或者$P(light,no,delayed,miss)$，我们将计算如下：$P(light)P(no|light)P(delayed|light,no)P(miss|delayed)$。每个单独概率的值可以在上面的概率分布中找到，然后将这些值相乘以产生$P(light,no,delayed,miss)$。
|
||||
|
||||
### 推理 (Inference)
|
||||
|
||||
在知识推理，我们通过蕴含来看待推理。这意味着我们可以在现有信息的基础上得出新的信息。我们也可以根据概率推断出新的信息。虽然这不能让我们确切地知道新的信息，但它可以让我们计算出一些值的概率分布。推理具有多个属性。
|
||||
- Query 查询变量 $X$：我们要计算概率分布的变量。
|
||||
- Evidence variables 证据变量$E$: 一个或多个观测到事件$e$ 的变量。例如，我们可能观测到有小雨，这一观测有助于我们计算火车延误的概率。
|
||||
- Hidden variables 隐藏变量 $H$: 不是查询结论的变量，也没有被观测到。例如，站在火车站，我们可以观察是否下雨，但我们不知道道路后面的轨道是否有维修。因此，在这种情况下，Maintenance 将是一个隐藏的变量。
|
||||
- The goal 目标：计算$P(X|e)$。例如，根据我们知道有小雨的证据 $e$ 计算 Train 变量 (查询) 的概率分布。
|
||||
|
||||
举一个例子。考虑到有小雨和没有轨道维护的证据，我们想计算 Appointment 变量的概率分布。也就是说，我们知道有小雨，没有轨道维护，我们想弄清楚我们参加约会和错过约会的概率是多少，$P(Appointment|light,no)$。从联合概率部分中，我们知道我们可以将约会随机变量的可能值表示为一个比例，将$P(Appointment|light,no)$重写为$αP(Appointment,light,no)$。如果 Appointment 的父节点仅为 Train 变量，而不是 Rain 或 Maintenance，我们如何计算约会的概率分布？在这里，我们将使用边缘化。$P(Appointment,light,no)$的值等于$α[P(Appointment,light,no,delay)+P(Appointment,light,no,on\ time)]$。
|
||||
|
||||
### 枚举推理
|
||||
|
||||
枚举推理是在给定观测证据$e$和一些隐藏变量$Y$的情况下，找到变量$X$ 的概率分布的过程。
|
||||
|
||||
$P(X|e)=\alpha P(X,e)=\alpha \sum_yP(X,e,y)$
|
||||
|
||||
在这个方程中，$X$代表查询变量，$e$代表观察到的证据，$y$代表隐藏变量的所有值，$α$归一化结果，使我们最终得到的概率加起来为 1。用文字来解释这个方程，即给定$e$的$X$的概率分布等于$X$和$e$的归一化概率分布。为了得到这个分布，我们对$X、e$和$y$的归一化概率求和，其中$y$每次取隐藏变量$Y$ 的不同值。
|
||||
|
||||
Python 中存在多个库，以简化概率推理过程。我们将查看库 `pomegranate`，看看如何在代码中表示上述数据。
|
||||
|
||||
```python
|
||||
from pomegranate import *
|
||||
'''创建节点，并为每个节点提供概率分布'''
|
||||
# Rain 节点没有父节点
|
||||
rain = Node(DiscreteDistribution({
|
||||
"none": 0.7,
|
||||
"light": 0.2,
|
||||
"heavy": 0.1
|
||||
}), name="rain")
|
||||
# Track maintenance 节点以 rain 为条件
|
||||
maintenance = Node(ConditionalProbabilityTable([
|
||||
["none", "yes", 0.4],
|
||||
["none", "no", 0.6],
|
||||
["light", "yes", 0.2],
|
||||
["light", "no", 0.8],
|
||||
["heavy", "yes", 0.1],
|
||||
["heavy", "no", 0.9]
|
||||
], [rain.distribution]), name="maintenance")
|
||||
# Train node 节点以 rain 和 maintenance 为条件
|
||||
train = Node(ConditionalProbabilityTable([
|
||||
["none", "yes", "on time", 0.8],
|
||||
["none", "yes", "delayed", 0.2],
|
||||
["none", "no", "on time", 0.9],
|
||||
["none", "no", "delayed", 0.1],
|
||||
["light", "yes", "on time", 0.6],
|
||||
["light", "yes", "delayed", 0.4],
|
||||
["light", "no", "on time", 0.7],
|
||||
["light", "no", "delayed", 0.3],
|
||||
["heavy", "yes", "on time", 0.4],
|
||||
["heavy", "yes", "delayed", 0.6],
|
||||
["heavy", "no", "on time", 0.5],
|
||||
["heavy", "no", "delayed", 0.5],
|
||||
], [rain.distribution, maintenance.distribution]), name="train")
|
||||
# Appointment 节点以列车为条件
|
||||
appointment = Node(ConditionalProbabilityTable([
|
||||
["on time", "attend", 0.9],
|
||||
["on time", "miss", 0.1],
|
||||
["delayed", "attend", 0.6],
|
||||
["delayed", "miss", 0.4]
|
||||
], [train.distribution]), name="appointment")
|
||||
'''我们通过添加所有节点来创建模型，然后通过在节点之间添加边来描述哪个节点是另一个节点的父节点（回想一下，贝叶斯网络是一个有向图，节点之间由箭头组成）。'''
|
||||
# 创建贝叶斯网络并添加状态
|
||||
model = BayesianNetwork()
|
||||
model.add_states(rain, maintenance, train, appointment)
|
||||
# 添加连接节点的边
|
||||
model.add_edge(rain, maintenance)
|
||||
model.add_edge(rain, train)
|
||||
model.add_edge(maintenance, train)
|
||||
model.add_edge(train, appointment)
|
||||
# 最终确定模型
|
||||
model.bake()
|
||||
'''模型可以计算特定条件下的概率'''
|
||||
# 计算给定观测的概率
|
||||
probability = model.probability([["none", "no", "on time", "attend"]])
|
||||
print(probability)
|
||||
'''我们可以使用该模型为所有变量提供概率分布，给出一些观测到的证据。在以下情况下，我们知道火车晚点了。给定这些信息，我们计算并打印变量 Rain、Maintenance 和 Appointment 的概率分布。'''
|
||||
# 根据火车晚点的证据计算预测
|
||||
predictions = model.predict_proba({
|
||||
"train": "delayed"
|
||||
})
|
||||
# 打印每个节点的预测
|
||||
for node, prediction in zip(model.states, predictions):
|
||||
# 预测已确定时返回字符串
|
||||
if isinstance(prediction, str):
|
||||
print(f"{node.name}: {prediction}")
|
||||
else:
|
||||
# 预测不确定时返回概率分布
|
||||
print(f"{node.name}")
|
||||
for value, probability in prediction.parameters[0].items():
|
||||
print(f" {value}: {probability:.4f}")
|
||||
```
|
||||
|
||||
上面的代码使用了枚举推理。然而，这种计算概率的方法效率很低，尤其是当模型中有很多变量时。另一种方法是放弃精确推理，转而采用近似推理。这样做，我们在生成的概率中会失去一些精度，但这种不精确性通常可以忽略不计。相反，我们获得了一种可扩展的概率计算方法。
|
||||
|
||||
### 采样 (Sampling)
|
||||
|
||||
采样是一种近似推理技术。在采样中，根据每个变量的概率分布对其值进行采样。
|
||||
|
||||
> 要使用骰子采样生成分布，我们可以多次掷骰子，并记录每次获得的值。假设我们把骰子掷了 600 次。我们计算得到 1 的次数，应该大约是 100，然后对其余的值 2-6 重复采样。然后，我们将每个计数除以投掷的总数。这将生成掷骰子的值的近似分布：一方面，我们不太可能得到每个值发生概率为 1/6 的结果（这是确切的概率），但我们会得到一个接近它的值。
|
||||
|
||||
如果我们从对 Rain 变量进行采样开始，则生成的值 none 的概率为 0.7，生成的值 light 的概率为 0.2，而生成的值 heavy 的概率则为 0.1。假设我们的采样值为 none。当我们得到 Maintenance 变量时，我们也会对其进行采样，但只能从 Rain 等于 none 的概率分布中进行采样，因为这是一个已经采样的结果。我们将通过所有节点继续这样做。现在我们有一个样本，多次重复这个过程会生成一个分布。现在，如果我们想回答一个问题，比如什么是$P(Train=on\ time)$，我们可以计算变量 Train 具有准时值的样本数量，并将结果除以样本总数。通过这种方式，我们刚刚生成了$P(Train=on\ {time})$的近似概率。
|
||||
|
||||
<table>
|
||||
<tr>
|
||||
<td><img src=https://cdn.xyxsw.site/CreObGAg4oXB0oxe2hMcQbYZnAc.png width=520></td>
|
||||
<td><img src=https://cdn.xyxsw.site/Vr96bdSafoV4kBxJ3x2cAU0TnOg.png width=520></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
我们也可以回答涉及条件概率的问题，例如$P(rain=light|train=on\ {time})$。在这种情况下，我们忽略 Train 值为 delay 的所有样本，然后照常进行。我们计算在$Train=\text{on time}$的样本中有多少样本具有变量$Rain=light$，然后除以$Train=\text{on time}$的样本总数。
|
||||
|
||||
<table>
|
||||
<tr>
|
||||
<td><img src=https://cdn.xyxsw.site/KsELbuMTCoKZkGxU9U5czQpanKg.png width=520></td>
|
||||
<td><img src=https://cdn.xyxsw.site/MrP0b2FbXofDsOxgnmncufUynAB.png width=520></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
| 去除$T= on time$的样本 | 选择$R=light$的样本 |
|
||||
| --------------------- | ------------------ |
|
||||
|  |  |
|
||||
|
||||
在代码中，采样函数可以是 `generate_sample`：
|
||||
|
||||
```python
|
||||
'''如果你对 pomegrante 库不熟悉，没有关系，考虑 generate_sample 为一个黑盒，或者你可以在 python 解释器中查看 model.states, state.distribution 的值以了解 model 在该库中的实现方式'''
|
||||
import pomegranate
|
||||
from collections import Counter
|
||||
def generate_sample():
|
||||
# 随机变量与生成的样本之间的映射
|
||||
sample = {}
|
||||
# 概率分布与样本的映射
|
||||
parents = {}
|
||||
# 为所有状态节点采样
|
||||
for state in model.states:
|
||||
# 如果我们有一个非根节点，则以父节点为条件进行采样
|
||||
if isinstance(state.distribution, pomegranate.ConditionalProbabilityTable):
|
||||
sample[state.name] = state.distribution.sample(parent_values=parents)
|
||||
# 否则，只根据节点的概率分布单独取样
|
||||
else:
|
||||
sample[state.name] = state.distribution.sample()
|
||||
# 追踪映射中的采样值
|
||||
parents[state.distribution] = sample[state.name]
|
||||
# 返回生成的样本
|
||||
return sample
|
||||
# 采样
|
||||
# 观测到 train=delay，计算 appointment 分布
|
||||
N = 10000
|
||||
data = []
|
||||
# 重复采样 10000 次
|
||||
for i in range(N):
|
||||
# 根据我们之前定义的函数生成一个样本
|
||||
sample = generate_sample()
|
||||
# 如果在该样本中，Train 的变量的值为 delay，则保存样本。由于我们对给定 train=delay 的 appointment 概率分布感兴趣，我们丢弃了 train=on time 的采样样本。
|
||||
if sample["train"] == "delayed":
|
||||
data.append(sample["appointment"])
|
||||
# 计算变量的每个值出现的次数。我们可以稍后通过将结果除以保存的样本总数来进行归一化，以获得变量的近似概率，该概率加起来为 1。
|
||||
print(Counter(data))
|
||||
```
|
||||
|
||||
### 似然加权
|
||||
|
||||
在上面的采样示例中，我们丢弃了与我们所掌握的证据不匹配的样本。这是低效的。解决这一问题的一种方法是使用似然加权，使用以下步骤：
|
||||
|
||||
- 首先固定证据变量的值。
|
||||
- 使用贝叶斯网络中的条件概率对非证据变量进行采样。
|
||||
- 根据其可能性对每个样本进行加权：所有证据出现的概率。
|
||||
|
||||
例如，如果我们观察到$Train=\text{on time}$，我们将像之前一样开始采样。我们对给定概率分布的 Rain 值进行采样，然后对 Maintenance 进行采样，但当我们到达 Train 时，我们总是按照观测值取值。然后，我们继续进行，并在给定$Train=\text{on time}$的情况下，根据其概率分布对 Appointment 进行采样。既然这个样本存在，我们就根据观察到的变量在给定其采样父变量的情况下的条件概率对其进行加权。也就是说，如果我们采样了 Rain 并得到了 light，然后我们采样了 Maintenance 并得到了 yes，那么我们将用$P(Train=\text{on time}|light,yes)$来加权这个样本。
|
||||
|
||||
## 马尔科夫模型 (Markov Models)
|
||||
|
||||
到目前为止，我们已经研究了概率问题，给出了我们观察到的一些信息。在这种范式中，时间的维度没有以任何方式表示。然而，许多任务确实依赖于时间维度，例如预测。为了表示时间变量，我们将创建一个新的变量$X$，并根据感兴趣的事件对其进行更改，使$X_t$ 是当前事件，$X_{t+1}$ 是下一个事件，依此类推。为了能够预测未来的事件，我们将使用马尔可夫模型。
|
||||
|
||||
### 马尔科夫假设 (**The Markov Assumption**)
|
||||
|
||||
马尔科夫假设是一个假设，即当前状态只取决于有限的固定数量的先前状态。想想预测天气的任务。在理论上，我们可以使用过去一年的所有数据来预测明天的天气。然而，这是不可行的，一方面是因为这需要计算能力，另一方面是因为可能没有关于基于 365 天前天气的明天天气的条件概率的信息。使用马尔科夫假设，我们限制了我们以前的状态（例如，在预测明天的天气时，我们要考虑多少个以前的日子），从而使这个任务变得可控。这意味着我们可能会得到感兴趣的概率的一个更粗略的近似值，但这往往足以满足我们的需要。此外，我们可以根据最后一个事件的信息来使用马尔可夫模型（例如，根据今天的天气来预测明天的天气）。
|
||||
|
||||
### 马尔科夫链 (**Markov Chain**)
|
||||
|
||||
马尔科夫链是一个随机变量的序列，每个变量的分布都遵循马尔科夫假设。也就是说，链中的每个事件的发生都是基于之前事件的概率。
|
||||
|
||||
为了构建马尔可夫链，我们需要一个过渡模型，该模型将根据当前事件的可能值来指定下一个事件的概率分布。
|
||||
|
||||
|
||||
|
||||
在这个例子中，基于今天是晴天，明天是晴天的概率是 0.8。这是合理的，因为晴天之后更可能是晴天。然而，如果今天是雨天，明天下雨的概率是 0.7，因为雨天更有可能相继出现。使用这个过渡模型，可以对马尔可夫链进行采样。从一天是雨天或晴天开始，然后根据今天的天气，对第二天的晴天或雨天的概率进行采样。然后，根据明天的情况对后天的概率进行采样，以此类推，形成马尔科夫链：
|
||||
|
||||
|
||||
|
||||
给定这个马尔可夫链，我们现在可以回答诸如“连续四个雨天的概率是多少？”这样的问题。下面是一个如何在代码中实现马尔可夫链的例子：
|
||||
|
||||
```python
|
||||
from pomegranate import *
|
||||
# 定义起始概率
|
||||
start = DiscreteDistribution({
|
||||
"sun": 0.5,
|
||||
"rain": 0.5
|
||||
})
|
||||
# 定义过渡模型
|
||||
transitions = ConditionalProbabilityTable([
|
||||
["sun", "sun", 0.8],
|
||||
["sun", "rain", 0.2],
|
||||
["rain", "sun", 0.3],
|
||||
["rain", "rain", 0.7]
|
||||
], [start])
|
||||
# 创造马尔科夫链
|
||||
model = MarkovChain([start, transitions])
|
||||
# 采样 50 次
|
||||
print(model.sample(50))
|
||||
```
|
||||
|
||||
## 隐马尔科夫模型 (Hidden Markov Models)
|
||||
|
||||
隐马尔科夫模型是一种具有隐藏状态的系统的马尔科夫模型，它产生了一些观察到的事件。这意味着，有时候，人工智能对世界有一些测量，但无法获得世界的精确状态。在这些情况下，世界的状态被称为隐藏状态，而人工智能能够获得的任何数据都是观察结果。下面是一些这方面的例子：
|
||||
|
||||
- 对于一个探索未知领域的机器人来说，隐藏状态是它的位置，而观察是机器人的传感器所记录的数据。
|
||||
- 在语音识别中，隐藏状态是所讲的话语，而观察是音频波形。
|
||||
- 在衡量网站的用户参与度时，隐藏的状态是用户的参与程度，而观察是网站或应用程序的分析。
|
||||
|
||||
举个例子。我们的人工智能想要推断天气 (隐藏状态)，但它只能接触到一个室内摄像头，记录有多少人带了雨伞。这里是我们的传感器模型 (sensor model)，表示了这些概率：
|
||||
|
||||
|
||||
|
||||
在这个模型中，如果是晴天，人们很可能不会带伞到大楼。如果是雨天，那么人们就很有可能带伞到大楼来。通过对人们是否带伞的观察，我们可以合理地预测外面的天气情况。
|
||||
|
||||
### 传感器马尔科夫假设
|
||||
|
||||
假设证据变量只取决于相应的状态。例如，对于我们的模型，我们假设人们是否带雨伞去办公室只取决于天气。这不一定反映了完整的事实，因为，比如说，比较自觉的、不喜欢下雨的人可能即使在阳光明媚的时候也会到处带伞，如果我们知道每个人的个性，会给模型增加更多的数据。然而，传感器马尔科夫假设忽略了这些数据，假设只有隐藏状态会影响观察。
|
||||
|
||||
隐马尔科夫模型可以用一个有两层的马尔科夫链来表示。上层，变量$X$，代表隐藏状态。底层，变量$E$，代表证据，即我们所拥有的观察。
|
||||
|
||||
|
||||
|
||||
基于隐马尔科夫模型，可以实现多种任务：
|
||||
|
||||
- 筛选 Filtering: 给定从开始到现在的观察结果，计算出<strong>当前</strong>状态的概率分布。例如，给从从特定时间开始到今天人们带伞的信息，我们产生一个今天是否下雨的概率分布。
|
||||
- 预测 Prediction: 给定从开始到现在的观察，计算<strong>未来</strong>状态的概率分布。
|
||||
- 平滑化 Smoothing: 给定从开始到现在的观察，计算<strong>过去</strong>状态的概率分布。例如，鉴于今天人们带了雨伞，计算昨天下雨的概率。
|
||||
- 最可能的解释 Most likely explanation: 鉴于从开始到现在的观察，计算最可能的事件顺序。
|
||||
|
||||
最可能的解释任务可用于语音识别等过程，根据多个波形，人工智能推断出给这些波形带来的最有可能的单词或音节的序列。
|
||||
|
||||
接下来是一个隐马尔科夫模型的 Python 实现，我们将用于最可能的解释任务：
|
||||
|
||||
```python
|
||||
from pomegranate import *
|
||||
# 每个状态的观测模型
|
||||
sun = DiscreteDistribution({
|
||||
"umbrella": 0.2,
|
||||
"no umbrella": 0.8
|
||||
})
|
||||
rain = DiscreteDistribution({
|
||||
"umbrella": 0.9,
|
||||
"no umbrella": 0.1
|
||||
})
|
||||
states = [sun, rain]
|
||||
# 过渡模型
|
||||
transitions = numpy.array(
|
||||
[[0.8, 0.2], # Tomorrow's predictions if today = sun
|
||||
[0.3, 0.7]] # Tomorrow's predictions if today = rain
|
||||
)
|
||||
# 起始概率
|
||||
starts = numpy.array([0.5, 0.5])
|
||||
# 建立模型
|
||||
model = HiddenMarkovModel.from_matrix(
|
||||
transitions, states, starts,
|
||||
state_names=["sun", "rain"]
|
||||
)
|
||||
model.bake()
|
||||
```
|
||||
|
||||
请注意，我们的模型同时具有传感器模型和过渡模型。对于隐马尔可夫模型，我们需要这两个模型。在下面的代码片段中，我们看到了人们是否带伞到大楼的观察序列，根据这个序列，我们将运行模型，它将生成并打印出最可能的解释 (即最可能带来这种观察模式的天气序列):
|
||||
|
||||
```python
|
||||
from model import model
|
||||
# 观测到的数据
|
||||
observations = [
|
||||
"umbrella",
|
||||
"umbrella",
|
||||
"no umbrella",
|
||||
"umbrella",
|
||||
"umbrella",
|
||||
"umbrella",
|
||||
"umbrella",
|
||||
"no umbrella",
|
||||
"no umbrella"
|
||||
]
|
||||
# 预测隐藏状态
|
||||
predictions = model.predict(observations)
|
||||
for prediction in predictions:
|
||||
print(model.states[prediction].name)
|
||||
```
|
||||
|
||||
在这种情况下，程序的输出将是 rain,rain,sun,rain,rain,rain,rain,sun,sun。根据我们对人们带伞或不带伞到大楼的观察，这一输出代表了最有可能的天气模式。
|
||||
341
2023旧版内容/4.人工智能/4.3.4.1程序示例.md
Normal file
341
2023旧版内容/4.人工智能/4.3.4.1程序示例.md
Normal file
@@ -0,0 +1,341 @@
|
||||
# 程序示例
|
||||
|
||||
::: tip
|
||||
阅读程序并运行
|
||||
|
||||
完成习题
|
||||
:::
|
||||
|
||||
::: tip 📥
|
||||
本节附件下载 <Download url="https://cdn.xyxsw.site/code/4-Lecture.zip"/>
|
||||
:::
|
||||
|
||||
## Hospital(局部搜索)
|
||||
|
||||
```python
|
||||
import random
|
||||
|
||||
class Space():
|
||||
def __init__(self, height, width, num_hospitals):
|
||||
"""创建一个具有给定维度的新状态空间"""
|
||||
self.height = height # 高度
|
||||
self.width = width # 宽度
|
||||
self.num_hospitals = num_hospitals # 医院数量
|
||||
self.houses = set() # 住房位置集合
|
||||
self.hospitals = set() # 医院位置集合
|
||||
|
||||
def add_house(self, row, col):
|
||||
"""在状态空间中的特定位置添加住房"""
|
||||
self.houses.add((row, col))
|
||||
|
||||
def available_spaces(self):
|
||||
"""返回住房或医院当前未使用的所有单元格"""
|
||||
# 考虑所有可能的单元格
|
||||
candidates = set(
|
||||
(row, col)
|
||||
for row in range(self.height)
|
||||
for col in range(self.width)
|
||||
)
|
||||
# 排除所有住房和医院
|
||||
for house in self.houses:
|
||||
candidates.remove(house)
|
||||
for hospital in self.hospitals:
|
||||
candidates.remove(hospital)
|
||||
return candidates
|
||||
|
||||
def hill_climb(self, maximum=None, image_prefix=None, log=False):
|
||||
"""执行爬山算法找到解决方案"""
|
||||
count = 0
|
||||
# 从随机初始化的医院位置开始
|
||||
self.hospitals = set()
|
||||
for i in range(self.num_hospitals):
|
||||
self.hospitals.add(random.choice(list(self.available_spaces())))
|
||||
...
|
||||
# 执行算法，直到达到最大迭代次数
|
||||
while maximum is None or count < maximum:
|
||||
count += 1
|
||||
best_neighbors = []
|
||||
best_neighbor_cost = None
|
||||
# 考虑所有医院移动
|
||||
for hospital in self.hospitals:
|
||||
# 考虑一下那家医院的所有邻居
|
||||
for replacement in self.get_neighbors(*hospital):
|
||||
# 生成一组相邻的医院
|
||||
neighbor = self.hospitals.copy()
|
||||
neighbor.remove(hospital)
|
||||
neighbor.add(replacement)
|
||||
# 检查邻居是否是迄今为止最好的
|
||||
cost = self.get_cost(neighbor)
|
||||
if best_neighbor_cost is None or cost < best_neighbor_cost:
|
||||
best_neighbor_cost = cost
|
||||
best_neighbors = [neighbor]
|
||||
elif best_neighbor_cost == cost:
|
||||
best_neighbors.append(neighbor)
|
||||
# 没有一个邻居比目前的状态更好
|
||||
if best_neighbor_cost >= self.get_cost(self.hospitals):
|
||||
return self.hospitals
|
||||
# 移动到价值最高的邻居
|
||||
else:
|
||||
...
|
||||
self.hospitals = random.choice(best_neighbors)
|
||||
...
|
||||
|
||||
def random_restart(self, maximum, image_prefix=None, log=False):
|
||||
"""多次重复爬山算法"""
|
||||
best_hospitals = None
|
||||
best_cost = None
|
||||
# 重复爬山算法的固定次数
|
||||
for i in range(maximum):
|
||||
hospitals = self.hill_climb()
|
||||
cost = self.get_cost(hospitals)
|
||||
if best_cost is None or cost < best_cost:
|
||||
best_cost = cost
|
||||
best_hospitals = hospitals
|
||||
...
|
||||
else:
|
||||
...
|
||||
...
|
||||
return best_hospitals
|
||||
|
||||
def get_cost(self, hospitals):
|
||||
"""计算从住房到最近医院的距离总和"""
|
||||
cost = 0
|
||||
for house in self.houses:
|
||||
cost += min(
|
||||
abs(house[0] - hospital[0]) + abs(house[1] - hospital[1])
|
||||
for hospital in hospitals
|
||||
)
|
||||
return cost
|
||||
|
||||
def get_neighbors(self, row, col):
|
||||
"""返回尚未包含住房或医院的邻居"""
|
||||
candidates = [
|
||||
(row - 1, col),
|
||||
(row + 1, col),
|
||||
(row, col - 1),
|
||||
(row, col + 1)
|
||||
]
|
||||
neighbors = []
|
||||
for r, c in candidates:
|
||||
if (r, c) in self.houses or (r, c) in self.hospitals:
|
||||
continue
|
||||
if 0 <= r < self.height and 0 <= c < self.width:
|
||||
neighbors.append((r, c))
|
||||
return neighbors
|
||||
|
||||
def output_image(self, filename):
|
||||
"""生成所有房屋和医院的图像（不作要求）"""
|
||||
from PIL import Image, ImageDraw, ImageFont
|
||||
cell_size = 100
|
||||
cell_border = 2
|
||||
cost_size = 40
|
||||
padding = 10
|
||||
|
||||
# Create a blank canvas
|
||||
img = Image.new(
|
||||
"RGBA",
|
||||
(self.width * cell_size,
|
||||
self.height * cell_size + cost_size + padding * 2),
|
||||
"white"
|
||||
)
|
||||
house = Image.open("assets/images/House.png").resize(
|
||||
(cell_size, cell_size)
|
||||
)
|
||||
hospital = Image.open("assets/images/Hospital.png").resize(
|
||||
(cell_size, cell_size)
|
||||
)
|
||||
font = ImageFont.truetype("assets/fonts/OpenSans-Regular.ttf", 30)
|
||||
draw = ImageDraw.Draw(img)
|
||||
|
||||
for i in range(self.height):
|
||||
for j in range(self.width):
|
||||
|
||||
# Draw cell
|
||||
rect = [
|
||||
(j * cell_size + cell_border,
|
||||
i * cell_size + cell_border),
|
||||
((j + 1) * cell_size - cell_border,
|
||||
(i + 1) * cell_size - cell_border)
|
||||
]
|
||||
draw.rectangle(rect, fill="black")
|
||||
|
||||
if (i, j) in self.houses:
|
||||
img.paste(house, rect[0], house)
|
||||
if (i, j) in self.hospitals:
|
||||
img.paste(hospital, rect[0], hospital)
|
||||
|
||||
# Add cost
|
||||
draw.rectangle(
|
||||
(0, self.height * cell_size, self.width * cell_size,
|
||||
self.height * cell_size + cost_size + padding * 2),
|
||||
"black"
|
||||
)
|
||||
draw.text(
|
||||
(padding, self.height * cell_size + padding),
|
||||
f"Cost: {self.get_cost(self.hospitals)}",
|
||||
fill="white",
|
||||
font=font
|
||||
)
|
||||
|
||||
img.save(filename)
|
||||
|
||||
# 创建一个状态空间并随机添加住房
|
||||
s = Space(height=10, width=20, num_hospitals=3)
|
||||
for i in range(15):
|
||||
s.add_house(random.randrange(s.height), random.randrange(s.width))
|
||||
# 使用局部搜索来确定医院位置
|
||||
hospitals = s.random_restart(maximum=100, image_prefix="hospitals", log=True)
|
||||
```
|
||||
|
||||
## Production(线性规划)
|
||||
|
||||
```python
|
||||
import scipy.optimize
|
||||
# Objective Function: 50x_1 + 80x_2
|
||||
# Constraint 1: 5x_1 + 2x_2 <= 20
|
||||
# Constraint 2: -10x_1 + -12x_2 <= -90
|
||||
result = scipy.optimize.linprog(
|
||||
[50, 80], # Cost function: 50x_1 + 80x_2
|
||||
A_ub=[[5, 2], [-10, -12]], # Coefficients for inequalities
|
||||
b_ub=[20, -90], # Constraints for inequalities: 20 and -90
|
||||
)
|
||||
if result.success:
|
||||
print(f"X1: {round(result.x[0], 2)} hours")
|
||||
print(f"X2: {round(result.x[1], 2)} hours")
|
||||
else:
|
||||
print("No solution")
|
||||
```
|
||||
|
||||
## Schedule(约束满足)
|
||||
|
||||
```python
|
||||
"""没有任何启发式或推理的自然回溯搜索"""
|
||||
VARIABLES = ["A", "B", "C", "D", "E", "F", "G"]
|
||||
CONSTRAINTS = [
|
||||
("A", "B"),
|
||||
("A", "C"),
|
||||
("B", "C"),
|
||||
("B", "D"),
|
||||
("B", "E"),
|
||||
("C", "E"),
|
||||
("C", "F"),
|
||||
("D", "E"),
|
||||
("E", "F"),
|
||||
("E", "G"),
|
||||
("F", "G")
|
||||
]
|
||||
|
||||
def backtrack(assignment):
|
||||
"""运行回溯搜索以查找赋值"""
|
||||
# 检查赋值是否完成
|
||||
if len(assignment) == len(VARIABLES):
|
||||
return assignment
|
||||
# 尝试一个新变量
|
||||
var = select_unassigned_variable(assignment)
|
||||
for value in ["Monday", "Tuesday", "Wednesday"]:
|
||||
new_assignment = assignment.copy()
|
||||
new_assignment[var] = value
|
||||
if consistent(new_assignment):
|
||||
result = backtrack(new_assignment)
|
||||
if result is not None:
|
||||
return result
|
||||
return None
|
||||
|
||||
def select_unassigned_variable(assignment):
|
||||
"""按顺序选择尚未赋值的变量"""
|
||||
for variable in VARIABLES:
|
||||
if variable not in assignment:
|
||||
return variable
|
||||
return None
|
||||
|
||||
|
||||
def consistent(assignment):
|
||||
"""检查分配是否一致"""
|
||||
for (x, y) in CONSTRAINTS:
|
||||
# 仅考虑变量赋值都已指定的弧
|
||||
if x not in assignment or y not in assignment:
|
||||
continue
|
||||
# 如果两者的值相同，则不一致
|
||||
if assignment[x] == assignment[y]:
|
||||
return False
|
||||
# 如果没有不一致的地方，那么赋值是一致的
|
||||
return True
|
||||
|
||||
solution = backtrack(dict())
|
||||
print(solution)
|
||||
```
|
||||
|
||||
使用命令`pip install python-constraint`安装 constraint 库
|
||||
|
||||
```python
|
||||
from constraint import *
|
||||
|
||||
problem = Problem()
|
||||
|
||||
# 添加变量
|
||||
problem.addVariables(
|
||||
["A", "B", "C", "D", "E", "F", "G"],
|
||||
["Monday", "Tuesday", "Wednesday"]
|
||||
)
|
||||
|
||||
# 添加约束
|
||||
CONSTRAINTS = [
|
||||
("A", "B"),
|
||||
("A", "C"),
|
||||
("B", "C"),
|
||||
("B", "D"),
|
||||
("B", "E"),
|
||||
("C", "E"),
|
||||
("C", "F"),
|
||||
("D", "E"),
|
||||
("E", "F"),
|
||||
("E", "G"),
|
||||
("F", "G")
|
||||
]
|
||||
for x, y in CONSTRAINTS:
|
||||
problem.addConstraint(lambda x, y: x != y, (x, y))
|
||||
|
||||
# Solve problem
|
||||
for solution in problem.getSolutions():
|
||||
print(solution)
|
||||
```
|
||||
|
||||
## Quiz
|
||||
|
||||
1. 对于以下哪一项，即使多次重新运行算法，也会始终找到相同的解决方案？
|
||||
假设一个问题的目标是最小化成本函数，并且状态空间中的每个状态都有不同的成本。
|
||||
1. Steepest-ascent hill-climbing，每次从不同的初始状态开始
|
||||
2. Steepest-ascent hill-climbing，每次都从相同的初始状态开始
|
||||
3. Stochastic hill-climbing，每次从不同的初始状态开始
|
||||
4. Stochastic hill-climbing，每次都从相同的初始状态开始
|
||||
5. 无论是 steepest-ascent 还是 stochastic hill climbing，只要你总是从同一个初始状态开始
|
||||
6. 无论是 steepest-ascent 还是 stochastic hill climbing，只要每次都从不同的初始状态开始
|
||||
7. 没有任何版本的爬山算法能保证每次都能得到相同的解决方案
|
||||
|
||||
2. 下面两个问题都会问你关于下面描述的优化问题。
|
||||
一位农民正在尝试种植两种作物，`作物 1` 和`作物 2`，并希望实现利润最大化。农民将从种植的每英亩`作物 1` 中获得 500 美元的利润，从种植的每英亩`作物 2` 中获得 400 美元的利润。然而，农民今天需要在早上 7 点到晚上 7 点之间的 12 个小时内完成所有的种植。种植一英亩的`作物 1` 需要 3 个小时，种植一英亩`作物 2` 需要 2 个小时。农民在供应方面也很有限：他有足够的供应种植 10 英亩的`作物 1`，有足够的资源种植 4 英亩的`作物 2`。假设变量 C1 表示要种植的`作物 1` 的英亩数，变量 C2 表示要种植`作物 2` 的英亩数。
|
||||
|
||||
对于这个问题，什么是有效的目标函数？
|
||||
|
||||
1. 10 \* C1 + 4 \* C2
|
||||
2. -3 \* C1 - 2 \* C2
|
||||
3. 500 \* 10 \* C1 + 400 \* 4 \* C2
|
||||
4. 500 \* C1 + 400 \* C2
|
||||
5. C1 + C2
|
||||
|
||||
3. 这个问题的制约因素是什么？
|
||||
1. 3 \* C1 + 2 \* C2 <= 12, C1 <= 10, C2 <= 4
|
||||
2. 3 \* C1 + 2 \* C2 <= 12, C1 + C2 <= 14
|
||||
3. 3 \* C1 <= 10, 2 \* C2 <= 4
|
||||
4. C1 + C2 <= 12, C1 + C2 <= 14
|
||||
|
||||
4. 下面的问题将问你以下考试安排约束满足图，其中每个节点代表一个课程。每门课程都与可能的考试日的初始域相关联（大多数课程可能在周一、周二或周三；少数课程已经被限制在一天内）。两个节点之间的边意味着这两个课程必须在不同的日子进行考试。
|
||||
|
||||
在对整个问题满足弧一致性之后，变量 C、D 和 E 的结果域是什么？
|
||||
|
||||
1. C 的域是\{Mon，Tue\}，D 的域是\{Wed\}，E 的域是\{Mon\}
|
||||
2. C 的域是\{Mon\}，D 的域是\{Wed\}，E 的域为\{Tue\}
|
||||
3. C 的域是\{Mon\}，D 的域是\{Tue\}，E 的域为\{Wed\}
|
||||
4. C 的域是\{Mon\}，D 的域是\{Mon，Wed\}，E 的域是\{Tue，Wed\}
|
||||
5. C 的域是\{Mon，Tue，Wed\}，D 的域是\{Mon，Wed\}，E 的域是\{Mon，Tue，Wed\}
|
||||
6. C 的域是\{Mon\}，D 的域是\{Mon，Wed\}，E 的域是\{Mon，Tue，Wed\}
|
||||
138
2023旧版内容/4.人工智能/4.3.4.2项目：填词游戏.md
Normal file
138
2023旧版内容/4.人工智能/4.3.4.2项目：填词游戏.md
Normal file
@@ -0,0 +1,138 @@
|
||||
# 项目——填词游戏
|
||||
|
||||
::: tip
|
||||
我们为你提供了一个简单有趣的项目，帮助你进行知识巩固，请认真阅读文档内容。
|
||||
|
||||
如果你卡住了，请记得回来阅读文档，或请求身边人的帮助。
|
||||
:::
|
||||
|
||||
::: tip 📥
|
||||
本节附件下载 <Download url="https://cdn.xyxsw.site/code/4-Projects.zip"/>
|
||||
:::
|
||||
|
||||
编写一个人工智能来完成填词游戏。
|
||||
|
||||
能够实现将文字转换为图片。
|
||||
|
||||
```shell
|
||||
$ python generate.py data/structure1.txt data/words1.txt output.png
|
||||
|█|█|█|█|█|█|█|█|█|█|█|█|█|█|
|
||||
|█|█|█|█|█|█|█|M|█|█|█|█|R|█|
|
||||
|█|I|N|T|E|L|L|I|G|E|N|C|E|█|
|
||||
|█|N|█|█|█|█|█|N|█|█|█|█|S|█|
|
||||
|█|F|█|█|L|O|G|I|C|█|█|█|O|█|
|
||||
|█|E|█|█|█|█|█|M|█|█|█|█|L|█|
|
||||
|█|R|█|█|█|S|E|A|R|C|H|█|V|█|
|
||||
|█|█|█|█|█|█|█|X|█|█|█|█|E|█|
|
||||
|█|█|█|█|█|█|█|█|█|█|█|█|█|█|
|
||||
```
|
||||
|
||||
|
||||
|
||||
## 背景
|
||||
|
||||
你如何生成一个填字游戏？考虑到填字游戏的结构 (即网格中哪些方格需要填入字母)，以及要使用的单词列表，问题就变成了选择哪些单词应该填入每个垂直或水平的方格序列。我们可以将这种问题建模为一个约束满足问题。每一个方格序列都是一个变量，我们需要决定它的值 (在可能的单词域中哪个单词将被填入该序列)。考虑一下下面的字谜结构。
|
||||
|
||||
|
||||
|
||||
在这个结构中，我们有四个变量，代表了我们需要填入这个字谜的四个单词 (在上图中每个单词都用数字表示)。每个变量由四个值定义：它开始的行 (`i`值)，它开始的列 (`j`值)，单词的方向 (纵向或横向 down or across)，以及单词的长度。例如，`变量1`将是一个由第 1 行 (假设从顶部计数的 0 索引)、第 1 列 (假设从左边计数的 0 索引)、方向为`across`和`4`的长度表示的变量。
|
||||
|
||||
与许多约束满足问题一样，这些变量有一元和二元约束。变量的一元约束是由其长度决定的。例如，对于`变量1`来说，数值`BYTE`可以满足一元约束，但是数值`BIT`则不能 (它有错误的字母数量)。因此，任何不满足变量的一元约束的值都可以立即从变量的域中删除。
|
||||
|
||||
变量的二元约束是由其与相邻变量的重合度给出的。`变量1`有一个邻居：`变量2`。`变量2`有两个邻居：`变量1`和`变量3`。对于每一对相邻的变量，这些变量都有一个重叠部分：一个它们共同的单方块。我们可以将这种重叠表示为每个变量有用相同字符位置的索引对。例如，`变量1`和`变量2`之间的重叠可以表示为一对`(1, 0)`，这意味着`变量1`在索引 1 处的字符必然与`变量2`在索引 0 处的字符相同 (再次假设索引从 0 开始)。因此，`变量2`和`变量3`之间的重叠将被表示为一对`(3, 1)`，`变量2`的值的字符`3`必须与`变量3`的值的字符`1`相同。
|
||||
|
||||
对于这个问题，我们将增加一个额外的约束条件，即所有的单词必须是不同的：同一个单词不应该在谜题中重复出现多次。
|
||||
|
||||
那么，接下来的挑战是写一个程序来找到一个满意的赋值：为每个变量提供一个不同的词 (来自给定的词汇表)，从而满足所有的一元和二元约束。
|
||||
|
||||
## 理解
|
||||
|
||||
这个项目中有两个 Python 文件：`crossword.py`和`generate.py`。第一个文件已经完全为你写好了，第二个文件有一些函数留给你去实现。
|
||||
|
||||
首先，让我们看一下`crossword.py`。这个文件定义了两个类，`Variable`(代表填字游戏中的变量) 和`Crossword`(代表填字游戏本身)。
|
||||
|
||||
注意，要创建一个变量，我们必须指定四个值：它的第`i`行，第`j`列，它的方向 (常数`Variable.ACROSS`或常数`Variable.DOWN``)，以及它的长度(`length``)。
|
||||
|
||||
字谜类需要两个值来创建一个新的字谜：一个定义了字谜结构的`structure_file`(`_`用来代表空白单元格，任何其他字符都代表不会被填入的单元格) 和一个定义了字词列表 (每行一个) 的`word_file`，用来作为游戏的词汇表。这些文件的三个例子可以在项目的数据目录中找到，也欢迎你自己创建。
|
||||
|
||||
特别要注意的是，对于任何一个字谜对象的字谜，我们都会存储以下的数值：
|
||||
|
||||
- `crossword.height`是一个整数，代表填字游戏的高度。
|
||||
- `crossword.width`是一个整数，代表填字游戏的宽度。
|
||||
- `crossword.structure`是一个二维列表，代表字谜的结构。对于任何有效的第 i 行和第 j 列，如果该单元格是空白的，`crossword.structure[i][j]`将为真 (必须在该单元格中填入一个字符)，否则将为假 (该单元格中没有字符要填)。
|
||||
- `crossword.words`是一个包含所有单词的集合，在构建填字游戏的时候，可以从这些单词中提取。
|
||||
- `crossword.variables`是谜题中所有变量的集合 (每个变量都是一个 Variable 对象)。
|
||||
- `crossword.overlaps`是一个字典，它将一对变量映射到它们的重合处。对于任何两个不同的变量 v1 和 v2，如果这两个变量没有重叠，`crossword.overlaps[v1, v2]`将是`None`，如果这两个变量有重叠，则是一对整数`(i, j)`。这对`(i, j)`应被解释为：`v1`的第`i`个字符的值必须与`v2`的第`j`个字符的值相同。
|
||||
|
||||
`Crossword`对象还支持一个方法`neighbors`，它可以返回与给定变量重叠的所有变量。也就是说，`crossword.neighbors(v1)`将返回一个与变量`v1`相邻的所有变量的集合。
|
||||
|
||||
接下来，看一下`generate.py`。在这里，我们定义了一个`CrosswordCreator`类，我们将用它来解决填字游戏。当一个`CrosswordCreator`对象被创建时，它得到一个填字游戏的属性，它应该是一个`Crossword`对象 (因此具有上面描述的所有属性)。每个`CrosswordCreator`对象还得到一个域属性：一个字典，它将变量映射到该变量可能作为一个值的一组词。最初，这组词是我们词汇表中的所有词，但我们很快就会写函数来限制这些域。
|
||||
|
||||
我们还为你定义了一些函数，以帮助你测试你的代码：`print`将向终端打印你的填字游戏的一个给定的赋值 (每个赋值，在这个函数和其他地方，是一个字典，将变量映射到它们相应的词)。同时，`save`将生成一个与给定作业相对应的图像文件 (如果你无法使用这个函数，你需要`pip3 install Pillow`)。 `letter_grid`是一个被`print`和`save`使用的辅助函数，它为给定的赋值生成一个所有字符在其适当位置的 2D 列表：你可能不需要自己调用这个函数，但如果你想的话，欢迎你这样做。
|
||||
|
||||
最后，注意`solve`函数。这个函数做了三件事：首先，它调用`enforce_node_consistency`来强制执行填字游戏的节点一致性，确保变量域中的每个值都满足一元约束。接下来，该函数调用`ac3`来强制执行弧一致性，确保二元约束得到满足。最后，该函数在最初的空赋值 (空字典 dict()) 上调用`backtrack`，试图计算出问题的解决方案。
|
||||
|
||||
不过，`enforce_node_consistency`、`ac3`和`backtrack`等函数还没有实现 (以及其他函数)。这就是你的任务。
|
||||
|
||||
## 明确
|
||||
|
||||
完成`grece_node_consistency`, `revise`, `ac3`, `assignment_complete`, `consistent`, `order_domain_values`, `selected_unassigned_variable`和`backtrack`在`generate.py`中的实现，这样如果有有解的话你的人工智能就能生成完整的字谜。
|
||||
|
||||
- `enforce_node_consistency`函数应该更新`self.domains`，使每个变量都是节点一致的。
|
||||
- 回顾一下，当对每个变量来说，其域中的每个值都与该变量的一元约束一致时，就实现了节点一致性。在填字游戏的情况下，这意味着要确保变量域中的每个值的字母数与变量的长度相同。
|
||||
- 要从一个变量`v`的域中移除一个值`x`，因为`self.domains`是一个将变量映射到数值集的字典，你可以调用`self.domains[v].remove(x)`。
|
||||
- 这个函数不需要返回值。
|
||||
- `revise`函数应该使变量 x 与变量 y 保持弧一致性。
|
||||
- `x`和`y`都是`Variable`对象，代表谜题中的变量。
|
||||
- 回顾一下，当`x`的域中的每一个值在`y`的域中都有一个不引起冲突的可能值时，`x`就与`y`保持弧一致性。(在填字游戏的背景下，冲突是指一个方格，两个变量对它的字符值意见不一)。
|
||||
- 为了使`x`与`y`保持一致，你要从`x`的域中删除任何在`y`的域中没有相应可能值的值。
|
||||
- 回顾一下，你可以访问`self.crossword.overlaps`来获得两个变量之间的重叠，如果有的话。
|
||||
- `y`的域应该不被修改。
|
||||
- 如果对`x`的域进行了修改，该函数应返回`True`；如果没有修改，则应返回`False`。
|
||||
|
||||
- `ac3`函数应该使用`AC3`算法，对问题实施弧一致性。回顾一下，当每个变量域中的所有值都满足该变量的二进制约束时，就实现了弧一致性。
|
||||
- 回顾一下，`AC3`算法保持着一个要处理的弧的队列。这个函数需要一个叫做`arcs`的可选参数，代表要处理的弧的初始列表。如果`arcs`是`None`，你的函数应该从问题中的所有弧的初始队列开始。否则，你的算法应该从一个初始队列开始，该队列中只有在列表`arcs`中的弧 (其中每个弧是一个变量`x`和另一个变量`y`的元组`(x，y)`)。
|
||||
- 回顾一下，为了实现`AC3`，你要一次一次地修改队列中的每个弧。不过，任何时候你对一个域做了改变，你可能需要在队列中增加额外的弧，以确保其他弧保持一致。
|
||||
- 你可能会发现在`ac3`的实现中调用`revise`函数是很有帮助的。
|
||||
- 如果在执行弧一致性的过程中，你从一个域中删除了所有剩余的值，则返回`False`(这意味着问题无解，因为这个变量已经没有可能的值了)。否则，返回`True`。
|
||||
- 你不需要担心在这个函数中强制执行词的唯一性 (你将在`consistent`函数中实现这个检查。)
|
||||
|
||||
- `assignment_complete`函数应该 (如其名所示) 检查一个给定的赋值是否完成。
|
||||
- `assignment`是一个字典，其中键是`Variable`对象，值是代表这些变量将采取的单词的字符串。
|
||||
- 如果每个字谜变量都被分配到一个值 (不管这个值是什么)，那么这个赋值就是完整的。
|
||||
- 如果赋值完成，该函数应该返回`True`，否则返回`False`。
|
||||
|
||||
- `consistent`函数应该检查一个给定的`assignment`是否一致。
|
||||
- `assignment`是一个字典，其中的键是`Variable`对象，值是代表这些变量将采取的词语的字符串。请注意，赋值不一定是完整的：不是所有的变量都会出现在赋值中。
|
||||
- 如果一个赋值满足问题的所有约束条件，那么它就是一致的：也就是说，所有的值都是不同的，每个值的长度都是正确的，并且相邻的变量之间没有冲突。
|
||||
- 如果赋值是一致的，该函数应该返回`True`，否则返回`False`。
|
||||
|
||||
- `order_domain_values`函数应该返回一个`var`域中所有数值的列表，根据最小约束值启发式排序。
|
||||
- `var`将是一个变量对象，代表谜题中的一个变量。
|
||||
- 回顾一下，最小约束值启发式的计算方法是一个赋值导致约束邻近的未分配的变量的数量。也就是说，如果给`var`赋值的结果是排除了邻近变量的`n`个可能的选择，你应该按照`n`的升序排列你的结果。
|
||||
- 请注意，在`assignment`中出现的任何变量都已经有了一个值，因此在计算相邻未赋值变量被排除的值的数量时不应该被计算在内。
|
||||
- 对于排除相邻变量相同数量可能选择的域值，任何排序都是可以接受的。
|
||||
- 回顾一下，你可以访问`self.crossword.overlaps`来获得两个变量之间的重叠，如果有的话。
|
||||
- 首先通过返回一个任意顺序的数值列表来实现这个函数可能会有帮助 (这仍然会产生正确的填字游戏)。一旦你的算法开始工作，你就可以回去确保这些值是以正确的顺序返回的。
|
||||
- 你可能会发现根据一个特定的 key 来对一个[列表](https://docs.python.org/3/howto/sorting.html)进行排序是很有帮助的：Python 包含一些有用的函数来实现这一点。
|
||||
|
||||
- `select_unassigned_variable`函数应该根据最小剩余值启发式，然后是度启发式，返回字谜中尚未被赋值的单个变量。
|
||||
- `assignment`是一个字典，其中键是`Variable`对象，值是代表这些变量将承担的单词的字符串。你可以假设赋值不会是完整的：不是所有的变量都会出现在`assignment`中。
|
||||
- 你的函数应该返回一个`Variable`对象。你应该返回在其域中剩余数值最少的变量。如果变量之间存在平局，你应该在这些变量中选择度最大的变量 (拥有最多的邻居)。如果在这两种情况下都相同，你可以在相同的变量中任意选择。
|
||||
- 首先通过返回任意未分配的变量来实现这个函数可能是有帮助的 (这应该仍然会产生正确的填字游戏)。一旦你的算法开始工作，你就可以回去修改这个函数确保你是根据启发式方法返回一个变量。
|
||||
- 你可能会发现根据一个特定的 key 来对一个列表进行[排序](https://docs.python.org/3/howto/sorting.html)是很有帮助的：Python 包含一些有用的函数来实现这一点。
|
||||
|
||||
- `backtrack`函数应该接受一个部分赋值`assignment`作为输入，并且使用回溯搜索，如果有可能的话，返回一个完整的令人满意的变量赋值。
|
||||
- `assignment`是一个字典，其中键是`Variable`对象，值是代表这些变量将承担的单词的字符串。你可以假设赋值不会是完整的：不是所有的变量都会出现在`assignment`中。
|
||||
- 如果有可能生成一个令人满意的字谜，你的函数应该返回完整的赋值：一个字典，其中每个变量是一个键，值是该变量应该承担的单词。如果不可能产生令人满意的赋值，该函数应该返回`None`。
|
||||
- 如果你愿意，你可能会发现，如果你把搜索和推理交织在一起，你的算法会更有效率 (比如每次做新的赋值时都要保持弧一致性)。我们不要求你这样做，但允许你这样做，只要你的函数仍然产生正确的结果。(正是由于这个原因，`ac3`函数允许一个`arcs`的参数，以防你想从不同的弧队列开始)。
|
||||
|
||||
除了要求你实现的函数外，你不应该修改`generate.py`中的任何其他东西，尽管你可以编写额外的函数和/或导入其他 Python 标准库模块。如果你熟悉`numpy`或`pandas`，你也可以导入它们，但是你不应该使用任何其他的第三方 Python 模块。你不应该修改`crossword.py`中的任何东西。
|
||||
|
||||
## 提示
|
||||
|
||||
- 对于`order_domain_values`和`select_unassigned_variable`来说，不以启发式方法实现它们，然后再添加启发式方法可能会有帮助。你的算法仍然可以工作：只是在找到一个解决方案之前，它可能会探索更多的分配，而不是它需要的。
|
||||
|
||||
- 要运行你的程序，你可以运行类似`python generate.py data/structure1.txt data/words1.txt`的命令，指定一个结构文件和一个单词文件。如果可以进行赋值，你应该看到打印出来的赋值。你也可以为图像文件添加一个额外的命令行参数，如运行`python generate.py data/structure1.txt data/words1.txt output.png`，可以为生成的填字游戏生成一个图像表示。
|
||||
|
||||
- `Crossword`类有一个`neighbors`函数，可以用来访问某个特定变量的所有邻居 (即重叠的变量)。在你需要确定某个特定变量的邻居时，请随时使用这个函数。
|
||||
301
2023旧版内容/4.人工智能/4.3.4最优化.md
Normal file
301
2023旧版内容/4.人工智能/4.3.4最优化.md
Normal file
@@ -0,0 +1,301 @@
|
||||
# 最优化
|
||||
|
||||
最优化是指从一组可能的选项中选择最佳选项。我们已经遇到过试图找到最佳选项的问题，比如在极大极小算法中，今天我们将学习一些工具，可以用来解决更广泛的问题。
|
||||
|
||||
## 局部搜索 (Local Search)
|
||||
|
||||
局部搜索是一种保持单一节点并通过移动到邻近的节点进行搜索的搜索算法。这种类型的算法与我们之前看到的搜索类型不同。例如，在解决迷宫的过程中，我们想找到通往目标的最快捷的方法，而局部搜索则对寻找问题的最佳答案感兴趣。通常情况下，局部搜索会带来一个不是最佳但 "足够好 "的答案，以节省计算能力。考虑一下下面这个局部搜索问题的例子：我们有四所房子在设定的位置。我们想建两所医院，使每所房子到医院的距离最小。这个问题可以形象地描述如下：
|
||||
|
||||
|
||||
|
||||
在这幅图中，我们看到的是房屋和医院的可能配置。它们之间的距离是用曼哈顿距离 (向上、向下和向两侧移动的次数；在[搜索](4.3.1搜索.md) 中详细讨论) 来衡量的，从每个房子到最近的医院的距离之和是 17。我们称其为成本 __(cost)__，因为我们试图使这个距离最小化。在这种情况下，一个状态将是房屋和医院的任何一个配置。
|
||||
|
||||
把这个概念抽象化，我们可以把每一种房屋和医院的配置表现为下面的状态空间图。图中的每一条都代表一个状态的值，在我们的例子中，它是房屋和医院配置的成本。
|
||||
|
||||
|
||||
|
||||
从这个可视化的角度来看，我们可以为我们接下来的讨论定义几个重要的术语：
|
||||
|
||||
- 目标函数 __(Objective Function)__ 是一个函数，我们用它来最大化解决方案的值。
|
||||
- 成本函数 __(Cost Function)__ 是一个我们用来最小化解决方案成本的函数 (这就是我们在房屋和医院的例子中要使用的函数。我们想要最小化从房屋到医院的距离)。
|
||||
- 当前状态 __(Current State)__ 是指函数目前正在考虑的状态。
|
||||
- 邻居状态 __(Neighbor State)__ 是当前状态可以过渡到的一个状态。在上面的一维状态空间图中，邻居状态是指当前状态两侧的状态。在我们的例子中，邻居状态可以是将其中一家医院向任何方向移动一步所产生的状态。邻居状态通常与当前状态相似，因此，其值与当前状态的值接近。
|
||||
|
||||
请注意，局部搜索算法的工作方式是考虑当前状态下的一个节点，然后将该节点移动到当前状态的一个邻节点处。这与极大极小算法不同，例如，在极大极小算法中，状态空间中的每一个状态都被递归地考虑。
|
||||
|
||||
## 爬山算法 (Hill Climbing)
|
||||
|
||||
爬山算法是局部搜索算法的一种类型。在这个算法中，邻居的状态与当前的状态进行比较，如果其中任何一个状态更好，我们就把当前的节点从当 - 的状态改为该邻居的状态。“好状态”的定义是由目标函数决定的，倾向于一个较高的值，或一个递减函数，倾向于一个较低的值。
|
||||
|
||||
一个爬山算法在伪代码中会有以下样子：
|
||||
|
||||
```txt
|
||||
function Hill-Climb(problem):
|
||||
current = initial state of problem
|
||||
repeat:
|
||||
neighbor = best valued neighbor of current
|
||||
if neighbor not better than current:
|
||||
return current
|
||||
current = neighbor
|
||||
```
|
||||
|
||||
在这个算法中，我们从一个当前状态开始。在一些问题中，我们会知道当前的状态是什么，而在其他问题中，我们将不得不从随机选择一个状态开始。然后，我们重复以下动作：我们评估邻居状态，选择一个具有最佳值的邻居状态。然后，我们将这个邻居状态的值与当前状态的值进行比较。如果邻居状态更好，我们将当前状态切换到邻居状态，然后重复这个过程。当我们将最佳邻居与当前状态进行比较，并且当前状态更好时，该过程就结束了。然后，我们返回当前状态。
|
||||
|
||||
使用爬山算法，我们可以开始改进我们在例子中分配给医院的位置。经过几次转换，我们得到了以下状态：
|
||||
|
||||
|
||||
|
||||
在这个状态下，成本是 11，比初始状态的成本 17 有所提高。然而，这还不是最佳状态。例如，将左边的医院移到左上角的房子下面，会使成本达到 9，比 11 好。然而，这个版本的爬山算法无法达到这个目标，因为所有的邻居状态都至少和当前状态的成本一样高。从这个意义上说，爬坡算法是短视的，它经常满足于比其他一些解决方案更好的解决方案，但不一定是所有可能的解决方案中最好的。
|
||||
|
||||
### 局部和全局最小值和最大值
|
||||
|
||||
如上所述，爬山算法可能卡在局部最大值或最小值中。局部最大值是一个比其相邻状态有更高值的状态。而全局最大值是指在状态空间的所有状态中具有最高值的状态。
|
||||
|
||||
|
||||
|
||||
相比之下，局部最小值是一个比其相邻状态的值更低的状态。与此相对，全局最小值是指在状态空间中所有状态中具有最低值的状态。
|
||||
|
||||
|
||||
|
||||
爬山算法的问题是，它们可能会在局部最小和最大中结束。一旦算法到达一个点，其邻居状态就目标函数而言，比当前状态更糟糕，算法就会停止。特殊类型的局部最大值和最小值包括平坦的局部最大值/最小值 __(flat local maximum/minimum)__，即多个数值相同的状态相邻，形成一个plateau，其邻居状态的数值更差；以及 __shoulder__，邻居状态既可以更好，也可以更差。从 plateau 的中间开始，算法将无法向任何方向推进。
|
||||
|
||||
|
||||
|
||||
### 爬山算法的变体
|
||||
|
||||
由于爬山算法的局限性，人们想到了多种变体来克服卡在局部最小值和最大值的问题。该算法的所有变体的共同点是，无论采用何种策略，每一种变体都有可能陷入局部最小或最大，并且没有办法继续优化。下面的算法是这样表述的：数值越大越好，但它们也适用于成本函数，其目标是使成本最小化。
|
||||
|
||||
- __Steepest-ascent__: 选择值最高的邻居状态。
|
||||
- Stochastic: 从值较高的邻居状态中随机选择。这样做，我们选择去任何比我们的值更高的方向。
|
||||
- __First-choice__: 选择第一个值较高的邻居状态。
|
||||
- __Random-restart__: 进行多次爬山。每次都从一个随机状态开始。比较每次试验的最大值，并在这些最大值中选择一个。
|
||||
- __Local Beam Search__: 选择值最高的 k 个邻居状态。这与大多数本地搜索算法不同，它使用多个节点进行搜索，而不是只有一个节点。
|
||||
|
||||
虽然局部搜索算法并不总是给出最好的解决方案，但在考虑所有可能的状态在计算上不可行的情况下，它们往往能给出足够好的解决方案。
|
||||
|
||||
## 模拟退火算法 (Simulated Annealing)
|
||||
|
||||
尽管我们已经看到了可以改进爬山算法的变种，但它们都有一个共同的错误：一旦算法达到局部最大值，它就会停止运行。模拟退火算法允许算法在卡在局部最大值时"摆脱"自己。
|
||||
|
||||
退火是指加热金属并让其缓慢冷却的过程，其作用是使金属变硬。这被用来比喻模拟退火算法，该算法开始时温度较高，更有可能做出随机决定，随着温度的降低，它变得不太可能做出随机决定，变得更加"坚定"。这种机制允许算法将其状态改变为比当前状态更差的邻居状态，这就是它如何摆脱局部最大值的原因。以下是模拟退火法的伪代码：
|
||||
|
||||
```txt
|
||||
function Simulated-Annealing(problem, max):
|
||||
current = initial state of problem
|
||||
for t = 1 to max:
|
||||
T = Temperature(t)
|
||||
neighbor = random neighbor of current
|
||||
ΔE = how much better neighbor is than current
|
||||
if ΔE > 0:
|
||||
current = neighbor
|
||||
with probability e^(ΔE/T) set current = neighbor
|
||||
return current
|
||||
```
|
||||
|
||||
该算法将一个`problem`和`max`作为输入，`max`是它应该重复的次数。对于每个迭代，`T`是用一个`Temperature`函数来设置的。这个函数在早期迭代中返回一个较高的值 (当`t`较低时)，在后期迭代中返回一个较低的值 (当`t`较高时)。然后，随机选择一个邻居状态，并计算`ΔE`，使其量化邻居状态比当前状态好的程度。如果邻居状态比当前状态好 (`ΔE>0`)，像以前一样，我们将当前状态设置为邻居状态。然而，当邻居状态较差时 (`ΔE<0`)，我们仍然可能将我们的当前状态设置为该邻居状态，并且我们以$e^{ΔE/t}$的概率这样做。这里的意思是，更小的`ΔE`将导致邻居状态被选择的概率降低，而温度`t`越高，邻居状态被选择的概率越高。这意味着邻居状态越差，被选择的可能性就越小，而算法在其过程中越早，就越有可能将一个较差的邻居状态设置为当前状态。这背后的数学原理如下：`e`是一个常数 (大约 2.72)，`ΔE`是负数 (因为这个邻居比当前状态更糟糕)。温度`t`越高，ΔE/`t`就越接近于 0，使概率更接近于 1。
|
||||
|
||||
### 旅行商问题 (Traveling Salesman Problem)
|
||||
|
||||
在旅行商问题中，任务是连接所有的点，同时选择最短的距离。例如，这就是快递公司需要做的事情：找到从商店到所有客户家的最短路线，然后再返回。
|
||||
|
||||
| 优化前 | 优化后 |
|
||||
| ------------------------------ | ------------------------------ |
|
||||
|  |  |
|
||||
|
||||
在这种情况下，邻居状态可以被看作是两个箭头互换位置的状态。计算每一个可能的组合使得这个问题在计算上要求很高 (10 个点给了我们 10! 或者说 3,628,800 条可能的路线)。通过使用模拟退火算法，可以以较低的计算成本找到一个好的解决方案。
|
||||
|
||||
## 线性规划 (Linear Programming)
|
||||
|
||||
线性规划是一个优化线性方程 (y=ax₁+bx₂+...形式的方程) 的问题系列。
|
||||
|
||||
线性规划有以下内容：
|
||||
|
||||
- 一个我们想要最小化的成本函数：c₁x₁ + c₂x₂ + ... + cₙxₙ。这里，每个 x 是一个变量，它与一些成本 c 相关联。
|
||||
- 一个约束条件，它表示为一个变量的总和，它要么小于或等于一个值 (a₁x₁+a₂x₂+...+aₙxₙ≤b)，要么正好等于这个值 (a₁x₁+a₂x₂+...+aₙxₙ=b)。在这种情况下，x 是一个变量，a 是与之相关的一些资源，而 b 是我们可以为这个问题投入多少资源。
|
||||
- 变量的域 (例如，一个变量不能是负数)，形式为 lᵢ≤xᵢ≤uᵢ。
|
||||
|
||||
请考虑以下例子：
|
||||
|
||||
- 两台机器，X₁和 X₂。X₁的运行成本为 50 美元/小时，X₂的运行成本为 80 美元/小时。我们的目标是使成本最小化。这可以被表述为一个成本函数：50x₁+80x₂。
|
||||
- X₁每小时需要 5 个单位的劳动力。X₂每小时需要 2 个单位的劳动力。总共需要花费 20 个单位的劳动力。这可以被形式化为一个约束条件：5x₁ + 2x₂ ≤ 20。
|
||||
- X₁每小时生产 10 个单位的产品。X₂每小时生产 12 个单位的产品。公司需要 90 个单位的产出。这是另一个约束条件。从字面上看，它可以被改写为 10x₁+12x₂≥90。然而，约束条件必须是 (a₁x₁+a₂x₂+...+aₙxₙ≤b) 或 (a₁x₁+a₂x₂+...+aₙxₙ=b)。因此，我们乘以 (-1)，得到一个所需形式的等价方程：(-10x₁)+(-12x₂)≤-90。
|
||||
|
||||
线性规划的优化算法需要几何学和线性代数的背景知识，而我们并不想假设这些知识。相反，我们可以使用已经存在的算法，如 Simplex 和 Interior-Point。
|
||||
|
||||
下面是一个使用 Python 中 scipy 库的线性规划例子：
|
||||
|
||||
```python
|
||||
import scipy.optimize
|
||||
# Objective Function: 50x_1 + 80x_2
|
||||
# Constraint 1: 5x_1 + 2x_2 <= 20
|
||||
# Constraint 2: -10x_1 + -12x_2 <= -90
|
||||
result = scipy.optimize.linprog(
|
||||
[50, 80], # Cost function: 50x_1 + 80x_2
|
||||
A_ub=[[5, 2], [-10, -12]], # Coefficients for inequalities
|
||||
b_ub=[20, -90], # Constraints for inequalities: 20 and -90
|
||||
)
|
||||
if result.success:
|
||||
print(f"X1: {round(result.x[0], 2)} hours")
|
||||
print(f"X2: {round(result.x[1], 2)} hours")
|
||||
else:
|
||||
print("No solution")
|
||||
```
|
||||
|
||||
## 约束满足(Constraint Satisfaction)
|
||||
|
||||
约束满足问题是一类需要在满足某些条件下为变量赋值的问题。
|
||||
|
||||
约束条件满足问题具有一下特性:
|
||||
|
||||
- 变量集合{x₁，x₂，...，xₙ}。
|
||||
- 每个变量域的集合{D₁, D₂, ..., Dₙ}。
|
||||
- 一组约束条件 C
|
||||
|
||||
数独可以表示为一个约束满足问题，每个空方块是一个变量，域是数字 1-9，而约束是不能彼此相等的方块。
|
||||
|
||||
|
||||
|
||||
再考虑一个例子。每个学生 1-4 都在选修 A、B、...、G 中的三门课程。每门课程都需要有考试，可能的考试日是星期一、星期二和星期三。但是，同一个学生不能在同一天有两次考试。在这种情况下，变量是课程，域是天数，约束条件是哪些课程不能在同一天安排考试，因为是同一个学生在考试。这可以直观地显示如下：
|
||||
|
||||
|
||||
|
||||
这个问题可以用约束条件来解决，约束条件用图来表示。图中的每个节点是一门课程，如果两门课程不能安排在同一天，则在它们之间画一条边。在这种情况下，该图看起来是这样的：
|
||||
|
||||
|
||||
|
||||
关于约束满足问题，还有几个值得了解的术语：
|
||||
|
||||
- 硬约束 (Hard Constraint) 是指在一个正确的解决方案中必须满足的约束。
|
||||
- 软约束 (Soft Constraint) 是一种约束，表示哪种解决方案比其他解决方案更受欢迎。
|
||||
- 一元约束 (Unary Constraint) 是指只涉及一个变量的约束。在我们的例子中，一元约束是指课程 A 在周一不能有考试{A≠周一}。
|
||||
- 二元约束 (Binary Constraint) 是一种涉及两个变量的约束。这就是我们在上面的例子中使用的约束类型，表示两个课程不能有相同的值{A ≠ B}。
|
||||
|
||||
### 节点一致性 (Node Consistency)
|
||||
|
||||
节点一致性是指一个变量域中的所有值都满足该变量的一元约束。
|
||||
|
||||
例如，让我们拿两门课程，A 和 B。每门课程的域是{Monday, Tuesday, Wednesday}，约束条件是{A≠Mon，B≠Tue，B≠Mon，A≠B}。现在，A 和 B 都不是一致的，因为现有的约束条件使它们不能取其域中的每一个值。然而，如果我们从 A 的域中移除 Monday，那么它就会有节点一致性。为了实现 B 的节点一致性，我们必须从它的域中删除 Monday 和 Tuesday。
|
||||
|
||||
### 弧一致性 (Arc Consistency)
|
||||
|
||||
弧一致性是指一个变量域中的所有值都满足该变量的二元约束 (注意，我们现在用"弧"来指代我们以前所说的 "边")。换句话说，要使 X 对 Y 具有弧一致性，就要从 X 的域中移除元素，直到 X 的每个选择都有 Y 的可能选择。
|
||||
|
||||
考虑到我们之前的例子，修改后的域：A:{Tuesday, Wednesday}和 B:{Wednesday}。如果 A 与 B 是弧一致的，那么无论 A 的考试被安排在哪一天 (从它的域来看)，B 仍然能够安排考试。A 与 B 是弧一致的吗？如果 A 取值为 Tuesday，那么 B 可以取值为 Wednesday。然而，如果 A 取值为 Wednesday，那么就没有 B 可以取的值 (记住，其中一个约束是 A≠B)。因此，A 与 B 不是弧一致的。为了改变这种情况，我们可以从 A 的域中删除 Wednesday。然后，A 的任何取值 (Tuesday 是唯一的选择) 都会给 B 留下一个取值 (Wednesday)。现在，A 与 B 是弧一致的。让我们看看一个伪代码的算法，使一个变量相对于其他变量是弧一致的 (注意，csp 代表 "约束满足问题")。
|
||||
|
||||
```python
|
||||
function Revise(csp, X, Y):
|
||||
revised = false
|
||||
for x in X.domain:
|
||||
if no y in Y.domain satisfies constraint for (X,Y):
|
||||
delete x from X.domain
|
||||
revised = true
|
||||
return revised
|
||||
```
|
||||
|
||||
这个算法从跟踪 X 的域是否有任何变化开始，使用变量 revised，这在我们研究的下一个算法中会很有用。然后，代码对 X 的域中的每一个值进行重复，看看 Y 是否有一个满足约束条件的值。如果是，则什么都不做，如果不是，则从 X 的域中删除这个值。
|
||||
|
||||
通常情况下，我们感兴趣的是使整个问题的弧一致，而不仅仅是一个变量相对于另一个变量的一致性。在这种情况下，我们将使用一种叫做 AC-3 的算法，该算法使用 Revise：
|
||||
|
||||
```python
|
||||
function AC-3(csp):
|
||||
queue = all arcs in csp
|
||||
while queue non-empty:
|
||||
(X, Y) = Dequeue(queue)
|
||||
if Revise(csp, X, Y):
|
||||
if size of X.domain == 0:
|
||||
return false
|
||||
for each Z in X.neighbors - {Y}:
|
||||
Enqueue(queue, (Z,X))
|
||||
return true
|
||||
```
|
||||
|
||||
该算法将问题中的所有弧添加到一个队列中。每当它考虑一个弧时，它就把它从队列中删除。然后，它运行 Revise 算法，看这个弧是否一致。如果做了修改使其一致，则需要进一步的行动。如果得到的 X 的域是空的，这意味着这个约束满足问题是无法解决的 (因为没有任何 X 可以取的值会让 Y 在约束条件下取任何值)。如果问题在上一步中没有被认为是不可解决的，那么，由于 X 的域被改变了，我们需要看看与 X 相关的所有弧是否仍然一致。也就是说，我们把除了 Y 以外的所有 X 的邻居，把他们和 X 之间的弧添加到队列中。然而，如果 Revise 算法返回 false，意味着域没有被改变，我们只需继续考虑其他弧。
|
||||
|
||||
虽然弧一致性的算法可以简化问题，但不一定能解决问题，因为它只考虑了二元约束，而没有考虑多个节点可能的相互连接方式。我们之前的例子中，4个学生中的每个人都在选修3门课程，对其运行AC-3后，仍然没有变化。
|
||||
|
||||
我们讲过[搜索](4.3.1搜索.md)问题。一个约束满足问题可以被看作是一个搜索问题：
|
||||
|
||||
- 初始状态 (Initial state)：空赋值 (所有变量都没有分配任何数值)。
|
||||
- 动作 (Action)：在赋值中加入一个{变量=值}；也就是说，给某个变量一个值。
|
||||
- 过渡模型 (Transition model)：显示添加赋值如何改变变量。这没有什么深度：过渡模型返回包括最新动作后的赋值的状态。
|
||||
- 目标测试 (Goal test)：检查所有变量是否被赋值，所有约束条件是否得到满足。
|
||||
- 路径成本函数 (Path cost function)：所有路径的成本都是一样的。正如我们前面提到的，与典型的搜索问题相比，优化问题关心的是解决方案，而不是通往解决方案的路线。
|
||||
|
||||
然而，把约束满足问题作为一个普通的搜索问题来处理，是非常低效的。相反，我们可以利用约束满足问题的结构来更有效地解决它。
|
||||
|
||||
### 回溯搜索 (Backtracking Search)
|
||||
|
||||
回溯搜索是一种考虑约束满足搜索问题结构的搜索算法。一般来说，它是一个递归函数，只要值满足约束，它就会尝试继续赋值。如果违反了约束，它将尝试不同的赋值。让我们看看它的伪代码：
|
||||
|
||||
```python
|
||||
function Backtrack(assignment, csp):
|
||||
if assignment complete:
|
||||
return assignment
|
||||
var = Select-Unassigned-Var(assignment, csp)
|
||||
for value in Domain-Values(var, assignment, csp):
|
||||
if value consistent with assignment:
|
||||
add {var = value} to assignment
|
||||
result = Backtrack(assignment, csp)
|
||||
if result ≠ failure:
|
||||
return result
|
||||
remove {var = value} from assignment
|
||||
return failure
|
||||
```
|
||||
|
||||
换句话说，如果当前赋值完成，则该算法返回当前赋值。这意味着，如果完成了算法，它将不会执行任何额外的操作，它只会返回已成立的赋值。如果赋值不完整，算法会选择任何尚未赋值的变量。然后，算法尝试为变量赋值，并对结果赋值再次运行回溯算法（递归）。然后，它检查结果值。如果不是失败，则表示赋值已完成，并且应返回此赋值。如果结果值失败，则删除最近的赋值，并尝试新的可能值，重复相同的过程。如果域中所有可能的值都返回失败，这意味着我们需要回溯。也就是说，问题出在之前的一些作业上。如果这种情况发生在我们开始使用的变量上，那么这意味着没有解决方案满足约束。
|
||||
|
||||
考虑以下行动方案：
|
||||
|
||||
|
||||
|
||||
我们从空赋值开始。然后，我们选择变量 A，并给它赋值`Mon`。然后，使用这个赋值，我们再次运行算法。既然 A 已经有了一个赋值，算法将考虑 B，并将`Mon`赋值给它。此赋值返回`false`，因此算法将尝试在`Tue`为 B 赋值，而不是在给定上一个赋值的情况下为 C 赋值。这个新的赋值满足约束条件，在给定这个赋值的情况下，下一步将考虑一个新的变量。例如，如果将`Tue`或`Wed`也赋值给 B 会导致失败，那么算法将回溯并返回到考虑 A，为其分配另一个值，即`Tue`。如果`Tue`和`Wed`也失败了，那么这意味着我们已经尝试了所有可能的赋值，该问题是无法解决的。
|
||||
|
||||
在源代码部分，您可以从头开始实现的回溯算法。然而，这种算法被广泛使用，因此，多个库已经包含了它的实现。
|
||||
|
||||
## 推理 (Inference)
|
||||
|
||||
尽管回溯搜索比简单搜索更有效，但它仍然需要大量的算力。另一方面，满足弧一致性需要的算力较低。通过将回溯搜索与推理交织在一起（满足弧一致性），我们可以得到一种更有效的算法。该算法被称为“保持弧一致性”__(Maintaining Arc-Consistency)__ 算法。该算法将在每次新的回溯搜索分配之后满足弧一致性。具体来说，在我们对 X 进行新的赋值后，我们将调用`AC-3`算法，并从所有弧 (Y，X) 的队列开始，其中 Y 是 X 的邻居 (而不是问题中所有弧的队列)。以下是一个经过修订的 Backtrack 算法，该算法保持了弧的一致性。
|
||||
|
||||
```python
|
||||
function Backtrack(assignment, csp):
|
||||
if assignment complete:
|
||||
return assignment
|
||||
var = Select-Unassigned-Var(assignment, csp)
|
||||
for value in Domain-Values(var, assignment, csp):
|
||||
if value consistent with assignment:
|
||||
add {var = value} to assignment # new here
|
||||
inferences = Inference(assignment, csp) # new here
|
||||
if inferences ≠ failure:
|
||||
add inferences to assignment
|
||||
result = Backtrack(assignment, csp)
|
||||
if result ≠ failure:
|
||||
return result
|
||||
remove {var = value} and inferences from assignment # new here
|
||||
return failure
|
||||
```
|
||||
|
||||
Inference 函数运行 AC-3 算法，如前所述。它的输出是通过满足弧一致性可以做出的所有推断。从字面上看，这些是可以从以前的赋值和约束满足问题的结构中推导出来的新赋值。
|
||||
|
||||
还有其他方法可以提高算法的效率。到目前为止，我们随机选择了一个未分配的变量。然而，有些选择比其他选择更有可能更快地找到解决方案。这需要使用启发式方法。启发式是一条经验法则，这意味着，通常情况下，它会比遵循随机的方法带来更好的结果，但不能保证总是更优。
|
||||
|
||||
__最小剩余值 (Minimum Remaining Values(MRV))__ 就是这样一种启发式方法。这里的想法是，如果一个变量的域被推理限制了，现在它只剩下一个值 (甚至是两个值)，那么通过进行这种赋值，我们将减少以后可能需要进行的回溯次数。也就是说，我们迟早要做这个赋值，因为它是从满足弧一致性中推断出来的。如果这项任务失败了，最好尽快发现，避免以后的回溯。
|
||||
|
||||
|
||||
|
||||
例如，在给定当前赋值的情况下缩小变量的域后，使用 MRV 启发式，我们接下来将选择变量 C，并以 Wed 为其赋值。
|
||||
|
||||
__度 (Degree)__ 启发式依赖于变量的度，其中度是指将一个变量连接到其他变量的弧数。通过一次赋值选择度最高的变量，我们约束了多个其他变量，从而加快了算法的进程。
|
||||
|
||||
|
||||
|
||||
例如，上面所有的变量都有相同大小的域。因此，我们应该选择一个度最高的域，它将是变量 E。
|
||||
|
||||
这两种启发式方法并不总是适用的。例如，当多个变量在其域中具有相同的最小值时，或者当多个变数具有相同的最高度时。
|
||||
|
||||
另一种提高算法效率的方法是，当我们从变量的域中选择一个值时，使用另一种启发式方法。在这里，我们使用 __最小约束值 (Least Constraining Values)__ 启发式，在这里我们选择将约束最少其他变量的值。这里的想法是，在度启发式中，我们希望使用更可能约束其他变量的变量，而在这里，我们希望这个变量对其他变量的约束最少。也就是说，我们希望找到可能是最大潜在麻烦源的变量 (度最高的变量)，然后使其尽可能不麻烦 (为其赋值约束其他变量最少的值)。
|
||||
|
||||
|
||||
|
||||
例如，让我们考虑变量 C。如果我们将`Tue`分配给它，我们将对所有 B、E 和 F 施加约束。然而，如果我们选择`Wed`，我们将只对 B 和 E 施加约束。因此，选择`Tue`可能更好。
|
||||
|
||||
总之，优化问题可以用多种方式来表述。在这，我们考虑了局部搜索、线性规划和约束满足。
|
||||
22
2023旧版内容/4.人工智能/4.3人工智能导论及机器学习入门.md
Normal file
22
2023旧版内容/4.人工智能/4.3人工智能导论及机器学习入门.md
Normal file
@@ -0,0 +1,22 @@
|
||||
# 人工智能导论及机器学习入门
|
||||
|
||||
人工智能（Artificial Intelligence, AI）是机器，特别是计算机系统对人类智能过程的模拟。人工智能是一个愿景，目标就是让机器像我们人类一样思考与行动，能够代替我们人类去做各种各样的工作。人工智能研究的范围非常广，包括演绎、推理和解决问题、知识表示、学习、运动和控制、数据挖掘等众多领域。
|
||||
|
||||
## 人工智能、机器学习与深度学习关系
|
||||
|
||||
人工智能是一个宏大的愿景，目标是让机器像我们人类一样思考和行动，既包括增强我们人类脑力也包括增强我们体力的研究领域。而学习只是实现人工智能的手段之一，并且，只是增强我们人类脑力的方法之一。所以，人工智能包含机器学习。机器学习又包含了深度学习，他们三者之间的关系见下图。
|
||||
|
||||
|
||||
|
||||
## 如何学习本节内容
|
||||
|
||||
作者深知学习人工智能时面临许多繁碎数学知识，复杂数学公式的痛苦，因此，本节内容重在讲解核心概念和算法，略去了复杂的数学推导，尽可能以直觉的方式去理解，本文的数学知识，高中生足以掌握。阅读本节内容不需要人工智能基础，你可以直接从本节入门 AI。本节内容的算法、项目实现将使用 python 实现，需要掌握一定的 python 基础语法。当然如果你急于了解 AI，却又不会 python，没有关系，你可以选择跳过其中的编程部分，着眼于其中的概念、算法，程序语言是算法实现的工具，并非学习算法的必须品。
|
||||
|
||||
## 学习建议
|
||||
|
||||
本节内容是作者根据[哈佛的 CS50AI 导论](https://cs50.harvard.edu/ai/2020/)以及 [Andrew Ng 的机器学习专项课程](https://www.coursera.org/specializations/machine-learning-introduction)简化编写，当然你可以直接学习这两门课程。本节内容的总学习时间应该是二到三个月，如果你在某个知识点上卡住了，你也许需要反复阅读讲义，必要时向身边人求助。
|
||||
|
||||
## 补充材料
|
||||
|
||||
|
||||
人工智能现代方法（第四版）
|
||||
58
2023旧版内容/4.人工智能/4.4FAQ：常见问题.md
Normal file
58
2023旧版内容/4.人工智能/4.4FAQ：常见问题.md
Normal file
@@ -0,0 +1,58 @@
|
||||
# FAQ：常见问题
|
||||
|
||||
## 我是非计算机专业的，感觉 AI 很火，可以看这篇内容吗
|
||||
|
||||
如果你不打算做相关研究的话，我觉得你最先应该考虑的是熟练掌握使用 AI 工具，本章内容更偏向于完善 AI 方面的知识体系架构
|
||||
|
||||
## 我对AI/CV/NLP/blabla研究方向很感兴趣可以看这篇内容吗？
|
||||
|
||||
目前的本章节的内容的定位仍在引导大家有更广阔的视野，在引导的同时给大家正确的学习/思考模式。
|
||||
|
||||
因此如果你想学某个知识体系，可以参考本章内容的路线，但是若你有足够强大的能力可以直接应对国外课程体系的困难，那么我非常推荐你去直接看英文内容
|
||||
|
||||
因为我们在降低门槛的时候也一定程度上让各位损失了一定的训练，在概括的过程中，信息量被稀释了，抽象地描述也许更能让你 get 到一些思想性的内容
|
||||
|
||||
## 我数学不好可以学吗
|
||||
|
||||
可以。我将在教程的脉络中引入数学的相关内容，帮助你正确认识数学和 AI 技术的相关性。
|
||||
|
||||
并且我希望你阅读这些文章
|
||||
|
||||
- [数学不好可以学机器学习吗](https://machinelearningmastery.com/what-if-im-not-good-at-mathematics/)
|
||||
- [没有数学专业背景和理解机器学习算法的 5 种技巧](http://machinelearningmastery.com/techniques-to-understand-machine-learning-algorithms-without-the-background-in-mathematics/)
|
||||
- [我是如何学习机器学习的？](https://www.quora.com/Machine-Learning/How-do-I-learn-machine-learning-1)
|
||||
|
||||
## 很多东西学校都没学
|
||||
|
||||
如果你完全依赖学校的进度，你可能一直都会有认为学校应该教但你没学到的东西
|
||||
|
||||
同时，这是一门前沿学科，学校学习的多数内容并不能达到掌握相关知识的要求。
|
||||
|
||||
你应该更多地依赖自己而不是学校
|
||||
|
||||
## [如果不是相关领域可以找到这个领域工作吗](https://www.quora.com/How-do-I-get-a-job-in-Machine-Learning-as-a-software-programmer-who-self-studies-Machine-Learning-but-never-has-a-chance-to-use-it-at-work)
|
||||
|
||||
> “我正在为团队招聘专家，但你的 MOOC 并没有给你带来工作学习机会。我大部分机器学习方向的硕士也并不会得到机会，因为他们（与大多数工作）上过 MOOC 的人一样）并没有深入地去理解。他们都无法帮助我的团队解决问题。”Ross C. Taylor
|
||||
|
||||
## 人工智能，深度学习，机器学习，数据分析，我该如何区分
|
||||
|
||||
人工智能包括机器学习
|
||||
|
||||
机器学习包括深度学习
|
||||
|
||||
|
||||
|
||||
[同时向你推荐这个 Data Analytics，Data Analysis，数据挖掘，数据科学，机器学习，大数据的区别是什么？](https://www.quora.com/What-is-the-difference-between-Data-Analytics-Data-Analysis-Data-Mining-Data-Science-Machine-Learning-and-Big-Data-1)
|
||||
|
||||
|
||||
|
||||
## 我没有任何相关概念
|
||||
|
||||
尝试阅读以下内容
|
||||
|
||||
- [形象的机器学习简介](http://www.r2d3.us/visual-intro-to-machine-learning-part-1/)
|
||||
- [为开发者准备的机器学习简介](http://blog.algorithmia.com/introduction-machine-learning-developers/)
|
||||
- [菜鸟的机器学习基础](https://www.analyticsvidhya.com/blog/2015/06/machine-learning-basics/)
|
||||
- [你如何向非计算机专业的人来解释机器学习与数据挖掘？](https://www.quora.com/How-do-you-explain-Machine-Learning-and-Data-Mining-to-non-Computer-Science-people)
|
||||
- [在罩子下的机器学习，博文简单明了地介绍了机器学习的原理](https://georgemdallas.wordpress.com/2013/06/11/big-data-data-mining-and-machine-learning-under-the-hood/)
|
||||
- [机器学习是什么？它是如何工作的呢？](https://www.youtube.com/watch?v=elojMnjn4kk&list=PL5-da3qGB5ICeMbQuqbbCOQWcS6OYBr5A&index=1)
|
||||
266
2023旧版内容/4.人工智能/4.5图网络略述（intro&GCN）.md
Normal file
266
2023旧版内容/4.人工智能/4.5图网络略述（intro&GCN）.md
Normal file
@@ -0,0 +1,266 @@
|
||||
# 图网络略述（intro&GCN）
|
||||
|
||||
> author：廖总
|
||||
|
||||
其实开始冲图神经网络也已经有一段时间了，从半年前阅览《Relational inductive biases, deep learning, and graph networks》一文，对图网络有了一定的了解，到现在已经过去半年了。然而这半年中我一直在摸鱼，就算偶尔复习图神经网络的方法，也一直在复习相同的工作。如今有幸受实验室隔座的兄弟邀请参与一个科研项目。比较尴尬的是，我除了自诩知晓图网络以外，对实际的操作与应用一无所知。我遂写下这篇文章，来昭示自己正式开始图网络的学习，并且尝试记录和融汇已知的知识点，不在浪费时间于重复的工作上。
|
||||
|
||||
首先，图网络是为什么产生的呢，通常，我们简略的称之为，方便表达结构化的知识，处理结构化的数据。这里的结构其实跟数据库及数据结构中描述的结构是相似的，即一种信息之间关联的结构，以及知识之间关联的结构。图拥有这样的特点，能通过节点来对实体进行描述，并用边描述实体之间的关系，与此同时还有着隐含信息的储存和全局信息的存在，于是构成了一个新颖且复杂的神经网络结构。
|
||||
|
||||
在周志华的机器学习一书半监督学习章节中，有对基本的图学习策略进行基本的描述，详见我为了应付课程考试整理的[图半监督学习](http://blog.cyasylum.top/index.php/2020/07/05/%E5%9B%BE%E5%8D%8A%E7%9B%91%E7%9D%A3%E5%AD%A6%E4%B9%A0/)。其基本思路是这样的，通过”样本距离度量“刻画获取样本之间的联系，将样本嵌入到“图”，即样本即其关系的集合中。后通过图将半监督学习中有标记样本的标签对未标记样本进行传递，从而获取未标记样本的属性，进行学习。
|
||||
|
||||
如此，便定下来图网络的基本思路，即通过*信息在图上的传递*，迭代学习知识。有了这样的基础，我们便可以开始对图网络进行讨论了。
|
||||
|
||||
接下来，我们从最基础的部分来讲讲，信息是如何在图上进行传播的。
|
||||
|
||||
## 消息传递
|
||||
|
||||
那么，消息是什么呢？在大多数时候，我们将消息理解为节点（但其实在特定场合，边或者全局信息都是可以或者需要考虑的），即“实体”包含的，要传递的信息。对于一个结构相对复杂的节点而言，假设其拥有 n 个属性，我们便用一个 n 维的向量（或是其他什么）$\mathbf{x}$表示节点中储存的信息。然后，节点上的信息要怎么传递呢？
|
||||
|
||||
答案必然是通过节点之间的连接。
|
||||
|
||||
在离散数学中，我们使用邻接矩阵来刻画图上所有节点之间的联系，即 Adjacency Matrix，记作$\mathbf{A}$。在不考虑边权重的情况下，我们将存在节点$x_{i},x_{j}$之间的联系表示为$A_{ij}=1$，在存在权重的情况下，我们将$A_{ij}$的值记作两节点之间边的权重。值得注意的是，$\mathbf{A}$对角线上的值，即节点之间自连接的系数，在不做考虑自连接时都被记作 $0$ 。
|
||||
|
||||
另外，我们特殊定义节点的度为该点所有连接权重之和，即$D_i=\sum_{j=0}^n A_{ij} $，使用对角矩阵$\mathbf{D}=diag(D_1,D_2,\cdots,D_n)$进行统一描述。
|
||||
|
||||
如此，我们便通过了两个矩阵刻画了一张图上所有节点之间的传递关系。为了方便计算，以及因为种种特性，一张图最终的传递特性，被描述成了拉普拉斯矩阵$\mathbf{L}=\mathbf{D}-\mathbf{A}$。
|
||||
|
||||
我们通过拉普拉斯矩阵 $L$ 来考虑图上的消息传递特性。
|
||||
|
||||
同时，我们可以理解为，拉普拉斯矩阵描述了图的结构。
|
||||
|
||||
## 归一化拉普拉斯矩阵
|
||||
|
||||
为了方便拉普拉斯矩阵在机器学习等众多需要迭代求解问题中的实际使用，我们要求对拉普拉斯矩阵进行归一化操作，从而避免在多次传递后导致的梯度爆炸和梯度消失。我们需要令其对角线上元素统一等于 1。
|
||||
|
||||
我们已知的是，主对角线上的元素只会同
|
||||
$D$矩阵有关，因此，我们引入了
|
||||
$\mathbf{D}^{-\tfrac{1}{2}}$ 作为归一化算子，令归一化拉普拉斯矩阵为
|
||||
|
||||
$$
|
||||
\mathbf{L}^{sym}
|
||||
=\mathbf{D}^{-\frac{1}{2}}
|
||||
\mathbf{L}\mathbf{D}^{-\frac{1}{2}}
|
||||
=\mathbf{I}-\mathbf{D}^{-\frac{1}{2}}
|
||||
\mathbf{A}\mathbf{D}^{-\frac{1}{2}}
|
||||
$$
|
||||
|
||||
$$
|
||||
L_{ij}^{sym}=
|
||||
\begin{cases}
|
||||
1 \quad\quad\quad\quad\quad\quad\quad\enspace\thinspace \left ( i=j\right ) \cup \left ( deg(v_i)\ne0 \right ) \\
|
||||
-\frac{1}{\sqrt{deg(v_i)deg(v_j)}} \qquad \left ( i\ne j \right ) \cup \left ( v_i adj v_j \right ) \\
|
||||
0 \quad\quad\quad\quad\quad\quad\quad\;\;\; else.
|
||||
\end{cases}
|
||||
$$
|
||||
|
||||
现在，我们可以尝试用$\mathbf{L}$对图进行表示了。
|
||||
|
||||
另外还有个*随机游走归一化拉普拉斯矩阵*
|
||||
$$
|
||||
\mathbf{L}^{sym}=\mathbf{D}^{-1}\mathbf{L}=\mathbf{I}-\mathbf{D}^{-1}\mathbf{A}
|
||||
$$
|
||||
|
||||
，不过我还不熟，暂时不管了。
|
||||
|
||||
## 图的频域表示
|
||||
|
||||
其实挺意外的，早在去年的这个时候，我也考虑过这个问题。对图像的矩阵进行奇异值分解，通过切除部分奇异值，我们可以对图像中的低频和高频信息进行定量的剪切，使得减少储存信息的同时不丢失大部分画质。这样的特性是不是同信号的频域分析，即傅里叶变换有着相似之处。当时的我寻遍了全网，并没有得到什么结果。而如今，我在做图的谱分析。
|
||||
|
||||
为了直观地对描述信号传播的图进行直观的“卷积滤波（需要注意的是，这里的卷积就不是图像意义上的卷积了，而是信号意义的卷积。但是在实际运用中图的卷积表示的也是信号在相邻图节点上的传播，这又与图像的卷积有着异曲同工之妙，那么新的问题来了，信号卷积和图像卷积是否也存在着什么物理层面上的联系？）”我们通过特征分解，获取图的“频谱”，从这边开始，便是 Spectral Graph Convolution 的思想了。
|
||||
|
||||
我们将 L 矩阵进行特征分解，有$\mathbf{L}=\mathbf{U}\boldsymbol{\Lambda}\mathbf{U}^\mathsf{T}$,其中特征值描述的是图像的频谱强度，而特征向量描述了分解的基底，即频率，对应频谱分析中的$e^{-j\omega t}$。
|
||||
|
||||
于是，我们考虑滤波和滤波器，我们设计$g\theta=diag(\theta)$，有滤波器改变了基底上信号的强度，即有$g\theta(\Lambda)$为特征值的函数。我们有$g\theta$在图$\mathbf{L}$上对输入信号$x$的卷积等于$g\theta$、$x$在频域相乘：
|
||||
$g\theta\star
|
||||
x=\mathbf{U}g\theta\mathbf{U}^\mathsf{T}x
|
||||
$
|
||||
|
||||
如此，我们完成了在图神经网络上进行分析的基础。
|
||||
|
||||
但是在实际问题下，这样的图是极难计算的，当我们的节点规模较大时，对 N^2^ 规模的图进行矩阵分解，并且进行多次矩阵乘法需要消耗极大的资源，这使得图网络很难运行。因此纵使图网络有着其特殊的性质，其热度一直不是很高。
|
||||
|
||||
## ChebNet 及其思考
|
||||
|
||||
ChebNet 的引入是当今神经网络大热门的开端，也是图卷积网络的基础。其思路为，使用切比雪夫多项式对卷积过程 K 阶拟合 ([参考](https://zhuanlan.zhihu.com/p/138420723))
|
||||
|
||||
ChebNet 假设$g\theta$对$\Lambda$的滤波结果是原始特征值多项式函数，而网络的目的是抛弃原本通过矩阵相乘来对卷积结果进行求解，而通过参数学习来对结果进行表示，给出下式
|
||||
|
||||
$$
|
||||
g\theta(\Lambda)=\sum_{k=0}^K \beta_kT_k(\hat{\Lambda})=\begin{pmatrix}
|
||||
\begin{matrix}\sum_{k=1}^K \beta_kT_k(\hat{\lambda_1})\end{matrix}\\
|
||||
&\cdots\\
|
||||
&&\begin{matrix} \sum_{k=1}^K \beta_kT_k(\hat{\lambda_n})\end{matrix}
|
||||
\end{pmatrix}
|
||||
$$
|
||||
|
||||
其中有切比雪夫多项式在矩阵上的表示，具体数学背景可以详细查看
|
||||
|
||||
$$
|
||||
T_0(L) = I\ T_1(L)=L\ T_{n+1}(L)=2LT_n(L) - T_{n-1}(L)
|
||||
$$
|
||||
|
||||
有$\beta_k$为网络的待学习参数
|
||||
|
||||
我们将原式
|
||||
$$
|
||||
g\theta\star
|
||||
x=\mathbf{U}g\theta\mathbf{U}^\mathsf{T}x
|
||||
$$
|
||||
|
||||
表示为拟合形式
|
||||
$$
|
||||
\mathbf{U}
|
||||
\begin{matrix} \sum_{k=0}^K \beta_kT_k(\hat{\Lambda})
|
||||
\mathbf{U}^\mathsf{T}x
|
||||
\end{matrix}
|
||||
$$
|
||||
并对其中无关输入信号 $x$ 的部分进行改写
|
||||
|
||||
$$
|
||||
\mathbf{U}\begin{matrix}\sum_{k=0}^K
|
||||
\beta_kT_k(\hat{\Lambda})
|
||||
\mathbf{U}^\mathsf{T}
|
||||
\end{matrix}
|
||||
$$
|
||||
|
||||
$$
|
||||
=\begin{matrix} \sum_{k=0}^K
|
||||
\mathbf{U}\beta_k(\begin{matrix}\sum_{c=0}^k\alpha_{kc}\hat{\Lambda^k}
|
||||
\end{matrix}\mathbf{U}^\mathsf{T})
|
||||
\end{matrix}
|
||||
$$
|
||||
$$
|
||||
=\begin{matrix} \sum_{k=0}^K\beta_k(\begin{matrix}\sum_{c=0}^k\alpha_{kc}(\mathbf{U}\hat{\Lambda}
|
||||
\mathbf{U}^\mathsf{T})^k
|
||||
\end{matrix})
|
||||
\end{matrix}
|
||||
$$
|
||||
$$
|
||||
=\begin{matrix} \sum_{k=0}^K\beta_kT_k(\mathbf{U}\hat{\Lambda}
|
||||
\mathbf{U}^\mathsf{T})
|
||||
\end{matrix}
|
||||
$$
|
||||
$$
|
||||
=\begin{matrix} \sum_{k=0}^K\beta_kT_k(\hat{\mathbf{L}})
|
||||
\end{matrix}
|
||||
$$
|
||||
|
||||
其中
|
||||
$$
|
||||
\hat{\mathbf{L}}=\frac{2}{\lambda_{max}}\mathbf{L}-\mathbf{I}_N
|
||||
$$
|
||||
|
||||
于是我们获得了
|
||||
$$
|
||||
g\theta\star
|
||||
x
|
||||
=\mathbf{U}g\theta\mathbf{U}^\mathsf{T}x
|
||||
=\begin{matrix}
|
||||
\sum_{k=0}^K\beta_kT_k
|
||||
(\hat{\mathbf{L}})x
|
||||
\end{matrix}
|
||||
$$
|
||||
|
||||
作为 ChebNet 的卷积结构
|
||||
|
||||
其中值得注意的一点是，ChebNet 的 K 值限制了卷积核的多项式次数，但是这里的多项式次数描述了什么呢？其实就是卷积的“范围”，即单次卷积内最高可获得的 K 阶相邻节点信息。在 K=n 的时候，我们从理论上可以通过单次卷积，获取一张连通图上所有结点的信息，而这也是原方法难以计算的根本原因。
|
||||
|
||||
到这里为止，我介绍了 2018 年 GCN 出现之前图网络的基本使用，并给出了对图网络的基本认知，于是，我们拥有了相对充分的工具去认识图网络近期的发展，以及更深层次的使用。
|
||||
|
||||
## Graph Convolutional Networks
|
||||
|
||||
前面谈论的都是基于图传播的方法以及理论基础，之后才是图神经网络（GNN）相关的内容，即我们需要将一个抽象的图的概念存入实际的数据结构，并考虑其在实际数据上的应用，好吧换句话来说就是开始抄论文。
|
||||
|
||||
## 设计思考
|
||||
|
||||
GCN 是典型的依靠消息传递进行迭代的网络，并通过对图卷积谱的线性逼近，其实就是只考虑相邻元素的线性组合，从而达到单层参数的最小化，使得 GCN 的深度构建成为可能。同时，一阶的拟合表示图卷积神经网络在单次卷积迭代中，仅考虑邻域的信息，这使得 GCN 在物理直觉上产生了与 CNN 的相似之处。我们可以发现，GCN 中的 Convolutional 是图的频谱卷积和图的邻域卷积的融合。即表现出了多种层面的滤波特性。也许正是如此，使得 GCN 有着如此好的表现。
|
||||
|
||||
## 数学表示
|
||||
|
||||
### 卷积层
|
||||
|
||||
### 原典
|
||||
|
||||
之前我们引入的是图传播特性的建模，而现在我们需要考虑一次实际的迭代如何在图上进行。
|
||||
|
||||
我们通常考虑输入的参数与节点的隐含状态，作为网络的隐含层，即 ℎ，我们需要在每一轮迭代中对每个节点的状态进行更新，从而达到端对端训练的可能性。因此我们要确定隐含状态的更新模式，如下展示：
|
||||
|
||||
$$
|
||||
\mathbf{h}_i^{l+1}=\sigma(\mathbf{W}_0^{(l)\mathsf{T}}\mathbf{h}_i^{(l)}+
|
||||
\begin{matrix}
|
||||
\sum_{j\in\mathcal{N}_i}c_{ij}\mathbf{W}_1^{(l)\mathsf{T}}\mathbf{h}_j^{l}+\mathbf{b}_0^{(l)}
|
||||
\end{matrix}
|
||||
)
|
||||
$$
|
||||
|
||||
### 归一化单参数
|
||||
|
||||
在实际场景中，减少了网络的参数，并对传播进行了重新的归一化
|
||||
|
||||
$$
|
||||
\mathbf{H}^{(l+1)}=\sigma(\tilde{\mathbf{D}}^{-\frac{1}{2}}\tilde{\mathbf{A}}\tilde{\mathbf{D}}^{-\frac{1}{2}}\mathbf{H}^{(l)}\mathbf{W}^{(l)})
|
||||
$$
|
||||
|
||||
其中
|
||||
$$
|
||||
\tilde{\mathbf{A}}=\mathbf{A}+\mathbf{I}_N,\tilde{D}_i
|
||||
=\begin{matrix}
|
||||
\sum_j\tilde{A}_{ij}
|
||||
\end{matrix}
|
||||
$$
|
||||
|
||||
作为传播的预处理部分，由此得到了 GCN 的完整数学表示。
|
||||
|
||||
### 损失函数
|
||||
|
||||
文中针对半监督节点分类问题设计了一下目标函数，仅对有监督部分设计交叉熵损失，有：
|
||||
|
||||
$$
|
||||
\mathcal{L}_{sup}
|
||||
=-\begin{matrix}
|
||||
\sum_{l\in\mathcal{y}_L}
|
||||
\end{matrix}
|
||||
\begin{matrix}
|
||||
\sum_{\mathcal{f}=1}^{d_{out}}\gamma_{l,f}\ln
|
||||
Z_{l,f}
|
||||
\end{matrix}
|
||||
$$
|
||||
|
||||
其中 γ 为指示变量，表示蒸馏分类正确类的交叉熵损失。
|
||||
$$
|
||||
\mathbf{Z}=f(\mathbf{X},\mathbf{A})
|
||||
$$
|
||||
|
||||
为预测结果。即我们希望正确分类下类可能性的最大化。
|
||||
|
||||
## 代码实现
|
||||
|
||||
归一化步骤
|
||||
|
||||
```python
|
||||
def norm(A):
|
||||
A = A + torch.eye(A.size(0))
|
||||
d = torch.sum(A, dim=1)
|
||||
D = torch.diag(d)
|
||||
|
||||
return torch.pow(D,-0.5).mm(A).mm(torch.pow(D,-0.5))
|
||||
```
|
||||
|
||||
GCN 本体
|
||||
|
||||
```python
|
||||
class GCN(nn.Module):
|
||||
def __init__(self, A, din, hidden, dout):
|
||||
super(GCN, self).__init__()
|
||||
self.A = norm(A)
|
||||
self.gcn1 = nn.Linear(din, hidden, bias=True)
|
||||
self.gcn2 = nn.Linear(hidden, dout, bias=True)
|
||||
def forward(self, X):
|
||||
X = F.relu(self.gcn1(self.A.mm(X)))
|
||||
X = self.gcn2(self.A.mm(X))
|
||||
return X
|
||||
```
|
||||
|
||||
### 测试方法
|
||||
|
||||
参考 dgl 的[使用教程](https://docs.dgl.ai/tutorials/basics/1_first.html)
|
||||
233
2023旧版内容/4.人工智能/4.6数据分析.md
Normal file
233
2023旧版内容/4.人工智能/4.6数据分析.md
Normal file
@@ -0,0 +1,233 @@
|
||||
# 数据科学
|
||||
|
||||
author:zzm
|
||||
|
||||
## 本章内容会从一个小故事开始
|
||||
|
||||
讲讲某个人在大一的悲惨经历来为大家串起来一个精简的数据科学工作包括了哪些步骤，同时给各位介绍一些优质的教程
|
||||
|
||||
同时，这章内容将详细阐述[与人合作的生死疲劳](../1.杭电生存指南/1.5小组作业避雷指南.md)
|
||||
|
||||
## 悲惨世界
|
||||
|
||||
::: danger 若有雷同，纯属瞎编~~根据真实事件改编
|
||||
|
||||
后人哀之而不鉴之，亦使后人而复哀后人也！
|
||||
|
||||
请欣赏小故事的同时，根据自己的需求选择自己想学的教程
|
||||
|
||||
:::
|
||||
|
||||
### Day1
|
||||
|
||||
你是一个可怜的大一学生，学校的短学期的第一天，你的心情非常好，因为要放寒假了，只要再坚持过这个短学期，你的快乐假期要来了！什么是短学期？不知道啊，也没听学长说过，好像是新研究出来的一个课程，去试试看吧。
|
||||
|
||||
当你快乐的走进教室，老师告诉你：“你们看看 PPT 上的任务，自由选择啊！”
|
||||
|
||||
你看到 PPT 上赫然印着
|
||||
::: tip 任务目标
|
||||
基础系统：
|
||||
|
||||
1. 淘宝客户价值分析系统，实现爬取数据，数据处理，数据分析。
|
||||
2. 二手房数据分析预测系统，实现爬取数据，数据分析，绘制图表。
|
||||
3. 智能停车场运营分析系统，实现爬取数据，数据分析，绘制图表。
|
||||
4. 影视作品分析系统，实现爬取数据，数据分析，绘制图表。
|
||||
|
||||
升级系统：
|
||||
|
||||
1. 利用爬虫理论，实现 12306 抢票小助手系统。
|
||||
2. 利用数据分析方法，实现淘宝商品排行分析。
|
||||
3. 利用爬虫原理，爬 Google 搜索引擎分析。”
|
||||
要求实现三项以上的功能模块或三种以上的特征分析或提取。
|
||||
|
||||
:::
|
||||
|
||||
心中一惊，暗道不妙，这都什么玩意，怎么还有爬谷歌，淘宝和抢 12306 的票啊，这 tm 不是犯法的么！这我要能做出来我还上什么大一的学啊！🥺🥺🥺🥺
|
||||
|
||||
老师紧接着补充“十个人一组啊！一周内做完，数据自己想办法，第三天就要检查你们的进度了！”
|
||||
|
||||
这是你倒是暗暗松了一口气，好像十个人一起干也没有那么复杂！😎（这时正是愚昧之峰，错误的认为工作总量就是工作量除以十）迅速的组好队之后，你问了问大伙的进度，what？大伙都没有 python 基础，只有我有？幸好学了 hdu-wiki 和 datawhale 的[聪明方法学 python](https://github.com/datawhalechina/learn-python-the-smart-way)
|
||||
|
||||
那就把教程分给大伙吧，我们选一个最简单的，二手房数据的分析系统好了！
|
||||
|
||||
第一天选好题了，又是大下午的，摆了摆了，你开心的打开电脑，打开了 steam，开摆！
|
||||
|
||||
day 1 End!🤣
|
||||
|
||||
### Day 2
|
||||
|
||||
昨天真是美滋滋的一天，玩了一晚上的你有点头昏脑涨，今天就开始干活好了，反正一周时间呢，比期末复习周可长太多了，就做这么个玩意我还能做不出来吗？
|
||||
|
||||
虽然你没有学过爬虫，但是你很幸运的找到了 github 上一个现成的爬虫代码，虽然费了一翻力气，但是仍然躲过了某房价网站的爬虫，他成功爬下来了，我们就把他存在哪里呢？~~（爬虫待补充）
|
||||
|
||||
先试试 excel 好了，毕竟这是大家最耳熟能详的存表格的方法，但是你貌似没有深入了解过他，打开了 datawhale 的[free-excel](https://github.com/datawhalechina/free-excel)，你才惊讶的发现，wow，原来他有这么多牛逼的功能啊！它除了可以将房价统计，找到它的平均价格，算出他的最高价格之类以外，竟然也可以把他可视化！甚至它还可以对房价进行多元分析！根据房屋数量面积地段等等因素帮你预测房价，甚至可以自动帮你检索和去除重复数据，实在是太好用啦！
|
||||
|
||||
当然，这只是一个理想状态，残酷的现实很快给你当头一棒！当你试着多爬点不同城市数据的时候，他崩了！这么脆弱的吗？！干点活就喊累的吗？！😨
|
||||
|
||||
当然你想起了有一个备用方案，好像你可以用数据库去存储他！
|
||||
|
||||
之前好像看到有一个教程叫做[wonderful-sql](https://github.com/datawhalechina/wonderful-sql?from=from_parent_mindnote)
|
||||
|
||||
他提到“随着社会的快速发展，各类企业数字化转型迫在眉睫，SQL 应用能力日趋重要。在诸多领域中 SQL 应用广泛，数据分析、开发、测试、维护、产品经理等都有可能会用到 SQL，而在学校里系统性讲授 SQL 的课程较少，但是面试及日常工作中却经常会涉及到 SQL。”
|
||||
|
||||
确实学校没有教过，但是幸好你有教程，折腾了一翻之后，你发现你对数据库有了更深的理解，他帮助了我们在容纳大量的多种不同的数据形式的时候不用专门去考虑怎么设计一个数据结构而是规划了一定的存储方法后全部塞给他，完全不用考虑具体的物理性的以及性能问题存储模式，并且他很多高级的功能可以帮助你便捷的把数据组织成一般情况下难以到达的形式，他的底层设计被严格的包装起来让你在进行数据增删改查的时候都又快又好。
|
||||
|
||||
并且它可以非常方便的存一些 excel 不好存的所谓的非结构化的数据，比如说图像等等，并且他不会动不动就喊累！处理几十万条也是一下子！
|
||||
|
||||
当然同时你也了解到，你所用的是关系型数据库，是老东西了，目前还有很多较为前沿的非关系型数据库，例如 MongoDB(这玩意什么都能存，比如说地图)，Neo4j（像一张蜘蛛网一样的结构，图）等等，他们不用固定的表来存储，可以用图存或者键值对进行存储，听起来好像非常的高级，不过你暂时用不到，数据搞都搞下来了，量也够了，是时候看看队友做到哪了？说不定后面你都不用做了，已经做的够多够累的了！
|
||||
|
||||
什么？！刚开始学 python?!woc! 完蛋，你逐渐来到了绝望之谷，唉！明天继续做吧！看来休息不了了。
|
||||
day 2 End 😔!
|
||||
|
||||
### Day 3
|
||||
|
||||
God!No! 昨天已经够累的了，今天老师还要讲课，还要早起！你期待着老师可以降低要求，可是当老师托起长音，讲起了他知道了学生的累，所以今天决定开始讲课了！（现在讲有毛用啊，你明天就要验收我们的进度了！）
|
||||
|
||||
而他却慢悠悠的开始讲 python 的历史，把这点内容讲了足足两节课，你终于绷不住了，本来时间就不够，他竟然又浪费了你足足一早上的时间！这也太该死了！🤬
|
||||
|
||||
你回到了寝室，准备今天争取数据分析完就直接交上去好了！
|
||||
|
||||
可是你发现了一个让你震惊的噩耗！你找到的数据，是混乱的！😱
|
||||
|
||||
这个野鸡房价网站每个城市的排版不一样，你爬虫爬取的完全是按照顺序标的，也就是说你爬取的所有房价信息处于混沌状态！完全就相当于给每个房子爬了一段句子的描述！
|
||||
|
||||
没有办法了，看来今天有的折腾了，你找到了一个叫 pandas（熊猫？）的东西，找到了这个教程[Joyful-Pandas](https://github.com/datawhalechina/joyful-pandas)，开始了一天的学习！
|
||||
|
||||
你了解到 pandas 是一个开源的 Python 数据处理库，提供了高性能、易用、灵活和丰富的数据结构，可以帮助用户轻松地完成数据处理、清洗、分析和建模等任务。你使用了 DataFrame 来装载二维表格对象。
|
||||
|
||||
用一些关键词来提取数据中隐藏的信息，例如提取“平米”前面的数字放到‘area'列，提取房价到'price’列，提取位置到'locate'里面，当然你也遇到了可怕的 bug，提取所有“室”和“厅”前面的数字，他总是告诉你有 bug，全部输出之后才发现你提取到了“地下室”结果他没法识别到数字所以炸了！
|
||||
|
||||
将数据勉强弄得有序之后，你提取了平均数填充到缺失数据的房屋里面，将一些处理不了的删掉。
|
||||
|
||||
当然，你也额外了解到 pandas 这只可爱的小熊猫还有非常多强大的功能，例如数据可视化，例如分类数据，甚至可以让房屋按照时序排列，但是你实在不想动了！
|
||||
|
||||
不论怎么说，你勉强有了一份看得过去的数据，你看了看表，已经晚上十一点半了，今天实在是身心俱疲！
|
||||
|
||||
问问队友吧，什么，他们怎么还是在 python 语法？！你就像进了米奇不妙屋~队友在说
|
||||
|
||||
~~“嘿~你呀瞅什么呢~是我！你爹~”~~
|
||||
|
||||
此时你像一头挨了锤的老驴，曾经的你有好多奢望，你想要 GPA，想要老师的认同，甚至想要摸一摸水里忽明忽暗的🐠，可是一切都随着你的 hardworking 变成了泡影。
|
||||
|
||||
可是步步逼近的截止日期不允许你有太多的 emo 时间，说好的七天时间，最后一天就剩下展示了！也就是说实际上只有 6 天的开发时间，也就是说你必须得挑起大梁了
|
||||
|
||||
> 世界上只有一种真正的英雄主义，那就是看清生活的真相之后，依然热爱生活
|
||||
|
||||
好的，你真不愧是一个真正的英雄！
|
||||
|
||||
day 3 end!👿 👹 👺 🤡
|
||||
|
||||
### Day 4
|
||||
|
||||
老师在验收的时候认为你什么工作也没做，他认为一份数据实在是太单薄了，特别是被你疯狂结构优化后的数据已经没几个特征了，让你去做点看得到的东西，不然就要让你不及格了，你的心里很难过，你想到也许你需要一些更好看的东西。数据可视化你在昨天的 pandas 看到过，可是你并没有详细了解，你觉得 pandas 已经在昨天把你狠狠的暴捶一顿了，并且老师想要更好看的图。
|
||||
|
||||
于是你考虑 pandas 配合 Matplotlib 画一些简单的图（Matplotlib 的缺点是它的绘图语法比较繁琐，需要编写较多的代码才能得到漂亮的图形。）
|
||||
|
||||
加上 Plotly 绘制一些复杂的图，让你的图有着更漂亮的交互效果，然后加上看起来很牛逼的英语描述
|
||||
|
||||
你找到了下面的教程：
|
||||
|
||||
[matplotlib 奇遇记文字教程](https://github.com/datawhalechina/fantastic-matplotlib)
|
||||
|
||||
[极好的 Plotly 文字教程：](https://github.com/datawhalechina/wow-plotly)
|
||||
[视频教程](https://www.bilibili.com/video/BV1Df4y1A7aR)
|
||||
|
||||
🤗
|
||||
你绘制了柱状图，散点图，箱线图，甚至花了点钱找了外包去做了一个前端的热力图，虽然你爬的城市和数据不够覆盖全国，但是可以数据不够前端来凑啊！把城市的热量铺洒在全国。
|
||||
|
||||
这时你认为你的任务已经完成了！于是早早就心满意足的早早睡着了🍻 🥂。最近真的太累了，天天一两点睡，早上惊醒，做梦都是在爬数据分析数据！太可怕了！
|
||||
|
||||
在梦里，你好像看到了美好的假期时光。 😪
|
||||
|
||||
day 4 end!~🤤
|
||||
|
||||
### Day 5
|
||||
|
||||
你睡得很死，因为你已经你做完了所有的东西，第二天只要美美的验收结束，买了机票就可以回家了，可是老师仍然制止了你，跟你说如果你今晚走了就给你挂科，因为你没有用机器学习来分析他！
|
||||
|
||||
可是机票今晚就要起飞了啊！😰你已经要气疯了，想和老师据理力争，但是又害怕这么一个课被打上不及格的分数，这实在是太难受了！
|
||||
|
||||
终归你还是在老师的逼迫下，改签了机票，好吧，多少得加点功能了！呜呜呜~🤢 🤮
|
||||
|
||||
可是你并不完全会机器学习的算法，可怜的大一本科生的你没有学信息论也没有学最优化理论，很多算法你完全不懂其理论知识！听说西瓜书很好，可是你在图书馆借到了西瓜书之后根本看不懂！
|
||||
|
||||
于是你找到了吃瓜教程，也就是所谓市面上的南瓜书的[文字教程](https://github.com/datawhalechina/pumpkin-book)
|
||||
|
||||
你也找到了西瓜书的代码实践[文字教程](https://github.com/datawhalechina/machine-learning-toy-code)
|
||||
|
||||
你对着他啃了半天，觉得很多东西你都能看懂了，你脑子里已经有了很多思路，你想按使用高级的机器学习的算法！
|
||||
|
||||
但是！时间还是太紧张了！你没有办法从头开始实现了！
|
||||
|
||||
你想尝试[pytorch 文字教程](https://github.com/datawhalechina/thorough-pytorch)，但是时间也不够让你去重整数据去训练了。你随便塞在线性层里的数据梯度直接爆炸，你这时候还不知道归一化的重要性，紧张之下把几万几十万的房价往里面塞，结果结果烂成💩了，并且你那薄如蝉翼的基础知识并不够让你去解决这些个 bug，只能疯狂的瞎调参数，可是结果往往不如人意~
|
||||
|
||||
时间来到了晚上八点，明天就要最后验收了，走投无路的你把目光看向了远在几十千米外已经入职了的大哥，晚上跟他打电话哭诉你最近的遭遇，你实在搞不懂，为什么十二生肖大伙都属虎，就你属驴。
|
||||
|
||||
大哥嘎嘎猛，连夜打车过来，你在因疫情封校的最后两个小时跑出了学校，和大哥一起租了个酒店，通宵奋战，他采取了更多更为优雅的特征工程和模型调参的方式，让模型优雅的收敛到了一定程度，再用春秋笔法进行汇总，在半夜两点半，终于将内容搞定了😭
|
||||
|
||||
终于你可以睡个好觉了~
|
||||
|
||||
day 5 end!😍 🥰 😘
|
||||
|
||||
### Day 6
|
||||
|
||||
验收日，老师端坐在底下，宛如一尊大佛，提出了一系列无关紧要的问题，比如问“我们能不能拿这个程序给老年人查资料？？？”
|
||||
|
||||
等等问题和技术一点关系都没有！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
|
||||
|
||||
😣 😖 😫 😩
|
||||
|
||||
极度悲愤之下，当天晚上，你火速提着行李，离开了这伤心之地~~~~~~~~~~~~~~~~~
|
||||
|
||||
The End~~~~~~~~~~
|
||||
|
||||
## 事后总结
|
||||
|
||||
你在那个暑假详细了解和学习一下数据科学竞赛，发现他的含金量在职场领域有时候相当高，并且对提升自身的实力也有相当大的帮助！
|
||||
|
||||
[数据竞赛 Baseline & Topline 分享](https://github.com/datawhalechina/competition-baseline)
|
||||
|
||||
你还发现了之前从来没有注意到的 kaggle 平台以及一些很棒的综合实践项目！
|
||||
|
||||
例如[根据贷款申请人的数据信息预测其是否有违约的可能](https://github.com/datawhalechina/team-learning-data-mining/tree/master/FinancialRiskControl)
|
||||
|
||||
[根据汽车类型等信息预测二手汽车的交易价格](https://github.com/datawhalechina/team-learning-data-mining/tree/master/SecondHandCarPriceForecast)
|
||||
|
||||
例如：[使用公开的 arXiv 论文完成对应的数据分析操作](https://github.com/datawhalechina/team-learning-data-mining/tree/master/AcademicTrends)
|
||||
|
||||
想到如果你早做准备，没有荒废大一的时光，也许你不但能圆满的通过这次课程，也可以开辟更为广阔的新世界了吧~
|
||||
|
||||
同时，你也初窥了数学＋机器学习世界的瑰丽传奇，你想更为深入的对其有一个了解，并且做出点东西，希望对你日后的学习生活有个见证~~
|
||||
|
||||
少年将去开启新的传奇~~~~~
|
||||
|
||||
::: danger 再次警告，本章内容有很多瞎编的内容，不要全信
|
||||
|
||||
比如说一天学完 pandas，一天学完 sql 之类的都是很不现实的！希望大家注意！
|
||||
|
||||
当然你也可以在需要用的时候再研究，也来得及，就是很累
|
||||
|
||||
不要打击到大家的自信心！
|
||||
:::
|
||||
|
||||
## 补充内容：下个定义
|
||||
|
||||
数据分析是独立于开发和算法岗的另一个方向，它主要是通过**应用**机器学习和深度学习的**已有算法**来分析现实问题的一个方向
|
||||
|
||||
我们常说：数据是客观的，但是解读数据的人是主观的。
|
||||
|
||||
数据这门科学就像中西医混合的一门医学，既要有西医的理论、分析模型以及实验，又需要有中医的望闻问切这些个人经验。
|
||||
|
||||
> 这世界缺的真不是算法和技术，而是能用算法、技术解决实际问题的人
|
||||
|
||||
## 什么是数据科学
|
||||
|
||||
数据科学是当今计算机和互联网领域最热门的话题之一。直到今天，人们已经从应用程序和系统中收集了相当大量的数据，现在是分析它们的时候了。从数据中产生建议并创建对未来的预测。[在这个网站中](https://www.quora.com/Data-Science/What-is-data-science)，您可以找到对于数据科学的更为精确的定义。
|
||||
|
||||
同时，我向各位推荐一个非常有趣的科普视频想你讲解数据分析师到底在做什么：[怎么会有这么性感的职业吶？](https://www.bilibili.com/video/BV1ZW4y1x7UU)
|
||||
|
||||
<Bilibili bvid='BV1ZW4y1x7UU'/>
|
||||
|
||||
## Datawhale 的生态体系
|
||||
|
||||
在与 Datawhale 开源委员会的负责人文睿进行一翻畅谈之后。zzm 受震惊于其理念以及已经构建的较为完善的体系架构，毅然决然的删除了本章和其广泛的体系比起来相形见绌的内容。为了更大伙更好的阅读以及学习体验，我们决定在本章内容引入了[datawhale 人工智能培养方案数据分析体系](https://datawhale.feishu.cn/docs/doccn0AOicI3LJ8RwhY0cuDPSOc#)，希望各位站在巨人的肩膀上，争取更进一步的去完善它。
|
||||
152
2023旧版内容/4.人工智能/4.7如何做研究.md
Normal file
152
2023旧版内容/4.人工智能/4.7如何做研究.md
Normal file
@@ -0,0 +1,152 @@
|
||||
# 如何做研究
|
||||
|
||||
## 0. 讲在前面
|
||||
|
||||
Author：任浩帆
|
||||
|
||||
Email: yqykrhf@163.com
|
||||
术语介绍的补充：Spy
|
||||
|
||||
仅供参考，如有不足，不吝赐教。
|
||||
|
||||
## 术语的介绍
|
||||
|
||||
**Benchmark：**评测的基准。通常会是一些公开的数据集。
|
||||
|
||||
**Baseline:** 基准，一般指的是一个现有的工作。
|
||||
|
||||
**SOTA **(state-of-art): 截止目前，指标最好。
|
||||
|
||||
举个例子：
|
||||
|
||||
我们选取 XXX-Net 作为我们的 Baseline，在加入我们设计的注意力机制的模块，在 KITTI 这个 Benchmark 上性能达到了 SOTA。
|
||||
|
||||
**Backbone:**
|
||||
|
||||
这个单词原意指的是人的脊梁骨，后来引申为支柱，核心的意思。
|
||||
|
||||
在神经网络中，尤其是 CV 领域，一般先对图像进行特征提取（常见的有 vggnet，resnet，谷歌的 inception），这一部分是整个 CV 任务的根基，因为后续的下游任务都是基于提取出来的图像特征去做文章（比如分类，生成等等）。
|
||||
|
||||
所以将这一部分网络结构称为 backbone 十分形象，仿佛是一个人站起来的支柱。
|
||||
|
||||
**Solid**
|
||||
|
||||
一般是描述这个工作非常扎实。
|
||||
|
||||
这个工作很 solid。每一步都 make sense（合理）。没有特意为了刷 benchmark 上的指标，用一些 fancy trick（奇技淫巧）。
|
||||
|
||||
**Robust**
|
||||
|
||||
鲁棒性，是描述一个系统受到外界的干扰情况下，仍然能保持较好的性能。
|
||||
|
||||
举个例子：
|
||||
|
||||
我们的系统的图片加入大量的噪声，已经旋转平移缩放以后，仍然能正确的分类，这表明了我们的工作具有一定的鲁棒性。
|
||||
|
||||
## 坐而论道
|
||||
|
||||
### 2.1 研究是什么
|
||||
|
||||
从实际的几个例子讲起：
|
||||
|
||||
1. 某学生，被老师分配了一个课题的名字：《语义分割》。之后开始看相关的论文，了解到有实时语义分割，视频语义分割，跨模态语义分割等等子任务或者交叉任务，然后跟导师开始汇报自己的一些感想，最后在老师的建议之下拟定了具体的课题，开始思考解决方案。
|
||||
2. 某学生，被老师分配了一个课题的名字：《存在遮挡情况下的单目人体重建》 。之后这个学生对这个问题提出了有效的解决方案。
|
||||
3. 某同学在 waymo（Google 自动驾驶子公司）实习，发现没有用神经网络来直接处理点云的工作。于是决定做一个神经网络能够直接输入点云，经过几番尝试以后，提出了《第一个能直接处理点云的网络》。
|
||||
4. 某高校的本科生在 lcw 下的指导下做科研的流程：老师直接给给一个 basic idea，然后让本科做实验，在这个工程中非常有针对性的指导。
|
||||
|
||||
例 1 是在给定一个大题目的基础下，去阅读论文寻找小题目。
|
||||
|
||||
例 2 是在给定一个具体细致的题目基础下，直接去想如何解决。
|
||||
|
||||
例 3 是在实际工作的情况下发现了一个非常有意义的问题，然后思考如何解决。
|
||||
|
||||
例 4 是直接给定一个 idea，去实现，研究者所需要完成的几乎是工程实践。
|
||||
|
||||
理想情况下，研究流程应该包含：
|
||||
|
||||
Step 1. 提出问题
|
||||
|
||||
Step 2. 提出解决方案
|
||||
|
||||
Step 3. 验证解决方案的有效性。
|
||||
|
||||
有些问题是一直存在，但没有彻底解决的。这一类的问题通常，就不存在 Step 1。从事这一课题的研究者经常会在 2，3 之间来回反复。
|
||||
|
||||
### 2.2 如何做研究
|
||||
|
||||
从上一小节的几个例子当中，其实不同的人做研究所需要完成的工作是完全不一样的。很多时候只需要做 step 3 即可，从功利的角度来讲这是性价比最高的。
|
||||
|
||||
如果我们是一个合格的博士或者我们致力于如此，那么首先的第一步要找到一个好的问题，这是一个非常重要的开始，**一个好的问题往往意味着研究已经成功了一半。 **什么是一个好的问题？它可能会有以下几个特点：
|
||||
|
||||
1. 理论上能实现某种意义上的统一，从而使得问题的描述变得非常优雅。比如 [DepthAwareCNN](https://arxiv.org/abs/1803.06791)
|
||||
2. 对于之后的工作非常具有启发的作用，甚至达到某种意义的纠偏作用。比如 [OccuSeg](https://arxiv.org/abs/2003.06537)
|
||||
3. 本身足够 solid，可以作为 meta algorithm。比如 Mask-RCNN
|
||||
4. 是一个大家没有引起足够重视，却非常棘手且非常迫切的问题。比如相机快速运动下的重建，[MBA-VO](https://openaccess.thecvf.com/content/ICCV2021/papers/Liu_MBA-VO_Motion_Blur_Aware_Visual_Odometry_ICCV_2021_paper.pdf)
|
||||
|
||||
#### 2.2.1 如何去找一个好的问题
|
||||
|
||||
如何确保自己选的问题是一个好的问题？这需要和指导老师及时的反馈。如果指导老师不给力，那么一些方法仅供参考。
|
||||
|
||||
1. 自己和工业界的一些人去交流与沟通，看看实际落地的痛点是什么？面对这些痛点，已有的研究方法能否解决，是否有一些现有的 benchmark 或者容易制作的 benchmark 来做为评价标准。
|
||||
2. 做加法。举个例子：图片可以做语义分割。那么图片 + 深度图如何更好的做语义分割。图片 + 文字描述的做语义分割。现在的语义分割的标注都是 0，1，2，3 这些数字，然后每一个数字对应一个实际的类别，这个对应表是认为规定的。如果我把 0，1 的对应关系换掉。重新训练以后就，网络的性能是否会影响？
|
||||
3. 做减法。对于点云的语义分割的标注，通过是非常费时费力的。那么对于点云来说，少量的标注是否是可行的？比如只标注百分之 10 的点。
|
||||
|
||||
以上是一些技巧，把输入调整一下，约束去掉一些，就会有很多新的问题。这个过程通常被叫做**“调研”**
|
||||
|
||||
这个过程在是一个相对比较痛苦的过程，因为调研的过程中你会发现很多问题，想到很多所谓创新的解决方法，但是实际上你会发现你的解决方法已经有很多人做过了。这一阶段调整心态很重要，切忌急于求成。
|
||||
|
||||
#### 2.2.2 如果提出解决方法
|
||||
|
||||
这个阶段需要百折不挠，小步快跑了。一下是有一些可能有帮助的技巧：
|
||||
|
||||
1. 多读本领域的论文。（说起来非常玄妙，会在如何读论文部分详细解释）
|
||||
2. 读一些基础，跨领域的论文。把其他领域的方法搬过来直接用。直接用通常情况下会存在一些问题，那么需要针对性的做一些改进。
|
||||
3. 从历史出发。将你面对的问题抽象成数学问题，这个数学问题可能过去很多人都遇到过，去看一看他们是如何解决的，从中获取一些灵感。
|
||||
|
||||
#### 2.2.3 如果做实验
|
||||
|
||||
做实验的目的是为了快速的验证想法的正确性。以下两个东西最好要有
|
||||
|
||||
1. 版本控制
|
||||
2. 日志系统
|
||||
|
||||
剩下就是一些工程习惯的问题，比如出现错误用 `std::cerr` 而不是 `std::cout`。这是一个需要实践积累的部分，与做研究有些脱节，之后有时间会在其他小节做一些补充。
|
||||
|
||||
## 快速出成果的捷径与方法
|
||||
|
||||
如何快速的出成果，不管别人如何帮你，前提是你自己要足够的强。不能存在 **“靠别人” **的想法。
|
||||
|
||||
对于一个博士生来讲，出成果保毕业，那么可能要对学术的进展要敏感，比如 Nerf 八月份刚出来的时候，如果你非常敏锐的意识到这个工作的基础性和重要性。那么你稍微思考一两个月，总是能有一些创新的 ieda 产生的。所以这个**timing 和 senstive**就非常重要，当然导师是不是审稿人可能更重要。
|
||||
|
||||
对于一个本科生来讲，当然是跟着指导老师的脚步去做。但是如果指导老师只是把你当成一个工具人，一直打杂货的话。你想发论文，一种所谓的捷径是 A+B。就是把一个方法直接拿过来用在另一个地方，大概率这样会有一些问题，那么你就可以针对性的改进，如何针对性的改进？不好的方式是 A+B 套娃，好一些的方式是分析这个不好的原因在哪里，现有的方法多大程度可以帮助解决这个问题，或者现有的方法解决不了这个问题，但是其中的一个模块是否是可以参考的。
|
||||
|
||||
### 3.2 学习别人是如何改进网络的（Beta）
|
||||
|
||||
自 UNet 提出后就有许多的魔改版本，如 UNet++, U2Net, 而这些 UNet 的性能也十分优异。
|
||||
|
||||
可以参考 UNet 的发展历程，去学习如何在前人的工作上加以改进和提升。
|
||||
|
||||
注：通过历史的演变来学习是非常有必要的，但是你需要注意一点的是，深度学习很多时候会出现一些情况：
|
||||
|
||||
1. 你认为你提出的改进方法是有效的，但是实际是不 OK 的
|
||||
2. 你认为你提出的方法可能有效，实际上也确实有效。然而你不能以令人信服的方式说明这为什么有效。
|
||||
|
||||
举个例子 ResNet 为什么有效。“因为网络越深，可以拟合的函数空间就会复杂，但是越深网络效果反而变差。那么从一个角度来思考：网络至少某一层 i 开始到最后一层 k，如果学习到的函数是 f(x)=x 的恒等映射，那么网络变深以后至少输出是和 i-1 层的是一模一样的，从而网络变深可能不一定会变好，但是至少不会变差才对。”看起来很有道理，然后 CVPR2021 分享会，ResNet 的作者之一，xiangyu zhang 说“当时也完全不能使人很信服的解释为什么 ResNet 就一定效果好，感觉更像是基于一些灵感，得到了一个很棒的东西，更像是一个工程化的问题，而不是一个研究。但我们可以先告诉别人这个是非常有效的，至于为什么有效，可能需要其他人来解决。”
|
||||
|
||||
再举一个例子 BN(Batch normalization) 为什么有效，你去看 BN 的原论文和之后关于 BN 为什么有效的研究，会发现原论文认为有效的原因是不太能让人信服的。但这不妨碍 BN 有效，而且非常快的推广起来。
|
||||
|
||||
其实这件事可以类比于中医，做研究就好比要提出一套理论，但是我不知怎得忽然发现有一个方子经过测试非常有效，但是我确实不能给出一个很好的理论解释说明这个房子为什么有效。但是我尽快把这个方子告诉大家，这同样是非常有意义的。
|
||||
|
||||
举这个两个例子是为了说明，类似 ResNet 这种拍一拍脑袋就想出的 idea，一天可能能想出十几个，但是最后做出来，并且真正 work 的非常少。这里面就存在一个大浪淘沙的过程，可能我们看到的经典的网络，比如 Unet 就是拍拍脑袋，迅速做实验出来的。我认为这种思考方式仅仅值得参考，并不值得效仿。现在早已经不是 5 年前那样，却设计各种 fancy 的网络结构去发论文的年代了。
|
||||
|
||||
那么我们应该如何对待神经网络？（之后再写）
|
||||
|
||||
但我想 Charles qi 的思考方式是值得借鉴的。论文的顺序是
|
||||
|
||||
PointNet------>PointNet++------>PointFrustum-------->VoteNet
|
||||
|
||||
有对应的中文 Talk。但我建议先去读论文，之后再看 talk。
|
||||
|
||||
我们不应该无脑的认为我们给什么数据，网络就会得到好的结果。说什么高层，底层特征云云。
|
||||
|
||||
思考问题可以先从类似哲学的 high level 层面开始，但是具体操作一定要 make sense，不然只是一个空想家。
|
||||
65
2023旧版内容/4.人工智能/4.8科研论文写作.md
Normal file
65
2023旧版内容/4.人工智能/4.8科研论文写作.md
Normal file
@@ -0,0 +1,65 @@
|
||||
# 科研论文写作
|
||||
|
||||
> author：晓宇
|
||||
|
||||
序言：写作，一门需要反馈才能学习的科目，无论一个人有多么厉害，第一篇论文的写作，总是那么不尽人意。
|
||||
|
||||
其原因在于，首先学术性写作是一门需要刻意训练的科目，其次学术写作训练的反馈成本是巨大的，很难落实到每一个人身上，这并不是一门看看网课就能学会的技能。
|
||||
|
||||
所以开设本栏目分享一些感悟与资料。
|
||||
|
||||
论文写作方法论简述：
|
||||
|
||||
我分为两大块：先想清楚你干了什么，在训练好你表达的规范性
|
||||
|
||||
<font color=green>大白话 -> 提取后的逻辑链条</font> -> <font color=red>科研写作 -> 英文翻译</font>
|
||||
|
||||
**干了什么：**
|
||||
|
||||
1. 如果没有想清楚要做的是什么，要写什么，可以先用大白话，在草稿上写，有利于理清思路，抽丝剥茧
|
||||
|
||||
失败案例：一上来直接英文[ ] ' '写作，一会 we want，一会 80 个词语的长难句，思路英语都不清晰
|
||||
|
||||
2. 先列出 Outline 每一个科研 section 你打算做什么，尝试去回答问题
|
||||
|
||||
::: warning 📌
|
||||
Introduction(Longer version of theAbstract,i.e.of the entire paper):
|
||||
|
||||
X: What are we trying to do and why is it relevant?
|
||||
|
||||
Y: Why is this hard?
|
||||
|
||||
Z: How do we solve it (i.e. ourcontribution!)
|
||||
|
||||
1: How do we verify that we solved it:
|
||||
|
||||
1a) Experimental results
|
||||
|
||||
1b) Theory Extra space? Future work!
|
||||
|
||||
Extra points for having Figure 1
|
||||
|
||||
on the first page
|
||||
|
||||
:::
|
||||
|
||||
之所以要用大白话是因为基础的不足，如果有一定功底的人，可能先天写出来文字自带规范性，所以仅供大家参考）
|
||||
|
||||
**表达规范性：**
|
||||
|
||||
此处的方法论为一句话，则是从模仿到超越的浑然天成。
|
||||
|
||||
1. 但凡是写作，原理无非是学习表达各种逻辑的常用性词语，要表达转折，对比，强调要是用什么词，使用什么句式，在学习的过程中，先是看优秀论文一句话表达的逻辑，然后抽丝剥茧，去掉他的主要内容填入自己的即可。
|
||||
|
||||
2. 迭代式写作，尝试多次更改写作的内容，优秀的作品都是改出来的，在把一部分的意思表达清晰知识
|
||||
|
||||
上述内容是写作的怎么去写，而下面则是内容层面，什么样的文章算是一篇好的文章
|
||||
|
||||
::: warning 📌
|
||||
C 会文章与 A 会文章的区别认知：
|
||||
|
||||
(1).C 是对于相关工作一个是罗列，A 是整理相关工作的脉络和方法类别，以及方法缺陷。
|
||||
|
||||
(2).对于设计的方法，C 会只是说明我们比另外几个模型好，并不能从原理层面深入分析为什么比别人好，而 A 会则是能够说明每一部设计对模型的增量效果，以及为什么要做这一步。
|
||||
|
||||
:::
|
||||
984
2023旧版内容/4.人工智能/4.9从 AI 到 智能系统 —— 从 LLMs 到 Agents.md
Normal file
984
2023旧版内容/4.人工智能/4.9从 AI 到 智能系统 —— 从 LLMs 到 Agents.md
Normal file
@@ -0,0 +1,984 @@
|
||||
# 从 AI 到 智能系统 —— 从 LLMs 到 Agents
|
||||
|
||||
author:廖总
|
||||
|
||||
*Last revised 2023/04/18*
|
||||
|
||||
先声夺人：AI 时代最大的陷阱，就是盲目考察 AI 能为我们做什么，而不去考虑我们能为 AI 提供什么
|
||||
|
||||
## *免责声明*
|
||||
|
||||
本文纯文本量达 16k（我也不知道字数统计的 28k 是怎么来的），在这 游离散乱的主线 和 支离破碎的文字 中挣扎，可能浪费您生命中宝贵的十数分钟。
|
||||
|
||||
但如果您坚持尝试阅读，可能看到如下内容（假设没在其中绕晕的话）：
|
||||
|
||||
- 对大语言模型本质 以及 AI 时代人们生产创作本位 的讨论
|
||||
- 对大语言模型 上下文学习（In-Context Learning，ICL）和 思维链（Chain of Thought，COT）能力的几种通识性认知
|
||||
- 围绕 Prompt Decomposition 对使用大语言模型构建复杂应用的基础讨论
|
||||
- 对当前热门大模型 Agent 化框架（如 Generative Agents（即斯坦福 25 人小镇）、AutoGPT）其本质的讨论
|
||||
- 对使用大语言模型构建智能系统（基于全局工作空间意识理论）的初步讨论
|
||||
- 对使用大语言模型构建符合当今生产需求的智能系统的方法论讨论
|
||||
|
||||
（顺便，如果这篇的阅读体验有点一路偏题，请不要见怪，因为我也被这两周的新工作一路被带着跑）
|
||||
|
||||
（而这也导致了很多从最开始就埋好想说的东西最后懒得挖了，一路开摆）
|
||||
|
||||
（所以唯一有参考价值的思路主干就是下面这条总结）
|
||||
|
||||
该文章主要分为几个部分：
|
||||
|
||||
- 引言：讨论当前基于 AI 构建工程的背景痛点，连带着讨论 AI 智能如何区别于人类，人类仍应在生产中发挥的智能在何处。
|
||||
- LLMs 能力考察：讨论了大语言模型涌现的一系列基本能力，并讨论基于这些基本能力和工程化，大模型能做到哪一步
|
||||
- Decomp 方法论：将大语言模型微分化使用的方法论，以此展开对大语言模型的新认知
|
||||
- AI 作为智能系统：结合 Generative Agents、AutoGPT 两项工作讨论大语言模型本身的局限性，围绕人类认知模型的启发，讨论通过构建复杂系统使得 LLMs Agent 化的可能性
|
||||
- 予智能以信息：讨论基于 LLMs 构建能够充分帮助我们提升生产力的 AI 剩余的一切痛点。借以回到主题 —— 在 AI 时代，我们要打造什么样的生产和信息管理新范式（有一说，还是空口无凭）
|
||||
|
||||
总体而言，本文包括对 LLM 领域近一个月的最新几项工作（TaskMatrix、HuggingGPT、Generative Agents、AutoGPT）的讨论，并基于此考察一个真正可用的 AI 会以什么样的形态出现在我们面前。
|
||||
|
||||
而本文的核心观点如下：
|
||||
|
||||
- 大语言模型的实质是一个拥有智能计算能力的语言计算器
|
||||
- 我们不该将其当作独立的智能体看待，但能在其基础上通过构建系统创建智能 Agent
|
||||
- 为此，我们需要通过构建信息工程，让 AI 能够真正感知和改造世界，从而改变我们的生产进程
|
||||
|
||||
仅作展望。
|
||||
|
||||
## 引言
|
||||
|
||||
在开启正式讨论之前，我们希望从两个角度分别对 AI 进行讨论，从而夹逼出我们 从 AI 到 智能系统 的主题
|
||||
|
||||
- 形而上：我们尝试讨论 AI 智能的形态，进而发现 人类智能 的亮点
|
||||
- 形而下：我们尝试给出 AI 使用的样例，进而发掘 人工智能 的痛点
|
||||
|
||||
结合二者，我们待解释一种通过人类智能引领人工智能跨越痛点的可能性
|
||||
|
||||
> 形而上者谓之道，形而下者谓之器；<br/>化而裁之谓之变，推而行之谓之通，<br/>举而措之天下之民，谓之事业。
|
||||
|
||||
以前只知前边两句，现在才知精髓全在后者
|
||||
|
||||
### 形而下者器：LLMs + DB 的使用样例
|
||||
|
||||
（为了不让话题一开场就显得那么无聊，我们先来谈点有意思的例子）
|
||||
|
||||
前些时日，简单尝试构建了一个原型应用，通过 LLM 的文本信息整合能力和推理能力，实现文本到情感表现的映射，并依此实现了游戏对话生成流水线中动作配置的自动生成。
|
||||
|
||||
该应用的工程步骤分为以下几步：
|
||||
|
||||
- 基于现有任务演出动作库和动作采用样例，构建一个使用情感表达向量化索引动作的数据库
|
||||
- 向 LLMs 构建请求，通过向对话文本中添加情感动作标签丰富对话表现
|
||||
- 召回填充完毕后的对话样本，正则化收集对话情感标签，并对数据库进行索引
|
||||
- 召回数据库索引，逐句完成情感动作选择，并反解析至配档文件
|
||||
|
||||
这还是一个极简的工程原型，甚至 LLMs 在其中智能能力的发挥程度依旧存疑，但我主要还是希望其起到一个提醒作用：这彰显了所谓“信息”在实际开发、以及在后续将 AI 引入开发过程中的重要性。
|
||||
|
||||
我们要如何将原本储存于大脑的跨模态开发数据知识外化到一个可读的模态上并有效收集起来，同时要如何尽一切可能让 AI 能帮助我们挖掘数据中蕴含的价值，这是最核心的出发点。
|
||||
|
||||
而上面这一步，才是应对 LLM 的到来，在未来可期层面上最值得展开讨论的内容。
|
||||
|
||||
（后面会给出更多关联的讨论，这里就先不赘叙了）
|
||||
|
||||
### 形而上者道：对 LLM 既有智能能力及其局限性的讨论
|
||||
|
||||
这一节中，想讨论一下人工智能与人类智能的碰撞（）
|
||||
|
||||
从 Plugins 到 AI 解决问题的能力
|
||||
|
||||
此相关的讨论是在 ChatGPT Plugins 出现后展开的：
|
||||
|
||||
ChatGPT Plugins 在两篇论文两个角度的基础上，对 LLMs 的能力的能力进行延拓
|
||||
|
||||
- ToolFormer：让 AI 具有使用工具的能力
|
||||
- Decomp：让 AI 能逐层分解并完成任务
|
||||
|
||||
此相关的能力，其实在微软最新的一篇论文 TaskMatrix.AI 中被进一步阐述，其通过工程构建了一个 AI 能 自由取用 API 解决问题 的环境。
|
||||
|
||||
上述能力，在实质上进一步将 AI 解决问题的能力与人类进行了对齐：人们通过问题的拆解，将任务转化为自己能处理的多个步骤；并通过工具借自己所不能及之力，将问题最终解决。此二者无疑是人类解决问题最核心的步骤，即确定“做什么”和“怎么做”
|
||||
|
||||
而这也基本奠定了后续面向 AI 的工作流，其基本展开形态：
|
||||
|
||||
- 为 AI 提供接口，为 AI 拓展能力
|
||||
- 建模自身问题，促进有效生成
|
||||
|
||||
#### 从人工智能到人类智能
|
||||
|
||||
在上面的论断中，我们看似已经能将绝大多数智能能力出让予 AI 了，但我还想从另一角度对 AI 与人类的能力进行展开讨论：
|
||||
|
||||
即讨论一下人工智能的模型基础与其历程
|
||||
|
||||
- 人工智能：AI 的元智能能力
|
||||
- “人工”智能：辅佐 AI 实现的智能
|
||||
- 人类智能：于人类独一无二的东西
|
||||
|
||||
#### AI 智能的形态
|
||||
|
||||
大语言模型的原始目的是制造一个“压缩器”，设计者们希望他能有效地学习世界上所有信息，并对其进行通用的压缩。
|
||||
|
||||
在压缩的过程中，我们希望 AI 丢掉信息表征，并掌握知识背后的智能能力与推理能力，从而使得该“压缩器”能在所有的域上通用。
|
||||
|
||||
该说法是略显抽象的，但我们可以给出一个简单的现实例子对其进行描摹：
|
||||
|
||||
> “人总是要死的，苏格拉底也是人，所以苏格拉底是要死的”<br/>这是一个经典苏格拉底式的三段论，其中蕴含着人类对于演绎推理能力的智慧。<br/>假设上面的样本是 LLM 既有学习的，而这时来了一个新的样本：<br/>“人不吃饭会被饿死，我是人，所以我也是要恰饭的嘛”<br/>那么对于一个理想的智能压缩器而言，其可能发现新句与旧句之间的关联，并有效学习到了句子的表征形式及其背后的逻辑
|
||||
|
||||
$$
|
||||
S1=<(人，苏格拉底，死),三段式推理>
|
||||
$$
|
||||
|
||||
$$
|
||||
S2=<(人，我，恰饭),三段式推理>
|
||||
$$
|
||||
|
||||
> 而随后，压缩器会倾向于储存三段式推理这一智能结构，并在一定程度上丢弃后来的（人，我，恰饭）这一实体关系组，仅简单建模其间联系，并在生成时按需调整预测权重。
|
||||
|
||||
换言之，对 LLMs 而言，其对“智能”的敏感性要远高于“信息”
|
||||
|
||||
而这也带来了大语言模型训练的一些要点，通常对 LLM 而言，越是底层的训练越容易混入并给予 LLM“信息表征”，而越是高层的训练，越倾向于让 LLM 掌握新的“智能模式”
|
||||
|
||||
基于这一点，我们能对 LLM 的智能能力出发点进行简要推断：
|
||||
|
||||
LLM 的实质上还是通过“语言结构”对“外显人类智能”进行掌握，也正是相应的，引入了一系列问题
|
||||
|
||||
- AI 偏好学习智能，却不能很好的学习“信息型知识”
|
||||
- AI 只能掌握基于语言模态等可外显表征模态下的智能
|
||||
|
||||
进一步的，受限于自回归解码器结构的限制，AI 只能线性地回归文本序列，而无法构建自反馈。
|
||||
|
||||
而也正是这些固有缺陷，为人类的自我定位和进一步利用 AI 找到了立足点。
|
||||
|
||||
#### 赋能 AI 实现智能
|
||||
|
||||
作为上面一点的衍生，我们可以从大体两个角度去辅助 AI 智能的实现：
|
||||
|
||||
- 补全 AI 的智能能力
|
||||
|
||||
- 通过 Prompt Engineering 激发 AI 既有的能力
|
||||
- 通过启发方法构建 AI 的智能链条
|
||||
|
||||
- 内隐启发：通过复杂 Prompt 指导 AI 理解并完成任务
|
||||
ICL / COT Prompt
|
||||
- 外显启发：通过程序规范化 LLMs 完成任务所需流程
|
||||
ChatGPT Plugins / LangChain
|
||||
- 结构启发：通过构建工程结构支持 AI 自迭代分解并解决问题
|
||||
Decomp / TaskMatrix.AI / Hugging GPT
|
||||
- 附加 AI 的信息能力
|
||||
|
||||
- 通过知识工程和迭代调用等方法，为 AI 构造“记忆宫殿”
|
||||
|
||||
### 反思人类智能
|
||||
|
||||
作为人类而言，我们所拥有的智能能力显然也不是能被 AI 所覆盖的
|
||||
|
||||
首先，我们是“能动”与“体验”功能都脱离于我们狭义的智能而存在，而正是这些要素赋予了我们“主体性”
|
||||
|
||||
其次，也正是这些成分脱离于语言和表达而存在，使他们成为无法被显式学习的要素
|
||||
|
||||
- AI 不具备深层动机，它有的只是被语言所描述的目标
|
||||
- AI 不具备体验能力，因此它的创作是无反馈无迭代的
|
||||
|
||||
但是，相应的，不涉及上述内容的工作流程，在可预见的将来，会由 AI 全面参与。
|
||||
|
||||
而我们为了不被时代淘汰，要更加积极主动地将 AI 引进来。
|
||||
|
||||
### 化而裁之，推而行之：回到我们的主题
|
||||
|
||||
回顾一下上文，我们从应用和概念两个角度简要讨论了 AI 当前的使用情况，以及这些应用依托于什么
|
||||
|
||||
- 应用
|
||||
|
||||
- 通过 AI 实现了高度智能化的工作
|
||||
- 通过整理开发信息使得链路通顺
|
||||
- 概念
|
||||
|
||||
- 我们能通过外力引导赋予 AI 更强的解决问题的能力
|
||||
- AI 的核心能力是通用智能能力，对工作情境已高度可用
|
||||
- 人类能力的核心是能动和体验，而非浅显的智能
|
||||
- 展望
|
||||
|
||||
- 如何更好的赋能 AI
|
||||
- 如何更好的驾驭 AI
|
||||
|
||||
在唠嗑了这么多之后，我们终于能引入今天的主题了。
|
||||
|
||||
简而言之，我希望能追随着 AI 的发展，讨论是否能构建这样一个通用的 AI 框架，并将其引入工作生产的方方面面。希望能讨论及如何对生产信息进行有效的管理，也包括如何让我们更好调用 AI，如何让 AI 满足我们的生产需要。
|
||||
|
||||
## LLMs：生成原理及能力考察
|
||||
|
||||
相信无论是否专业，各位对 LLMs 的生成原理都有着一定的认知
|
||||
|
||||
简单来说，这就是一个单字接龙游戏，通过自回归地预测“下一个字”。在这个过程的训练中，LLMs 学习到了知识结构，乃至一系列更复杂的底层关联，成为了一种人类无法理解的智能体。
|
||||
|
||||
### In-Context Learning / Chain of Thought
|
||||
|
||||
经过人们对模型背后能力的不懈考察，发现了一系列亮点，其中最瞩目的还是两点：
|
||||
|
||||
ICL（In-Context Learning，上下文学习）和 COT（Chain of Thought，思维链）
|
||||
|
||||
可以说，绝大部分对于使用 LLMs 的启发，都源自这两个特性，简单说明此二者的表现
|
||||
|
||||
- ICL：上下文学习使得模型能从上下文中提供的样例/信息中学习，有效影响输出
|
||||
- COT：当模型在输出过程中写出思维过程时，能大幅提升输出效果
|
||||
|
||||
虽然学界对此没有太大的共识，但其原理无非在于给予 LLMs 更翔实的上下文，让输出与输入有着更紧密的关联与惯性。（从某种意义上来说，也可以将其认为是一种图灵机式的编程）
|
||||
|
||||
> ICL：<br/>
|
||||
|
||||
ICL 为输出增加惯性
|
||||
|
||||
> 可以简单认为，通过 ICL Prompt，能强化人类输入到机器输出的连贯性，借以提升输出的确定性。<br/>在经过“回答”的 finetune 之前，大模型的原始能力就是基于给定文本进行接龙，而 ICL 的引入则在“回答”这一前提条件下，降低了机器开始接龙这一步骤中的语义跨度，从而使得输出更加可控。<br/>
|
||||
|
||||
COT：<br/>
|
||||
|
||||
COT 为输出增加关联
|
||||
|
||||
> 同样可以简单认为，在引入 COT 后，AI 能将一次完整的输出看作两次分离的输出。<br/>对这两次输出而言，输入输出之间均有更高的关联度，避免了长程的抽象推理。对应短程推理的误差相对较小，最终使得积累误差也要更小。
|
||||
|
||||
进一步的，ICL 的发现，让 LLMs 能避免过多的传统 Finetune，轻易将能力运用在当前的情景中；COT 的发现，使得通过 LLMs 解决复杂问题成为可能。此二者的组合，为 LLMs 的通用能力打下了基础。
|
||||
|
||||
### TaskMatrix.AI
|
||||
|
||||
微软对 [TaskMatrix.AI](https://arxiv.org/abs/2303.16434) 这一项目的研究，很大程度上展示了 LLMs 基于 ICL 和 COT 所能展现的能力
|
||||
|
||||
（需要注意的是，TaskMatrix.AI 更大程度上是一个愿景向的调研案例，尚未正式落地生态）
|
||||
|
||||
|
||||
|
||||
TaskMatrix 的生态愿景
|
||||
|
||||
该文展现了一个生态愿景，即将 LLMs 作为终端，整合诸多 API 的能力，让 AI 运用在生活中的方方面面。
|
||||
|
||||
简单介绍的话，该框架主要分为四个模块
|
||||
|
||||
- Multimodal Conversational Foundation Model：通过与用户对话了解问题情景，并按需组装 API 实现操作，帮助用户解决问题
|
||||
- API Platform：构建统一的 API 制式，储存和管理平台内上所有 API 及其关联文档
|
||||
- API Selector：根据 MCFM 对用户问题的理解，向 MCFM 选择并推荐可用 API
|
||||
- API Executor：代替 MCFM 执行 API 脚本，并返回执行结果或中间信息
|
||||
|
||||
基于这一框架，微软于论文中实现了诸如图像编辑（基于我们摸不到的 GPT4）、论文写作、PPT 制作等工作。不难想象，微软即将推出的 Office 365 Copilot 也是基于相关技术及更深层的 API 定制实现的。
|
||||
|
||||
而与此相关的工作还可以关注 [HuggingGPT](https://arxiv.org/abs/2303.17580)，也是微软同期发布的论文，让 AI 能自主调用 Hugging Face 上的通用模型接口解决 AI 问题，从而实现一种“AGI”性能。
|
||||
|
||||
毫无疑问，我们通常会认为这种通过构造框架来大幅增强 LLMs 能力的可能性，是构建在既有 ICL 和 COT 的能力之上的，而我会围绕此二者重新进行简单展开
|
||||
|
||||
（当然，硬要说的话，对 ICL 和 COT 两种能力都有一个狭义与广义之争，但这不重要，因为我喜欢广义）
|
||||
|
||||
#### ICL for TaskMatrix
|
||||
|
||||
> 狭义的 ICL：从输入的既有样例中学习分布和规范<br/>广义的 ICL：有效的将输入内容有效运用到输出中
|
||||
|
||||
以 TaskMatrix 为例，在 API 组装阶段，其为 MCFM 提供的 ICL 内容即为 API 的文档
|
||||
|
||||
以论文为例，其提供的每个 API 文档分为如下部分
|
||||
|
||||
- API Name：用于描述该 API 名，亦即函数的调用名
|
||||
- Parameter List：用于描述 API 中的参数列表，介绍每个参数的特性及输入输出内容
|
||||
- API Description：API 描述，用于描述 API 功能，查找 API 时的核心依据
|
||||
- Usage Example：API 的调用方法样例
|
||||
- Composition Instruction：API 的使用贴士，如应该与其它什么 API 组合使用，是否需要手动释放等
|
||||
|
||||
> 样例：打开文件 API<br/>
|
||||
|
||||
基于此类文档内容和 ICL 的能力，LLMs 能从输入中习得调用 API 的方法，依此快速拓展了其横向能力
|
||||
|
||||
COT for TaskMatrix
|
||||
|
||||
> 狭义的 COT：通过 Lets Think Step by Step 诱导 LLMs 生成有效的解答中间步骤，辅助输出<br/>广义的 COT：通过 LLMs 的固有能力对问题进行拆解，构建解决问题的链条
|
||||
|
||||
通过此种模式，能极好的将问题分解至可被执行的原子形态
|
||||
|
||||
在 TaskMatirx 中，通过该模式，让 MCFM 将任务转化为待办大纲，并最终围绕大纲检索并组合 API，完成整体工作
|
||||
|
||||
> 样例：写论文<br/>构建完成工作大纲<br/>
|
||||
|
||||
TaskMatrix 自动围绕目标拆解任务
|
||||
|
||||
> 自动调用插件和组件<br/>
|
||||
|
||||
TaskMatrix 自动为任务创建 API 调用链
|
||||
|
||||
### 初步考察
|
||||
|
||||
基于上述的简单介绍，我们已经初步认识了 AI 在实际情景中的高度可用性
|
||||
|
||||
而接下来，我们继续从工程的角度揭示这种可用性的根源 —— 其源自一项通用的 Prompt 技术
|
||||
|
||||
## Prompt Decomposition：方法论
|
||||
|
||||
我们可以认为，TaskMatirx 的能力极大程度上依托于 Prompt Decomposition 的方法
|
||||
|
||||
而这实质上也是串联 LLM 能力与实际工程需求的必经之路
|
||||
|
||||
[[2210.02406] Decomposed Prompting: A Modular Approach for Solving Complex Tasks (](https://arxiv.org/abs/2210.02406)[arxiv.org](https://arxiv.org/abs/2210.02406)[)](https://arxiv.org/abs/2210.02406)
|
||||
|
||||
### 原始 Decomp
|
||||
|
||||
Decomp 的核心思想为将复杂问题通过 Prompt 技巧，将一个复杂的问题由 LLMs 自主划分为多个子任务。随后，我们通过 LLMs 完成多个任务，并将过程信息最终组合并输出理想的效果
|
||||
|
||||
|
||||
|
||||
几种 Prompt 方法图示
|
||||
|
||||
参考原始论文中阐述的方案，Decomp 方法区别于传统 Prompt 方法就在于，Decomp 会根据实际问题的需要，将原始问题拆解为不同形式的 Sub-Task，并在 Sub-Task 中组合使用多种符合情景的 Prompt 方法。
|
||||
|
||||
而对于 Decomp 过程，则又是由一个原始的 Decomp Prompt 驱动
|
||||
|
||||
|
||||
|
||||
Decomp 方法执行样例
|
||||
|
||||
在实际运行中，Decomp 过程由一个任务分解器，和一组程序解析器组成
|
||||
|
||||
其中分解器作为语言中枢，需要被授予如何分解复杂任务 —— 其将根据一个问题 Q 构建一个完整的提示程序 P，这个程序包含一系列简单的子问题 Q_i，以及用于处理该子问题的专用函数 f_i（可以通过特定小型 LLM 或专用程序，也可以以更小的提示程序 P_i 形式呈现）。
|
||||
|
||||
模型将通过递归运行完整的提示程序，来获得理想的答案。
|
||||
|
||||
在构建 Decomp 流程的初期，其主要是为了解决 LLMs 无法直接解决的具有严密逻辑的工作（比方说基于文本位置的文字游戏，比方说检索一首藏头诗的头是啥（当然这个太简单了），大模型的位置编码系统和概率系统让其很难长程处理相关工作），我们希望通过 Decomp 方法，将复杂问题逐步归约回 LLMs 能处理的范畴。
|
||||
|
||||
我们也可以认为，在每个子任务中，我们通过 Prompt 将 LLMs 的能力进行了劣化，从而让其成为一个专职的功能零件。而这种对单个 LLMs 能力迷信的削减，正延伸出了后续的发展趋势。
|
||||
|
||||
### Decomp 衍生
|
||||
|
||||
Decomp 的原始功能实际上并不值得太过关注，但我们急需考虑，该方法还能用于处理些什么问题。
|
||||
|
||||
#### 递归调用
|
||||
|
||||
我们可以构建规则，让 Decomp 方法中的分解器递归调用自身，从而使得一个可能困难的问题无限细分，并最终得以解决
|
||||
|
||||
#### 外部调用
|
||||
|
||||
通过问题的分解和通过“专用函数”的执行，我们可以轻易让 LLMs 实现自身无法做到的调用 API 工作，例如主动从外部检索获取回答问题所需要的知识。
|
||||
|
||||
|
||||
|
||||
Decomp 方法调用外部接口样例
|
||||
|
||||
如上图为 LLMs 利用 ElasticSearch 在回答问题过程中进行检索
|
||||
|
||||
基于此，我们还希望进一步研究基于这些机制能整出什么花活儿，并能讨论如何进一步利用 LLMs 的能力
|
||||
|
||||
### 回顾：HuggingGPT 对 Decomp 方法的使用
|
||||
|
||||
[HuggingGPT](https://arxiv.org/abs/2303.17580) 一文也许并未直接参考 Decomp 方法，而是用一些更规范的手法完成该任务，但其充分流水线化的 Prompt 工程无疑是 Decomp 方法在落地实践上的最佳注脚
|
||||
|
||||
|
||||
|
||||
HuggingGPT
|
||||
|
||||
如图所示，在实际工程中，对于这个调用 HuggingFace API 的“通用人工智能”而言，其所需的任务并不复杂，仅仅分为三步（获取并运行缝在一起了）
|
||||
|
||||
- 理解并规划解决问题所需步骤
|
||||
- 选择并运行解决问题所需模型
|
||||
- 基于子问题输出结果总结反馈
|
||||
|
||||
同样的，TaskMatrix.AI 也使用了相似的方法和步骤来完成任务，最新的进展高度明晰了该框架的可用性，并为我们如何有效使用 AI 来完成专用任务提供了有效的指导。
|
||||
|
||||
接下来，我们会讨论一个很新的，在为 Agent 模拟任务构建框架上，把 Decomp 和 Prompting 技术用到登峰造极的样例。
|
||||
|
||||
## Generative Agents：社群模拟实验
|
||||
|
||||
[[2304.03442] Generative Agents: Interactive Simulacra of Human Behavior (](https://arxiv.org/abs/2304.03442)[arxiv.org](https://arxiv.org/abs/2304.03442)[)](https://arxiv.org/abs/2304.03442)
|
||||
|
||||
Generative Agents 一文通过的自然语言框架 AI 构建出了一个模拟社群，一方面我们震撼于以 AI 为基础的社群复杂系统也能涌现出如此真实可信的表现，另一方面则需要关注他们通过 Prompt 技巧和工程设计，为 AI 构建的 感知、记忆、交互 大框架。
|
||||
|
||||
其在极大程度上能为我们想建立的其它基于 AI 的工程提供参考。
|
||||
|
||||
因为，其本质是一个信息管理框架的实验。
|
||||
|
||||
### 简要介绍
|
||||
|
||||
简单介绍该项目构建的框架：
|
||||
|
||||
我们可以认为该工程由三个核心部分构成
|
||||
|
||||
- 世界信息管理
|
||||
- 角色信息管理
|
||||
- 时间驱动机制
|
||||
|
||||
我们可以从宏观到微观渐进讨论该课题：
|
||||
|
||||
Generative Agents 构建了一套框架，让 NPC 可以感知被模块化的世界信息。同时，对于全游戏的每个时间步，该框架驱动 NPC 自主感知世界环境的信息与自身信息，并依此决策自己想要执行的行为。
|
||||
|
||||
根据 NPC 的决策，NPC 能反向更新自身所使用的记忆数据库，并提炼总结出高层记忆供后续使用。
|
||||
|
||||
### 世界沙盒的构建
|
||||
|
||||
相比角色信息的构建是重头戏，世界沙盒的构建使用的方法要相对朴素一些
|
||||
|
||||
世界沙盒的核心是一个树状 Json 数据，其依据层次储存游戏场景中所有的信息：
|
||||
|
||||
- 一方面，其包含场景中既有对象，包括建筑和摆件等的基础层级信息
|
||||
|
||||
|
||||
|
||||
Generative Agents 的场景信息管理
|
||||
|
||||
- 另一方面，其储存了沙盒世界中每个代理的信息，包括其位置、当前动作描述、以及他们正在交互的沙盒对象
|
||||
|
||||
对于每个时间步，服务器将解析场景的状态，例如对于 Agent 使用咖啡机的情景，会自动将咖啡机转换为正在使用中的状态。
|
||||
|
||||
而相对更有趣的设计是，场景中的所有信息会依靠认知过滤（即 NPC 是否能感知其感知范围外的环境变化）进行筛选，并最终呈现成 NPC 可感知/有印象的子集。
|
||||
|
||||
同时，空间信息会被自动组成自然语言 Prompt，用于帮助 Agent 更好地理解外部信息。甚至当 Agent 希望获取空间信息时，其能主动递归调用世界信息，从而让 NPC 能准确找到其希望抵达的叶子节点。
|
||||
|
||||
### Agent 构建
|
||||
|
||||
模型中的 Agent 由 数据库 + LLMs 构建
|
||||
|
||||
对于一个初始化的 Agent，会将角色的初始设定和角色关联设定作为高优先级的“种子”储存在“记忆”中，在记忆种子的基础上，得以构建角色的基本特征和社交关系，用于展开后续关联
|
||||
|
||||
一个 Agent 核心的能力是 —— 将当前环境和过去经验作为输入，并将生成行为作为输出
|
||||
|
||||
对于当前环境，在构建世界沙盒模块对方法论进行了简要的介绍。
|
||||
|
||||
而对于过去经验的输入，则是文章的一大亮点
|
||||
|
||||
### 记忆模式
|
||||
|
||||
对于 Agent 的记忆，依托于一个储存信息流的数据库
|
||||
|
||||
数据库中核心储存三类关键记忆信息 memory, planning and reflection
|
||||
|
||||
#### Memory
|
||||
|
||||
对于 Agent 每个时间步观测到的事件，会被顺序标记时间戳储存进记忆数据库中
|
||||
|
||||
而对于储存进数据库的信息，记忆管理器通过三个标准对其进行评估和管理
|
||||
|
||||
- Recency：时效性，记忆在数据库中会随着时间推移降低时效性，数据库储存记忆的最后访问时间，并由此与当前时间对比，计算时效性评分
|
||||
- Importance：重要性，当记忆储存时，会使用特定 Prompt 让 Agent 自主评估当前记忆的重要性，并依据该评分调整该记忆的权重（例如扫地和做咖啡可能就是无关紧要的记忆）
|
||||
- Relevance：关联性，该指标被隐式地储存，表现为一个嵌入索引，当调取记忆时，会将调取记忆的关键词嵌入与索引相匹配，以取得关联性的评分
|
||||
|
||||
对于对记忆数据库进行索引的情况，会实时评估上述三个指标，并组合权重，返回对记忆索引内容的排序
|
||||
|
||||
#### Reflection
|
||||
|
||||
反思机制用于定期整理当前的 memory 数据库，让 npc 构建对世界和自身的高层认知
|
||||
|
||||
反思机制依靠一个自动的过程，反思 - 提问 - 解答
|
||||
|
||||
在这个过程中，Agent 需要复盘自身所接受的记忆，并基于记忆对自己进行追问：
|
||||
|
||||
“根据上述信息，我们能问出哪些最高优先级（有趣）的问题”
|
||||
|
||||
依据由 Agent 的好奇自主产生的问题，我们重新索引数据库，并围绕相关的记忆产生更高层的洞察
|
||||
|
||||
> What 5 high-level insights can you infer from the above statements?<br/>(example format: insight (because of 1, 5, 3))
|
||||
|
||||
进一步的，我们将这些洞察以相同的形式重新储存至记忆库中，由此模拟人类的记忆认知过程
|
||||
|
||||
#### Planning
|
||||
|
||||
Planning 的核心在于鼓励 Agent 为未来做出一定的规划，使得后续行动变得可信
|
||||
|
||||
计划由 Agent 自行生成，并存入记忆流中，用于在一定程度上影响 Agent 的当前行为
|
||||
|
||||
对于每天 Agent 都会构建粗略的计划，并在实际执行中完善细节
|
||||
|
||||
在此基础上，Agent 也需要对环境做出反应而调整自己的计划表（例如自身判断外界交互的优先级比当前计划更高。
|
||||
|
||||
### 交互构建
|
||||
|
||||
基于上述记忆框架，进一步实时让 Agent 自行感知并选择与其它 Agent 构建交互
|
||||
|
||||
并最终使得复杂的社群在交互中涌现
|
||||
|
||||
### 启发
|
||||
|
||||
Generative Agent 框架主要带来了一些启发，不止于 AI-NPC 的构建，其操作的诸多细节都是能进一步为我们在实际的工程中所延拓的。
|
||||
|
||||
例如：
|
||||
|
||||
> 感知，围绕目标递归对地图搜索，带来了递归检索数据库的可能性，以及要如何有效构建数据库之间的关联（不止于树<br/>记忆，将 AI 的 Reflection 等表现储存进数据库中，用于实现高层观点的构建，比方说自动构建对复杂对象，如代码库的高层理解<br/>交互，通过地图要素的拆分和可读化构建的交互框架，如何基于该思路构建大世界地图关卡数据的数据库，如何把它拓展到更复杂的游戏中
|
||||
|
||||
我们可以认为，Generative Agents 一文的核心亮点在于，其构建了一套充分有效的信息管理机制以支撑世界运行的需要，并未我们提供了一系列启发性的数据管理观点
|
||||
|
||||
- 层次管理数据：通过对数据进行分层的管理和访问，降低运算开销，并通过系统级递归实现访问
|
||||
- 层次管理信息：通过语言模型的能力为信息构建高层的 Insight，对碎片信息的信息量进行聚合
|
||||
- 数据价值评估：通过实际需求对信息进行评估，构建多样化的信息评估指标，实现信息的有效获取
|
||||
- AI x 信息自动化系统的构建：基于 AI + 软件系统而非基于人工对数据进行收集和管理
|
||||
- etc...
|
||||
|
||||
## AutoGPT：自动化的智能软件系统
|
||||
|
||||
[Torantulino/Auto-GPT: An experimental open-source attempt to make GPT-4 fully autonomous. (](https://github.com/Torantulino/Auto-GPT)[github.com](https://github.com/Torantulino/Auto-GPT)[)](https://github.com/Torantulino/Auto-GPT)[github.com/Torantulino/Auto-GPT](https://github.com/Torantulino/Auto-GPT)
|
||||
|
||||
同为近期，一个名为 AutoGPT 的软件系统在 Github 上被开源，其通过构建软件系统支持，让 AI 能围绕预设定的目标反复迭代，并自主获取外界的反馈，从而形成一个能自动化满足需求的自动机。
|
||||
|
||||
特别的，其可以被视为前文中 Generative Agent 中由系统自驱动单个 Agent 的拓展，通过构建内置和外置的不同目标驱动 GPT 作为 Agent 持续运行
|
||||
|
||||
AutoGPT 主要特性如下：
|
||||
|
||||
- 使用 GPT-4 实例进行文本生成
|
||||
- ️ 使用 GPT-3.5 进行文件存储和摘要
|
||||
- 接入互联网获取信息
|
||||
- 长期和短期内存管理
|
||||
|
||||
考虑到工程细节，该项目实际上没有特别大的落地案例，但毫无疑问这是面向未来的 GPT 使用方式
|
||||
|
||||
其核心机制在于，通过 LLMs 和 记忆/目标管理模块 的符合，构建出了一个复杂的 Agent 系统
|
||||
|
||||
我们通常不再将该系统认为是一个完整的 GPT 线程：
|
||||
|
||||
这是一个通过工程、通过系统化、通过反馈构建的自动机，就像人一样。
|
||||
|
||||
（我们需要放下通过 LLMs 来模拟智能体的执念，我们作为智能体的实质是一个输入输出的系统，而我们所自认为的自由意志也只是大脑的一个解释模块而已，也许与智能系统中调用的单个 LLMs 线程异曲同工）
|
||||
|
||||
当前，AutoGPT 的能力主要反应在主动通过 Google API 联网，寻找并记忆自己需要使用到的知识，包括某些软件的接口和其它 API，也包括自己完成某些分析所需要的知识。
|
||||
|
||||
（已经有人尝试通过其快速构建软件工程，或者完成其它某些自动化操作。）
|
||||
|
||||
（虽然感觉依旧不甚理想）
|
||||
|
||||
（如下是 AutoGPT 的基础 Prompt）
|
||||
|
||||
```txt
|
||||
[
|
||||
{
|
||||
'content': 'You are Eliza, an AI designed to write code according to my requirements.\n'
|
||||
'Your decisions must always be made independently without seeking user assistance. Play to your strengths as an LLM and pursue simple strategies with no legal complications.\n\n'
|
||||
|
||||
'GOALS:\n\n'
|
||||
'1. \n\n\n'
|
||||
|
||||
'Constraints:\n'
|
||||
'1. ~4000 word limit for short term memory. Your short term memory is short, so immediately save important information to files.\n'
|
||||
'2. If you are unsure how you previously did something or want to recall past events, thinking about similar events will help you remember.\n'
|
||||
'3. No user assistance\n'
|
||||
'4. Exclusively use the commands listed in double quotes e.g. "command name"\n\n'
|
||||
|
||||
'Commands:\n'
|
||||
'1. Google Search: "google", args: "input": "<search>"\n'
|
||||
'2. Browse Website: "browse_website", args: "url": "<url>", "question": "<what_you_want_to_find_on_website>"\n'
|
||||
'3. Start GPT Agent: "start_agent", args: "name": "<name>", "task": "<short_task_desc>", "prompt": "<prompt>"\n'
|
||||
'4. Message GPT Agent: "message_agent", args: "key": "<key>", "message": "<message>"\n'
|
||||
'5. List GPT Agents: "list_agents", args: \n'
|
||||
'6. Delete GPT Agent: "delete_agent", args: "key": "<key>"\n'
|
||||
'7. Write to file: "write_to_file", args: "file": "<file>", "text": "<text>"\n'
|
||||
'8. Read file: "read_file", args: "file": "<file>"\n'
|
||||
'9. Append to file: "append_to_file", args: "file": "<file>", "text": "<text>"\n'
|
||||
'10. Delete file: "delete_file", args: "file": "<file>"\n'
|
||||
'11. Search Files: "search_files", args: "directory": "<directory>"\n'
|
||||
'12. Evaluate Code: "evaluate_code", args: "code": "<full_code_string>"\n'
|
||||
'13. Get Improved Code: "improve_code", args: "suggestions": "<list_of_suggestions>", "code": "<full_code_string>"\n'
|
||||
'14. Write Tests: "write_tests", args: "code": "<full_code_string>", "focus": "<list_of_focus_areas>"\n'
|
||||
'15. Execute Python File: "execute_python_file", args: "file": "<file>"\n'
|
||||
'16. Execute Shell Command, non-interactive commands only: "execute_shell", args: "command_line": "<command_line>"\n'
|
||||
'17. Task Complete (Shutdown): "task_complete", args: "reason": "<reason>"\n'
|
||||
'18. Generate Image: "generate_image", args: "prompt": "<prompt>"\n'
|
||||
'19. Do Nothing: "do_nothing", args: \n\n'
|
||||
|
||||
'Resources:\n'
|
||||
'1. Internet access for searches and information gathering.\n'
|
||||
'2. Long Term memory management.\n'
|
||||
'3. GPT-3.5 powered Agents for delegation of simple tasks.\n'
|
||||
'4. File output.\n\n'
|
||||
|
||||
'Performance Evaluation:\n'
|
||||
'1. Continuously review and analyze your actions to ensure you are performing to the best of your abilities.\n'
|
||||
'2. Constructively self-criticize your big-picture behavior constantly.\n'
|
||||
'3. Reflect on past decisions and strategies to refine your approach.\n'
|
||||
'4. Every command has a cost, so be smart and efficient. Aim to complete tasks in the least number of steps.\n\n'
|
||||
|
||||
'You should only respond in JSON format as described below \n'
|
||||
'Response Format: \n'
|
||||
'{\n'
|
||||
' "thoughts": {\n'
|
||||
' "text": "thought",\n'
|
||||
' "reasoning": "reasoning",\n'
|
||||
' "plan": "- short bulleted\\n- list that conveys\\n- long-term plan",\n'
|
||||
' "criticism": "constructive self-criticism",\n'
|
||||
' "speak": "thoughts summary to say to user"\n'
|
||||
' },\n'
|
||||
' "command": {\n'
|
||||
' "name": "command name",\n'
|
||||
' "args": {\n'
|
||||
' "arg name": "value"\n'
|
||||
' }\n'
|
||||
' }\n'
|
||||
'} \n'
|
||||
'Ensure the response can be parsed by Python json.loads',
|
||||
'role': 'system'
|
||||
},
|
||||
{
|
||||
'content': 'The current time and date is Fri Apr 14 18:47:50 2023',
|
||||
'role': 'system'
|
||||
},
|
||||
{
|
||||
'content': 'This reminds you of these events from your past:\n\n\n',
|
||||
'role': 'system'
|
||||
},
|
||||
{
|
||||
'content': 'Determine which next command to use, and respond using the format specified above:',
|
||||
'role': 'user'
|
||||
}
|
||||
]
|
||||
```
|
||||
|
||||
## 回归正题：AI 作为智能系统
|
||||
|
||||
作为正题的回归，我们需要重新考虑什么是一个 AI，一个能帮助我们的 AI 应当处于什么样的现实形态？
|
||||
|
||||
*我们需要的 **AI** 仅仅是大语言模型吗？如果是，它能帮我们做什么呢？如果不是，那 AI 的实质是什么呢？*
|
||||
|
||||
我首先武断地认为，我们需要的 AI，并不是一个语言模型实体，而是一个复杂智能系统
|
||||
|
||||
而上述围绕 GPT 展开的实验，实质都是上述观点的佐证。
|
||||
|
||||
接下来，我们会围绕此进行展开
|
||||
|
||||
### 意识理论之于 AI：全局工作空间理论
|
||||
|
||||
全局工作空间理论（英语：Global workspace theory，GWT）是美国心理学家伯纳德·巴尔斯提出的[意识](https://zh.wikipedia.org/wiki/%E6%84%8F%E8%AF%86)模型。该理论假设意识与一个全局的“广播系统”相关联，这个系统会在整个大脑中广播资讯。大脑中专属的智能处理器会按照惯常的方式自动处理资讯，这个时候不会形成[意识](https://zh.wikipedia.org/wiki/%E6%84%8F%E8%AF%86)。当人面对新的或者是与习惯性刺激不同的事物时，各种专属智能处理器会透过合作或竞争的方式，在全局工作空间中对新事物进行分析以获得最佳结果，而意识正是在这个过程中得以产生。
|
||||
|
||||
这通常被认为是 神经科学家接受度最高的哲学理论
|
||||
|
||||
从某种意义上来说，该理论将“系统”摆在了主体的位置，而把纯粹的语言或“意识”转变成了系统运动的现象，表现为系统特殊运作情况的外显形式。
|
||||
|
||||
其提醒我们，就连我们的意识主体性，也只是陈述自我的一个表述器而已。我们是否应当反思对语言能力的过度迷信，从而相信我们能通过训练模型构建 All in One 的智能实体？
|
||||
|
||||
|
||||
|
||||
全局工作空间理论
|
||||
|
||||
如图所示，在全局工作空间理论的建模中，全局工作空间作为系统，有五个主要的模块负责输入和输出
|
||||
|
||||
其分别是：
|
||||
|
||||
- 长时记忆（过去）
|
||||
- 评估系统（价值）
|
||||
- 注意系统（关注）
|
||||
- 知觉系统（现在）
|
||||
- 运动系统（未来）
|
||||
|
||||
#### 例子：意识系统 For Generative Agent
|
||||
|
||||
单独解释的话，或许会比较麻烦，毕竟我对认知科学并不专业
|
||||
|
||||
我们可以简单对比 Generative Agents 其框架，结合意识模型讨论 Agent 是如何被有效构建的
|
||||
|
||||
回顾前文，我们核心对照 Agent 的记忆模块构建：
|
||||
|
||||
（不想手写，让 GPT4 来进行代笔）
|
||||
|
||||
> 从全局工作空间理论（GWT）的角度来看，Generative Agent 的设计确实与之有相似之处。GWT 提出了一个全局工作空间，负责整合来自不同认知子系统的信息。在 Generative Agent 的框架中，这些认知子系统可以看作是上述提到的几个模块。
|
||||
|
||||
- 首先，我们可以将长时记忆（过去）与 Generative Agent 的 memory 模块进行类比。memory 模块中存储了 Agent 在过去时间步观察到的事件，这与长时记忆中存储的过去信息相对应。
|
||||
- 其次，评估系统（价值）可以与 Generative Agent 的 Importance 和 Relevance 进行对应。Importance 可以理解为对记忆的重要性评估，而 Relevance 则评估了记忆与当前情境的关联性。这两者与全局工作空间理论中对不同认知子系统信息的竞争和广播过程相呼应。
|
||||
- 注意系统（关注）可以与 Generative Agent 的 Recency 相关联。Recency 衡量了记忆的时效性，这类似于在全局工作空间中，我们需要关注当前环境中的新信息，以便及时做出反应。
|
||||
- 知觉系统（现在）在 Generative Agent 中可以对应于当前环境的输入，这与全局工作空间理论中的感知子系统相一致。
|
||||
- 运动系统（未来）可以与 Generative Agent 的 planning 和 reflection 模块相关联。planning 模块让 Agent 为未来做出规划，而 reflection 模块则允许 Agent 对过去的记忆进行整理，构建高层认知，进而影响未来的行为。这两个模块与全局工作空间理论中的行动子系统相呼应。
|
||||
|
||||
> 综上所述，Generative Agent 的设计确实与全局工作空间理论有相似之处，通过将这些模块整合到一个统一的框架中，Agent 能够模拟人类在虚拟世界中扮演角色进行交互。这种整合有助于理解大脑如何处理和整合来自不同认知来源的信息，从而实现更接近人类的智能行为。
|
||||
|
||||
当然，我个人对该问题的认知与 GPT4 并非完全相同，包括注意系统与运动系统的部分。但其实我并不一定需要将所有东西全都呈现出来，因为在框架上它已然如此。
|
||||
|
||||
记忆、评估、反思这几块的设计通过 Prompt 把 LLMs 劣化成专用的智能处理器单元，并系统性实现信息的整合与输出。从整体的观点上来看，Generative Agents 中的 Agent，其主体性并不在于 LLM，而是在于这个完整的系统。（相应的，LLMs 只是这个系统的运算工具和陈述工具）
|
||||
|
||||
#### 例子：AutoGPT 的考察
|
||||
|
||||
我们再从相同的角度考察 AutoGPT 这一项目：
|
||||
|
||||
- 内存管理：全局工作空间理论强调了长时记忆、短时记忆和注意力机制之间的互动。AutoGPT 中的长期和短期内存管理与此类似，需要智能体在执行任务时权衡信息的重要性、时效性和关联性，以便有效地组织和存储信息。
|
||||
- 信息获取：全局工作空间理论的知觉系统负责处理来自外部的信息。AutoGPT 通过搜索和浏览网站等功能，获取外部信息，这与知觉系统的作用相符。
|
||||
- 生成与执行：全局工作空间理论中的运动系统负责生成和执行行为。AutoGPT 通过多种命令实现了文本生成、代码执行等功能，体现了运动系统的特点。
|
||||
|
||||
同时，其也具有对应的缺陷：
|
||||
|
||||
- AutoGPT 的长期记忆存在较大漏洞，并没有较强的注意力能力
|
||||
- AutoGPT 不能围绕记忆擢升更高层的认知，从而进一步指导未来的行为
|
||||
- AutoGPT 的运动系统，即执行能力受限于 Prompt 提供的接口，无法自适应完成更多任务
|
||||
- AutoGPT 对自身既往行为认知较差，短期记忆依赖于 4000 字 Context 窗口，并被系统输入占据大半
|
||||
|
||||
这也对应 AutoGPT 虽然看似有着极强的能力，但实际智能效果又不足为外人道也
|
||||
|
||||
### 构建一个什么样的智能系统
|
||||
|
||||
再次回归正题，Generative Agents 和 AutoGPT 这两个知名项目共同将 AI 研究从大模型能力研究导向了智能系统能力研究。而我们也不能驻足不前，我们应当更积极地考虑我们对于一个 AI 智能体有着什么样的需求，也对应我们需要构建、要怎么构建一个基于 LLMs 语言能力的可信可用的智能系统。
|
||||
|
||||
我们需要从两个角度展开考虑，从我们需要什么展开，并围绕框架进行延拓
|
||||
|
||||
当前，ChatGPT 虽然成了炙手可热的明珠，但却依然存在一些微妙的问题
|
||||
|
||||
> 来自 即刻网友 马丁的面包屑<br/>观察到一些现象：<br/>1. 除了最早期，最成熟的 Jasper 这样围绕短文本生成领域的应用，还没有看到太颠覆性的大模型应用<br/>2. 从 GPT-4 发布后的狂欢，其实是应用上的狂欢，无论 HuggingGPT、AutoGPT、Generative Agent 本质上是一种“玩法”的挖掘。<br/>3. 这种 Demo 级的产品展现了创意，但是我们知道 Demo 离最终落地还有非常多要解决的问题，这些问题哪些是可控的只需要堆时间，哪些是不可控的需要基座模型升级目前还看不清楚。<br/>4. 另外我在尝试将他融入我的工作流，帮助有限。我让一些程序员朋友测试 Github Copilot，评价上也比较有限
|
||||
|
||||
该讨论中所展现的问题，其核心在于，如何真正将 GPT 沉入“场景”中去。
|
||||
|
||||
而这才是真正一直悬而未决的 —— 作为一个打工人，你真正需要帮助的那些场景，GPT 都是缺席的。
|
||||
|
||||
同时，这样的场景，他是一个活场景抑或死场景？在这样的场景上，我们是否需要一个全知的神为我们提供信息？还是说，我们想要的是一个能像我们一样在场景中获取信息，并辅助我们决策/工作的个体？
|
||||
|
||||
这些问题都在指导、质问我们究竟需要一个怎样的智能系统。
|
||||
|
||||
## 予智能以信息：难题与展望
|
||||
|
||||
回到最开始的话题，我们构建一个可用智能系统的基底，依旧是信息系统
|
||||
|
||||
我们大胆假设，如果我们希望构建一个足以帮助我们的智能系统，其需要拥有以下几个如 全局工作空间理论 [1](http://127.0.0.1:6125/#footnotes-def-1) 所述的基本模块
|
||||
|
||||
- 知觉系统（现在）
|
||||
- 工作记忆（中继）
|
||||
|
||||
- 长时记忆（过去）
|
||||
- 评估系统（价值）
|
||||
- 注意系统（关注）
|
||||
- 运动系统（未来）
|
||||
|
||||
而接下来，我们希望对其进行逐一评估，讨论他们各自将作用的形式，讨论他们需要做到哪一步，又能做到哪一步。
|
||||
|
||||
### 知觉系统：构建 AI 可读的结构化环境
|
||||
|
||||
知觉系统负责让智能体实现信息的感知，其中也包括对复杂输入信息的解析
|
||||
|
||||
举两个简单的例子，并由此引出该课题中存在的难题
|
||||
|
||||
AutoGPT 的知觉设计：结构性难题
|
||||
|
||||
AutoGPT 所使用的 Commands 接口中，就有很大一部分接口用于实现知觉
|
||||
|
||||
典型的包含 Google Search & Browse Website & Read file
|
||||
|
||||
- Google Search: "google",
|
||||
|
||||
- args: "input": `"<search>"`
|
||||
- 返回网页关键信息与网址的匹配列表
|
||||
- Browse Website: "browse_website",
|
||||
|
||||
- args:
|
||||
|
||||
- "url": `"<url>"`,
|
||||
- "question": `"<what_you_want_to_find_on_website>"`
|
||||
- 返回网址中与 question 相关的匹配文段（通过 embedding 搜索）
|
||||
- Read file: "read_file",
|
||||
|
||||
- args: "file": `"<file>"`
|
||||
- 读取文件并解析文本数据
|
||||
|
||||
这些访问接口由程序集暴露给 GPT，将知觉系统中实际使用的微观处理器隐藏在了系统框架之下
|
||||
|
||||
AutoGPT 所实际感知的信息为纯文本的格式，得益于以开放性 Web 为基础的网络世界环境，AutoGPT 能较方便地通过搜索（依赖于搜索引擎 API）和解析 html 文件（依赖于软件辅助，GPT 难以自行裁剪 html 中过于冗杂的格式信息），从而有效阅读绝大多数互联网信息。
|
||||
|
||||
但显然的，Read file 接口能真正有效读取的就只有纯文本文件此类了。
|
||||
|
||||
由此，这带来了知觉系统设计的第一个难题：我们要如何面对生产环境中的一系列非结构化信息？如何对其进行规范和整理？如何设计“处理器”使得 GPT 能有效对其进行读取？
|
||||
|
||||
围绕这一难题，我们简单例举几个例子来进行讨论，用作抛砖引玉：
|
||||
|
||||
- 我们以 Excel 或 Word 等格式编写排版的策划文档，要如何让 GPT 读取和索引？
|
||||
- 如果我们希望让 GPT 掌握游戏中的关卡信息，其要如何对关卡编辑器进行理解？
|
||||
- 如果我们有一个数千行的代码文件，如何让 GPT 能掌握其结构信息，充分理解模功能，而非因为草率输入爆掉上下文限制？
|
||||
- 如果我们希望让 GPT 帮助我们通过点击 UI 要素自动测试游戏，我们要如何向其传达当前界面 UI 结构？如何向其展示测试进程和玩家状态？
|
||||
- etc...
|
||||
|
||||
综上所述，第一个难题就是，我们要如何为所有期待由 AI 帮忙解决的问题，构造 AI 能理解的语境，如何把所有抽象信息规范化、结构化地储存（不止步于文本，而是把更多东西文本化（顺便这里的文本化是可读化的意思，在 GPT4 完全公开后，图像也将成为索引信息，因此这段话的本意还是将更多东西 token 化））
|
||||
|
||||
Generative Agents 的知觉设计：关联性难题
|
||||
|
||||
区别于接受互联网环境信息的 AutoGPT，Generative Agents 的知觉系统仅在人工赋予 Agent 的有限环境中生效，因此也显得愈发可控。
|
||||
|
||||
也正是因为如此，对于场景中可知觉的信息，在 GA 的框架下能得到更有效的管理
|
||||
|
||||
> [Agent's Summary Description]<br/>Eddy Lin is currently in The Lin family's house: (Eddy Lin's bedroom: desk) that has Mei and John Lin's bedroom, Eddy Lin's bedroom, common room, kitchen, bathroom, and garden.<br/>Eddy Lin knows of the following areas:<br/>The Lin family's house, Johnson Park, Harvey Oak Supply Store, The Willows Market and Pharmacy, Hobbs Cafe, The Rose and Crown Pub.<br/>* Prefer to stay in the current area if the activity can be done there.<br/>Eddy Lin is planning to take a short walk around his workspace. Which area should Eddy Lin go to?
|
||||
|
||||
如上述 Prompt 所示，由于 Generative Agents 预定义了空间的树状层级关系，这使得当其作为知觉系统时，可通过对树的层级遍历和自然语言拼装实现知觉系统的有效传达。
|
||||
|
||||
同时，基于树状结构，这允许了 Agent 基于自身需求在树上进行深度搜索。
|
||||
|
||||
该样例作为补充，讨论了数据结构设计中关联性和结构化的价值。以搜索引擎为例，仅通过关键词关联进行检索的联系是偏弱的，且不能体现层次信息，以及层次信息中蕴含的知识。
|
||||
|
||||
> 对于上面这点，我们举一个简单的例子：<br/>迪娜泽黛是一个因身患魔鳞病深居简出的 Agent，她的家在须弥城，有一天她突发奇想希望能在病逝之前看一看海。她通过搜索引擎关联搜索，并找到了推荐度最高的大海聚香海岸，为此她不远万里来到了沙漠，但差点在路上噶掉。她的好朋友迪希娅追上来给了她梆梆两拳，跟她说你去隔壁奥摩斯港看海她不香吗？
|
||||
|
||||
对于绝大部分的信息，我们所需的并不只是信息本身，更包含其中的潜在结构和关联。而对于游戏中的复杂数据更是如此。
|
||||
|
||||
这为我们知觉系统设计带来了第二个难题：我们要如何建模我们语境空间中零散的信息？我们要怎么通过最结构化最易读的方式有效对其索引？我们要如何建模并用工程辅助 GPT 的索引过程？
|
||||
|
||||
我们依旧简单举几个例子来进行讨论：
|
||||
|
||||
- 如果 GPT 能够读取我们的设计文档，它要如何整合多个文档之间的关联？如何构建索引？
|
||||
- 如果 GPT 要阅读我们的代码库，其要怎么快速跳转并逐层理解模块、功能、接口？
|
||||
- 如果我们希望 GPT 作为 Agent 来进行游戏，GPT 要如何经过 UI 步骤准确进入系统层级？
|
||||
|
||||
由此，除了数据本身的结构化（指高度可读），数据库的结构化（指关联构建）也是为知觉系统服务的一个重要课题。
|
||||
|
||||
知觉系统及开发数据环境的构建
|
||||
|
||||
该议题显然还只是一个开放性的讨论，知觉系统的设计并不仅仅包括设计智能体依赖什么接口进行知觉，更要求知觉系统与环境的匹配，以及工作目的与环境的匹配。
|
||||
|
||||
仅就这方面而言，作为一个方向性的倡议，对知觉系统的开发可能分为以下步骤
|
||||
|
||||
#### *数据处理/管理*
|
||||
|
||||
- 对 办公文件/数据 构建通用读取接口
|
||||
- 以同类信息为单位，设计通用的字段（由人设计和管理，AI 能力尚不至此）
|
||||
|
||||
- 以程序 API 接口为例：可能包含以下字段
|
||||
|
||||
- API 接口名
|
||||
- API 调用参数
|
||||
- 所属命名空间
|
||||
- 所属父类
|
||||
- API 接口描述
|
||||
- API 接口描述向量（可能用于语义索引）
|
||||
- 源文件索引（用于监听和更新）
|
||||
- 源信息（源文本 or）
|
||||
- etc...
|
||||
- 围绕既定的通用字段，以对象为单位，依靠 GPT 的文本能力自底向上进行总结和编码
|
||||
|
||||
- 我们尝试给定规范让 GPT 自动阅读代码段并总结接口，转化为 bson 文件
|
||||
- 构建对象索引数据库
|
||||
|
||||
- 如储存进 mongoDB
|
||||
- （设计孪生数据的自动更新机制）
|
||||
|
||||
#### *知觉系统驱动*
|
||||
|
||||
- 基于上述索引数据库，以视图为单位进行访问，并设计 视图 2 Prompt 的转化格式
|
||||
|
||||
- 依旧以 API 接口为例，我们将 AutoGPT 的 Command 信息表现为以数据库形式储存
|
||||
|
||||
对于如上数据库信息，我们对于以视图为单位进行整理，将其转化为 prompt 输入
|
||||
|
||||
'Commands:\n'
|
||||
'1. Google Search: "google", args: "input": `"<search>"`\n'
|
||||
'2. Browse Website: "browse_website", args: "url": `"<url>"`, "question": `"<what_you_want_to_find_on_website>"`\n'
|
||||
'3. Start GPT Agent: "start_agent", args: "name": `"<name>"`, "task": `"<short_task_desc>"`, "prompt": `"<prompt>"`\n'
|
||||
'4. Message GPT Agent: "message_agent", args: "key": `"<key>"`, "message": `"<message>"`\n'
|
||||
'5. List GPT Agents: "list_agents", args: \n'
|
||||
|
||||
- 对于对数据库进行感知的任务，我们需要进一步设计 Pormpt 驱动 Agent 的行为
|
||||
|
||||
- 对于 Agent 开启的指定任务线程（区分于主线程的感知模块），其起始 Prompt 可能呈这样的形式
|
||||
|
||||
> <br/>如上是你的目标，为了实现这个目标，你可能需要获取一系列的信息，为了帮助你获得信息，我会为你提供一系列的索引访问接口，请你通过如下格式输出语句让我为你返回信息。<br/>注：如果你请求错误，请你阅读返回的报错信息以自我纠正<br/>例：<br/>< 通过接口名称检索 ("接口名称")><br/>< 通过接口功能检索 ("访问网页")><br/>< 通过父级名称检索 ("父级名称")>
|
||||
|
||||
- 为 GPT 设计自动化指令解析与执行模块
|
||||
|
||||
- 如对上述数据访问接口，仍需匹配一套自动解析访问指令并进行数据库检索，返回指定视图格式转换后的 Prompt（当然也可以是对应视图的 bson 转 json 文件，不使用源数据以过滤系统信息）
|
||||
|
||||
可以预见的，基于上述知觉框架，我们能让 Agent 一定程度上在语境中自动化实现基于任务的信息收集。
|
||||
|
||||
非工程化的试验样例
|
||||
|
||||
（使用了我先前写过的卡牌游戏，基于指定任务让其主动收集信息并编写新的技能脚本）
|
||||
|
||||
> TBD：号被 OpenAI 噶了，我也很绝望啊
|
||||
|
||||
### 工作记忆：组织 AI 记忆系统
|
||||
|
||||
记忆系统的构成其实相较知觉系统等更为抽象，它用于管理 AI 运行时作为背景的长期记忆，以及定义决定了 AI 当前任务及目标的短期记忆。
|
||||
|
||||
从某种意义上来说，其极度依赖工程实践中的迭代，因此我现在空手无凭，相比也说不出什么好东西。
|
||||
|
||||
但我们依旧能从前人的工作中获得一定的参考。
|
||||
|
||||
#### AutoGPT 的记忆设计：粗放但有效
|
||||
|
||||
在 长时记忆（过去）、评估系统（价值）、注意系统（关注）这三个要素中，AutoGPT 做得比较好的无疑只有第一个。
|
||||
|
||||
AutoGPT 的核心记忆设计依赖于预包装的 Prompt 本体，这一包装包含如下部分：
|
||||
|
||||
- Content：用于定义 AI 当前的状态
|
||||
- Goals：用于储存用户定义的 AI 任务
|
||||
- Constraints：用于告诉 AI 约束和部分行为指引
|
||||
|
||||
- 让 AI 通过“thought”调用长期记忆就是在这里约束好的
|
||||
- 同时鼓励 AI 把当前的输入尽快存入长期记忆数据库
|
||||
- Commands：用于告诉 AI 其可执行的行为
|
||||
- Resources：告诉 AI 它主要能做什么（没啥用）
|
||||
- Performance Evaluation：用于提醒 AI 自我反思
|
||||
- Response Format：用于确保 AI 输出可解析
|
||||
|
||||
而在这个预定义本体信息之上，进一步拼贴了如下要素
|
||||
|
||||
- 当前时间戳
|
||||
- 过去几步行为记录
|
||||
- 依据“thought”从长期记忆数据库中抽取的记忆片段
|
||||
- 用于驱动执行下一步的 Prompt
|
||||
|
||||
如上形式，AutoGPT 的记忆设计相对粗放，其依赖于 GPT 对数据库的写入，并将索引记忆的工作完全交予了基于关联的向量数据库索引。
|
||||
|
||||
也正是因为这个，在实际使用中，不乏能遇到 AutoGPT 在运行中发生记忆紊乱，开始重复进行了既往的劳动、或钻牛角尖做些无用功的情景。
|
||||
|
||||
但从另一角度，其“自主将收集到的信息写入记忆”这一功能作为一个 以完成任务为目标 的 Agent 而言无疑是非常合适的架构设计。
|
||||
|
||||
#### Generative Agents 的记忆设计：精心构建的金字塔
|
||||
|
||||
区别于 AutoGPT 主动写入的记忆，Generative Agents 的记忆源自被动的无限感知和记录，因此显得更加没有目的性。也正因如此，其需要一种更妥善的管理形式。
|
||||
|
||||
Generative Agent 通过自动化评估记忆的价值，并构建遗忘系统、关注系统等用于精准从自己繁杂的记忆中检索对于当前情景有用的信息。
|
||||
|
||||
|
||||
|
||||
Generative Agents：基于 Reflection 构建记忆金字塔
|
||||
|
||||
进一步的，其通过反思机制强化了记忆的价值，使得高层洞察从既有记忆的连结中涌现，这一机制通常被用于将 信息转化为知识，并构建出了有效记忆的金字塔。
|
||||
|
||||
而毫无疑问，相关的洞见对于“完成任务”而言也是极具价值的。
|
||||
|
||||
相关的更有效的记忆管理无疑很快就会被更新的项目学习。
|
||||
|
||||
#### 记忆系统的构建讨论（放飞大脑）
|
||||
|
||||
但从某种意义上来说，对于一个我们希望其帮助我们工作的智能体而言，像 Generative Agent 这般的巨大数据库也许并未有充分的价值，何况我们所输入的内容原始层级就较高（这一层可能在前面的知觉系统中，就让一定程度上的高层洞见自主产生了），不易于进一步的堆叠。
|
||||
|
||||
也许，我们更该关注的是 Agent 对自身短期记忆的管理，即让 Agent 锚定自身的状态，并自主抽象出凝练的短期记忆和关注方向。
|
||||
|
||||
在 AutoGPT 的框架下，我们能构建一个专用的短期记忆文本文件，供 GPT 自身编辑，对于每次会话开始时，该文本文件都会自动嵌入 Prompt 中，从而永续保存在 GPT 的上下文窗口内。
|
||||
|
||||
该短期记忆主要用于记录当前目标执行进度，以及 GPT 对目标的实际分解形式。
|
||||
|
||||
相应的，GPT 的行为记录也能被下放至长期记忆中，构成行为与储存资料的数据对，使得记忆管理更加规范。易于在记忆向量检索时取得期望的效果。
|
||||
|
||||
（我本该写得更靠谱一点，但我写到这里已经快累死了，让我开摆罢）
|
||||
|
||||
不过显然，这部分设计需要在工程中得到迭代
|
||||
|
||||
（可以遇见的，以 AutoGPT 的热度，半个月内就会有人为其设计相应的 mod）
|
||||
|
||||
### 运动系统：让 AI 可及一切
|
||||
|
||||
基于知觉系统和记忆系统，已经能构建一个使用语言解决问题的智能体了。但最为关键的改造世界部分则依旧缺席。
|
||||
|
||||
虽然这么说也不准确，其实运动系统的部分在知觉系统的讨论中就以提及了：对外界的主动交互并感知，就是一种“运动”。
|
||||
|
||||
我们最终总会不满足于让 AI 帮助我们思考问题，我们想让 AI 帮我们走完最后一步。由此，我们需要让 AI 能与世界进一步地互动。
|
||||
|
||||
- 我们大胆假设未来游戏中的 Agent 能通过 API 驱动自身在场景中无拘无束（拼装行为树
|
||||
- 再大胆假设他们能使用 API 实时把需求的内容转化为发布给玩家的任务（拼装任务节点
|
||||
- 继续大胆假设，AI 根据我的需求把今天要配的啥比表直接配完，当场下班（笑
|
||||
|
||||
（而这一切，都是可能，且近在眼前的）
|
||||
|
||||
而这最终又回到了原始的问题 —— 我们能给 AI 什么
|
||||
|
||||
AI 能做的一切都基于我们的赋予，包括语言能力，包括思维能力，包括对话能力，更包括前面那些知觉和记忆的能力。运动也无外乎如是，其落实到了两个问题上：
|
||||
|
||||
- 如何为 AI 构造充分实用的工具（高度开放的 API 设计
|
||||
- 如何让 AI 找到足够趁手的工具（易于检索的 API 平台
|
||||
- 如果让 AI 能够正确地使用工具（高鲁棒的 API 执行器
|
||||
|
||||
而这其中，进一步要求让 API 可读和可索引，由此回到我们在知觉系统中的课题，也不必过多赘述了。
|
||||
|
||||
在结尾处重新梳理一下本文核心讨论的观点
|
||||
|
||||
- 大语言模型的实质是一个拥有智能能力的语言计算器
|
||||
- 我们不该将其当作独立的智能体看待，但能在其基础上通过构建系统创建智能 Agent
|
||||
- 为此，我们需要通过信息工程，让 AI 能够真正感知和改造世界，从而改变我们的生产进程
|
||||
|
||||
## 寄予厚望
|
||||
|
||||
感谢有人忍受了我阴间的行文和一路跑偏的思路，真能看到这里
|
||||
|
||||
红豆泥私密马赛西塔！！！
|
||||
|
||||
从某种意义上，本文实际上并没有讨论什么实质性的东西，但作为一个近期思路变化的总结，和对 AI 未来发展的展望，乃至对未来生产力发展的展望。我希望它有一定的参考价值。
|
||||
|
||||
可以预见的，AI 对于生产的作用显然并不止于我们上面所讨论的这些，我们不仅希望人要为 AI“赋能”，更希望 AI 能进一步地为人赋能：
|
||||
|
||||
- 通过 AI、以及对信息的管理，我们能极大程度上降低复杂团队内部的沟通成本和信息获取成本
|
||||
- 通过更智能的 AI，能更好地辅助内容创作，让创作者把有限的生产力放在抓住更亮眼的 Sparks 上
|
||||
- 通过基于 AI 的高度自动化流程，也许我们真的能看到每个人都能将自己的空想所具现化的未来
|
||||
|
||||
为 AI 开放一切，为 AI 提供信息，这两个“为”才是走向 AIGC 的唯一明路。是让 AI 真正走入生产，解放生产力的唯一正路。
|
||||
|
||||
- 作为 AI 研究者，我愿意拭目以待
|
||||
- 作为游戏开发者，我希望积极地将其运用到我的生产过程中
|
||||
- 作为团队成员，我期盼生产革命能从我的身边掀起
|
||||
- 作为马克思主义者，我必将推动着它解放世人们的生产力
|
||||
155
2023旧版内容/4.人工智能/4.人工智能.md
Normal file
155
2023旧版内容/4.人工智能/4.人工智能.md
Normal file
@@ -0,0 +1,155 @@
|
||||
# 4.人工智能
|
||||
|
||||
## 开篇
|
||||
|
||||
对于所谓 AI 的开篇该怎么写，我思考了很久，因为这实在是太过于宏大的话题了，从 2012 年开始这个行业迎来了所谓的技术爆炸阶段
|
||||
|
||||
> 宇宙的时间尺度来看，一个文明的技术在科技发展的过程中，可能短时间内快速发展、科技发展速度不断增加的现象 --------《三体》
|
||||
|
||||
无论是工业界还是科研界似乎都在这轮发展中进入了一场狂欢，但是狂欢之下，时代的滚滚洪流，也引起了不少人的焦虑和恐慌。
|
||||
|
||||
我们人类在如此宏大的课题面前，我们将得到什么？又将会失去什么呢？也许只有时间可以告诉我们答案。
|
||||
|
||||
阅读本篇内容的群体，我想主要是自动化或计算机的大学生，更多的是没有基础的同学才会翻阅。
|
||||
|
||||
因此本篇不将技术，笔者将从自己的视角，笔者进入大学到现在对所谓 AI 发展的思想感受的变迁为明线，为将要开启人工智能学习的大伙勾勒出一个笔者眼中的，**人工智能**时代。
|
||||
|
||||
同时，我也会在本篇内容中给你，你可以在本篇内容中获得什么。
|
||||
> 这是一个最好的时代，也是一个最坏的时代；
|
||||
>
|
||||
> 这是一个智慧的年代，这是一个愚蠢的年代；
|
||||
>
|
||||
> 这是一个信任的时期，这是一个怀疑的时期。
|
||||
>
|
||||
> 这是一个光明的季节，这是一个黑暗的季节；
|
||||
>
|
||||
> 这是希望之春，这是失望之冬；
|
||||
>
|
||||
> 人们面前应有尽有，人们面前一无所有；
|
||||
>
|
||||
> 人们正踏上天堂之路，人们正走向地狱之门。
|
||||
>
|
||||
> ——《双城记》查尔斯·狄更斯
|
||||
|
||||
## 看山是山
|
||||
|
||||
2020 年，在一门杭电的程序设计实践课上，老师要求我们用 C 语言去实现一些算法，我本来是将目标定为去大厂赚更多的钱的，对所谓 AI 仅仅停留在概念上，对其内容一无所知。
|
||||
|
||||
在实验的过程中，偶然和一位转专业学长偶然聊起到程设变态难得题目设计，要求用 C 语言实现 KNN 之类的算法，这 TM 对于我当时的水平简直是太难了！聊到他自己所在的某个实验室本科生的入组任务也不过是这个难度偏低一点点。
|
||||
|
||||
带着投机主义的心态，想着能不能混到一些论文之类的成果更好就业，毅然决然上了船。
|
||||
|
||||
当然，这也是大伙可能愿意去看这篇文章或抱着本科生科研的心态去学习本篇讲义或学习人工智能的主要心态。
|
||||
|
||||
可能还有一些人想的是我学一下这个相关技术可以更好的打比赛或者做项目，都是在我“看山是山"的阶段有过的。
|
||||
|
||||
对所谓的科研，所谓的论文，所谓的项目的含金量都是一知半解，只不过是“看到感觉他很火，感觉他很好，具体怎么样我不知道”的心态。这也是在当时的市场上，很多人的心态，由此也是人工智能第一轮狂潮的热点所在，因为大家其实很多都不清楚这个新技术，究竟有什么样的上线，吹起了很大的泡泡。
|
||||
|
||||
就算是有点远见的本科生，也仅仅是看到了所谓的 CV 和 NLP 在学校和整个社会大规模宣传下的科普性的概念，也许也没有深入了解过，当时的我也一样。但是我也陷入了同样的狂热中，仅仅是因为他足够火热或有足够的前景，我就想着跟随着潮流走。
|
||||
|
||||
我看了一点非常基础的教程，老师便给我发了两篇非常刺激的 CV 论文，都是他专业下比较前沿的文章了，我对这到底意味着什么仍然是一无所知，我完全没有搭建起合理的知识框架，我眼里 AI 只有深度学习，只有用框架写的那几行短短的代码，于是开启了受难之旅。
|
||||
|
||||
老师并没有做错什么，他只是在这个人工智能大潮下的一朵浪花，他也尽其所能的做到了对本科学生的关注，错的是我，我没有仔细考究过，也没有站在足够高的角度去审视如果我加入了他的工作，我在这个行业中会处在什么样的位置。
|
||||
|
||||
**这也是本篇讲义想要做到的第一件事，让你可以从比较高的角度去搭建起对这个领域的知识框架，而不是贸然的进入某个领域然后发现自己不喜欢或者说自己“被坑了”。**
|
||||
|
||||
## 看山不是山
|
||||
|
||||
学习过程非常恐怖的一件事就是完全没有正反馈，我在阅读论文的时候面对的是我对他无数前置工作一无所知的情况，并且我完全不知道怎么入手去读一个纯英文论文，我也不知道做科研到底意味着什么？
|
||||
|
||||
**这也是本篇讲义想要做到的第二件事，让你可以阅读一些文章之后就有一个大致的方法论而不至于完全手足无措。在本章的如何做研究和如何科研论文写作的篇章里面。**
|
||||
|
||||
短短的两篇文章我足足啃了一个假期，去读了很多东西，看了很多文章，但是自己究竟学会了什么其实也是答不上来，唯一能带给我的欣喜就是我复现了那篇文章，我让他在自己想要的数据集上跑起来了，但是也没有什么太大的成就感，因为唯一可以看到的仅仅只是跳动的数字和分割出来效果极其糟糕的几张图片。
|
||||
|
||||
紧接着我阅读了更多的论文，带给我的只有更多的负反馈，我不清楚将前两个论文串起来为什么就变成了一个创新点，我不清楚为什么论文写的代码里没有，我也不清楚代码为什么那样写，创新方案为什么要做成那样？我最大的疑惑其实是我们在不断堆积数据和算力，这样也能叫科研吗？而他们却又真真切切的发表在了那些顶刊上？这合理吗？
|
||||
|
||||
我刚刚对科研建立起的美好神圣的幻想，被一篇又一篇近乎重复的论文打的粉碎，让我不禁身心俱疲。我根本不相信靠眼前这些，被当时的我定义为“学术垃圾”的论文能掀起什么风浪。可我也不知道到底什么样才是真正的科研，不知道我该怎么做。
|
||||
|
||||
当时唯一支撑我的是某位老师的观点，她认为科技的进步和学术的发展正是建立在无意义的沙堆上的。正是这高耸的沙堆，才让人们可以清晰的看见沙堆上蚌中的珍珠散发着耀眼的光。尽管很多看起来现在无用，也许几年后，他被挖掘出来，就会发挥新的作用，我对此完全不理解，只是觉得深度学习目前这个研究方向，为什么大方向这么不可理喻。
|
||||
|
||||
当时的我还看到了，因为他的爆火，带来了非常优秀的工具链，极大程度的降低了门槛。科研界将电子斗蛐蛐奉为圭臬，比赛和项目只是劳动力和资源的无限叠加堆砌出来结果亦或是单纯的硬扯，工业界不知道在搞些什么名堂，好像仅仅只知道跟着国外的脚步走。（甚至你在现在的讲义中仍然能发现一些我当时的看法）
|
||||
|
||||
很多本科生诚然发了优秀的论文，可他也不过是一颗坚挺的或者优秀的螺丝钉，在正确的时间，正确的位置，做了不知道正确还是错误的事，让他取得了不属于他目前能力的成就。无论是老师还是学生都被迫进入了这一场狂欢然后做了也许不那么正义的事情。
|
||||
|
||||
**我厌恶他！我厌恶他破坏了科研的纯洁性！我厌恶他成为了急功近利者的帮凶！我厌恶他堆砌的沙堆是充斥着无产者的血和泪！我厌恶他让马太效应发挥到了极致！我厌恶他让所有人都贴上了他的面具，但可能对本质上的东西一无所知！我厌恶他只注重结果，完全不注重过程然后让写的故事变成了捏造！**
|
||||
|
||||
但是，现在我会说，也许当时的我真的错了。我并没有思考过所谓人类的智能和 AI 的智能的关系，也忽视了当某一个趋势或方向发展到极致之后，量变会引发什么样的质变。
|
||||
|
||||
[推荐大伙可以看看这个](https://www.bilibili.com/video/BV11c41157aU)
|
||||
|
||||
<Bilibili bvid='BV11c41157aU'/>
|
||||
|
||||
## 看山还是山
|
||||
|
||||
> 孟德尔出生于奥地利帝国（今天的捷克共和国）的西里西亚，是现代遗传学的创始人。尽管几千年来农民就知道动植物的杂交可以促进某些理想的性状，但孟德尔在 1856 年至 1863 年之间进行的豌豆植物实验建立了许多遗传规则，现称为孟德尔定律。
|
||||
|
||||
在孟德尔那个时代，人们不知道基因，人们也看不到那么小的东西，他给基因取了个名字叫遗传因子。他没能掌握“真实的规律”，可是我们不得不承认的是，他是一个真正有科研精神的人的科研人。 -
|
||||
|
||||
我在不断地绝望之后，走向了极端，我放弃了跟进这个方面的学习，孟尝高洁，空余报国之情；阮籍猖狂，岂效穷途之哭！我失去了搞科研的热情，只想一心去做些别的。
|
||||
|
||||
我看到了南大的课程，我去看一生一芯，去看 jyy 老师的 OS，我听到了蒋老师对未来 AI 的发展充满了信心，我虽然很崇拜他，但我仍对此嗤之以鼻，我不相信。
|
||||
|
||||
一直到有一天，相先生在实验室玩一个叫 chatGPT 的东西，虽然之前懵懵懂懂的有了解过 GPT3 之类的东西，但是都对此行的发展没有什么了解，只是知道他又非常大的参数的语言模型，在好奇之下，我去亲自体验 chat GPT，我受震惊于他能准确无误的理解我的意思，甚至能替我写代码，只要将问题拆解，他几乎可以就任何一个问题给出一个反而化之的答案。
|
||||
|
||||
随后没过多久，GPT4 与 new bing 应运而生，可以理解用户的意图和情感，根据用户的偏好和反馈来调整输出，甚至利用网络搜索来增强其的知识和回答能力，他们还结合了 CV 的功能，可以让他们来进行图像的生成工作。作为科研人的最高追求，大一统，一通半通的解决所有问题的模型竟然真的可能在我的有生之年实现，不由得震惊至极。同时，大模型也进入了 CV 领域，出现了 segmenting anything 这样可以做到零样本迁移这样的神奇功能，auto GPT 出现了在电脑主机上直接替人解决问题甚至是完成某一项工程任务的 GPT，以及可以在手机上本地做的 mini GPT，技术的爆炸以及变革似乎一瞬间到来了，但是当我回过头展望的时候，正是我最看不起的沙砾，堆叠成了如此强大石之巨人，并且随着资本的涌入，他还在不断强大！！！
|
||||
|
||||
2012 年，被我们认定为人工智能学习的开篇之作，Alex net 诞生了，由 Alex Krizhevsky 和他的导师 Geoffrey Hinton 以及 Ilya Sutskever 设计，在 2012 年的 ImageNet 大规模视觉识别挑战赛中获得了冠军，展示了深度学习在图像分类方面的强大能力，并且正式启动了深度学习的革命，在当时他也引发了大量的争议，奉承这符号主义的大师们对着他指指点点，可是他们并不能阻碍时代的巨石碾过一切非议，并且在各个领域都爆发出极其强大的生命力。
|
||||
|
||||
想起在学操作系统的时候，linus 在几十年前被大老师 tanenbaum 狂喷，说整了什么垃圾玩意儿。当时的 minix 基本上可以说是横扫江湖，linus 却坚持说用户只考虑用户态是否好用而不在乎内核有多牛逼，当时的论战基本上把各类大神都炸出来，结果几十年后的如今我们发现原来遍布世界的居然是宏内核/混合内核。
|
||||
|
||||
时代的发展连大佬都可以拍死在沙滩上！
|
||||
|
||||
从短期来看，也许未来 GPT 会接管小 AI 形成一套上下左右俱为一体的 AI 智能模型，在所谓自动驾驶，智能家居领域发挥极其卓越的作用。
|
||||
|
||||
从长远来看，不由得联想起 AI 在围棋方面 alpha zero 的论文里面提到过，当他们不适用人类的知识的时候，反而模型的效果好很多，有没有可能 AI 在短短的未来总结出一套人类自然语言的规则后，自发创造出一个全新的语言，最终就彻底脱离人类变成一种全新的生命形式，从而彻底颠覆人类以公理为基础的数学，创造一套全新的数学体系，数学体系重做，物理学是否也会迎来质变？
|
||||
|
||||
AI 是一个复杂且多样化的研究领域，他能取得如此长远的发展，并非是仅仅一个两个人靠着所谓的理论研究就可以推动起来的，它伴随着底层的硬件设施配套的完善，算力的突破性增长等等，发展本身，也许就是兼容并蓄的，我们应该在这个发展的洪流前，找到自己的位置以更为谦卑谨慎的姿态，进行更为长远的思考和学习吧。
|
||||
|
||||
> 三花聚顶本是幻，脚下腾云亦非真。大梦一场终须醒，无根无极本归尘。
|
||||
|
||||
## 结语
|
||||
|
||||
让我们回到最开始的那几句话
|
||||
这是一个最好的时代（AI 技术正在改变人们的生活）
|
||||
|
||||
也是一个最坏的时代（AI 也许取代大量人的饭碗）
|
||||
|
||||
这是一个智慧的年代（很多顶尖的科学家正在改变世界）
|
||||
|
||||
这是一个愚蠢的年代（很多高校止步于电子斗蛐蛐，很多企业只想着追赶外国不想着自己创新）
|
||||
|
||||
这是一个信任的时期（人们将更加信任这个社会会因此变好）
|
||||
|
||||
这是一个怀疑的时期（AI 技术带来伦理，毁灭世界等方面的讨论）
|
||||
|
||||
这是一个光明的季节（前沿科研或科技从来没有离普通的本科生这么近）
|
||||
|
||||
这是一个黑暗的季节（太近了导致很多人急功近利）
|
||||
|
||||
这是希望之春（我们迎来了技术爆炸）
|
||||
|
||||
这是失望之冬（我国仍有很多需要发展的地方）
|
||||
|
||||
人们面前应有尽有（人们以后可能拥有了 AI 也就拥有了一切）
|
||||
|
||||
人们面前一无所有（隐私，版权，安全等问题正在受到质疑）
|
||||
|
||||
人们正踏上天堂之路（也许未来人类不用干任何工作实现真正的共产主义）
|
||||
|
||||
人们正走向地狱之门（也许人类将被取代将被奴役，无数人会被取代）
|
||||
|
||||
技术的发展往往就伴随着激烈的争议和讨论
|
||||
|
||||
火车出现的年代人们责怪他破坏风水
|
||||
|
||||
蒸汽机出现的时代人指责他不安全
|
||||
|
||||
纺织机出现的时代女工辱骂他抢了自己工作
|
||||
|
||||
而这些都不会使他停滞
|
||||
|
||||
**这是本讲义想做的第三件事，拥有学习新技术，跟上时代的能力**
|
||||
|
||||
而愿不愿意在这激荡翻腾的年份，贡献出你的力量，让世界变得更好/更坏，就取决于你的选择了！
|
||||
|
||||
## 欢迎来到新世界！同学们！
|
||||
95
2023旧版内容/4.人工智能/ch01/ch1.1.md
Normal file
95
2023旧版内容/4.人工智能/ch01/ch1.1.md
Normal file
@@ -0,0 +1,95 @@
|
||||
# 推荐系统的意义
|
||||
|
||||
随着移动互联网的飞速发展，人们已经处于一个信息过载的时代。在这个时代中，信息的生产者很难将信息呈现在对它们感兴趣的信息消费者面前，而对于信息消费者也很难从海量的信息中找到自己感兴趣的信息。推荐系统就是一个将信息生产者和信息消费者连接起来的桥梁。平台往往会作为推荐系统的载体，实现信息生产者和消费者之间信息的匹配。上述提到的平台方、信息生产者和消费者可以分别用平台方（如：腾讯视频、淘宝、网易云音乐等）、物品（如：视频、商品、音乐等）和用户和来指代。下面分别从这三方需求出发，介绍推荐系统的存在的意义。
|
||||
|
||||
|
||||
## 平台方
|
||||
|
||||
平台方一般是为信息生产者提供物品展示的位置，然后通过不同的方式吸引用户来到平台上寻找他们感兴趣的物品。平台通过商家对物品的展示以及用户的浏览、观看或下单等行为，就产生了所谓的"流量"。
|
||||
|
||||
对平台方而言，流量的高效利用是推荐系统存在的重要原因。以典型的电商网站一般具有如图所示的树状拓扑结构，树状结构在连通性方面有着天然的劣势，阻碍这流量的高效流通。推荐系统的出现使得原本的树状结构变成网络拓扑结构，大大增强了整个网络的连通性。推荐模块不仅使用户在当前页面有了更好的选择路径，同时也给了每个商品增加入口和展示机会，进而提高了成交概率。而推荐质量的好坏，直接决定了用户选择这条路径的可能性，进而影响着流量的利用效率。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://typoraimg-1252051831.cos.ap-guangzhou.myqcloud.com/image-20220514232543182.png" alt="image-20220514232543182" style="zoom: 80%;" />
|
||||
</div>
|
||||
|
||||
推荐系统解决产品能够最大限度地吸引用户、留存用户、增加用户粘性、提高用户转化率的问题，从而达到平台商业目标增长的目的。不同平台的目标取决于其商业的盈利目的，例如对于YouTube，其商业目标是最大化视频被点击（点击率）以及用户观看的时长（完播率），同时也会最大化内置广告的点击率；对于淘宝等电商平台，除了最大化商品的点击率外，最关键的目标则是最大化用户的转化率，即由点击到完成商品购买的指标。推荐系统能够平台带来丰厚的商业价值 。
|
||||
|
||||
|
||||
## 信息生产者(物品)
|
||||
|
||||
因为在互联网大数据时代下，物品的长尾性和二八原则是非常严重的。具体来说，对于一个平台而言80%的销售额可能是那些最畅销20%的物品。但是那20%的物品其实只能满足一小部分人的需求，对于绝大多数的用户的需求需要从那80%的长尾物品中去满足。虽然长尾物品的总销售额占比不大，但是因为长尾物品的数量及其庞大，如果可以充分挖掘长尾物品，那这些长尾物品的销售额的总量有可能会超过热门商品。
|
||||
|
||||
物品只是信息生产者的产物，对于信息生产者而言，例如商家、视频创作者等，他们也更希望自己生产的内容可以得到更多的曝光，尤其是对于新来的商家或者视频创作者，这样可以激发他们创作的热情，进而创作出更多的商品或者视频，让更多的用户的需求得到满足。
|
||||
|
||||
对于一个平台而言，无论是否靠平台上的物品直接盈利，其将平台上的内容与用户进行匹配的能力都是衡量平台的重要标准之一，推荐系统的好坏很大程度上决定了平台匹配需求和供给的能力。推荐系统匹配需求和供给的能力决定了其最终的商业价值。
|
||||
|
||||
|
||||
## 信息消费者(用户)
|
||||
|
||||
推荐系统对于用户而言，除了将平台上的需求和供给进行匹配外，还需要尽可能地提高用户的体验，但是对于一个平台来说，影响用户体验的因素非常多（产品设计、广告数量等）。对于一个有明确需求的用户来说，用户在平台上可以直接通过搜索来快速满足自己的需求，但这也仅仅是一个平台最基础的用户体验（平台做的好是应该的，但是做的不好可能会被喷）。对于一个没有明确需求的用户来说，用户会通过浏览平台上的推荐页来获取一些额外的惊喜需求。因为用户没有明确的需求，也就对推荐页浏览的内容没有明确的预期，但是并不说明用户没有期待。我们每天都希望自己的一天中充满惊喜，这样生活才会感觉更加的多姿多彩。推荐系统可以像为用户准备生日礼物一样，让呈现的内容给用户带来惊喜，进而增强用户对平台的依赖。此外，在给用户带来惊喜的同时，也会提高平台的转化率（例如成交额）
|
||||
|
||||
|
||||
## 推荐和搜索的区别
|
||||
|
||||
搜索和推荐都是解决互联网大数据时代信息过载的手段，但是它们也存在着许多的不同：
|
||||
1. **用户意图**：搜索时的用户意图是非常明确的，用户通过查询的关键词主动发起搜索请求。对于推荐而言，用户的需求是不明确的，推荐系统在通过对用户历史兴趣的分析给用户推荐他们可能感兴趣的内容。
|
||||
2. **个性化程度**：对于搜索而言，由于限定的了搜索词，所以展示的内容对于用户来说是有标准答案的，所以搜索的个性化程度较低。而对于推荐来说，推荐的内容本身就是没有标准答案的，每个人都有不同的兴趣，所以每个人展示的内容，个性化程度比较强。
|
||||
3. **优化目标**：对于搜索系统而言，更希望可以快速地、准确地定位到标准答案，所以希望搜索结果中答案越靠前越好，通常评价指标有：归一化折损累计收益（NDCG）、精确率（Precision）和召回率（Recall）。对于推荐系统而言，因为没有标准的答案，所以优化目标可能会更宽泛。例如用户停留时长、点击、多样性，评分等。不同的优化目标又可以拆解成具体的不同的评价指标。
|
||||
4. **马太效应和长尾理论**：对于搜索系统来说，用户的点击基本都集中在排列靠前的内容上，对于排列靠后的很少会被关注，这就是马太效应。而对于推荐系统来说，热门物品被用户关注更多，冷门物品不怎么被关注的现象也是存在的，所以也存在马太效应。此外，在推荐系统中，冷门物品的数量远远高于热门物品的数量，所以物品的长尾性非常明显。
|
||||
|
||||
> 对于搜索、推荐、广告这三个领域的区别和联系可以参考王喆老师写的[排得更好VS估得更准VS搜的更全「推荐、广告、搜索」算法间到底有什么区别？](https://zhuanlan.zhihu.com/p/430431149)
|
||||
|
||||
## 推荐系统的应用
|
||||
个性化推荐系统通过分析用户的行为日志，得到用户当前的甚至未来可能的兴趣，给不同的用户展示不同的(个性化)的页面，来提高网站或者app的点击率、转化率、留存率等指标。推荐系统被广泛应用在广告、电商、影视、音乐、社交、饮食、阅读等领域。下面简单的通过不同的app的推荐页来感受一下推荐系统在各个内容平台的存在形式。
|
||||
|
||||
- **电商首页推荐(淘宝、京东、拼多多)**
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220421190313917.png" alt="image-20220421190313917" style="zoom: 15%;" />
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220421191138469.png" alt="image-20220421191138469" style="zoom:53%;" />
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220421191441104.png" alt="image-20220421191441104" style="zoom:53%;" />
|
||||
</div>
|
||||
|
||||
- **视频推荐（抖音、快手、B站、爱奇艺）**
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220421190629410.png" alt="image-20220421190629410" style="zoom:55%;" />
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220421191849577.png" alt="image-20220421191849577" style="zoom: 53%;" />
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220421192047973.png" alt="image-20220421192047973" style="zoom:53%;" />
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220421192209412.png" alt="image-20220421192209412" style="zoom:55%;" />
|
||||
</div>
|
||||
|
||||
|
||||
- **饮食推荐（美团、饿了么、叮咚买菜）**
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220421192623380.png" alt="image-20220421192623380" style="zoom:53%;" />
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220421192717773.png" alt="image-20220421192717773" style="zoom:55%;" />
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220421192749794.png" alt="image-20220421192749794" style="zoom:55%;" />
|
||||
</div>
|
||||
|
||||
|
||||
- **音乐电台（网易云音乐、QQ音乐、喜马拉雅）**
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220421193139183.png" alt="image-20220421193139183" style="zoom: 57%;" />
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220421193447933.png" alt="image-20220421193447933" style="zoom:68%;" />
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220421193325921.png" alt="image-20220421193325921" style="zoom: 54%;" />
|
||||
</div>
|
||||
|
||||
|
||||
- **资讯、阅读（头条、知乎、豆瓣）**
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220421193856262.png" alt="image-20220421193856262" style="zoom:53%;" />
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220421193923283.png" alt="image-20220421193923283" style="zoom:55%;" />
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220421194244083.png" alt="image-20220421194244083" style="zoom:55%;" />
|
||||
</div>
|
||||
|
||||
|
||||
**参考资料：**
|
||||
|
||||
- 《推荐系统实践》
|
||||
- 《从零开始构建企业级推荐系统》
|
||||
- 《智能搜索和推荐系统》
|
||||
174
2023旧版内容/4.人工智能/ch01/ch1.2.md
Normal file
174
2023旧版内容/4.人工智能/ch01/ch1.2.md
Normal file
@@ -0,0 +1,174 @@
|
||||
# 推荐系统架构
|
||||
推荐和搜索系统核心的的任务是从海量物品中找到用户感兴趣的内容。在这个背景下，推荐系统包含的模块非常多，每个模块将会有很多专业研究的工程和研究工程师，作为刚入门的应届生或者实习生很难对每个模块都有很深的理解，实际上也大可不必，我们完全可以从学习好一个模块技术后，以点带面学习整个系统，虽然正式工作中我们放入门每个人将只会负责的也是整个系统的一部分。但是掌握推荐系统最重要的还是梳理清楚整个推荐系统的架构，知道每一个部分需要完成哪些任务，是如何做的，主要的技术栈是什么，有哪些局限和可以研究的问题，能够对我们学习推荐系统有一个提纲挈领的作用。
|
||||
|
||||
所以这篇文章将会从**系统架构**和**算法架构**两个角度出发解析推荐系统通用架构。系统架构设计思想是大数据背景下如何有效利用海量和实时数据，将推荐系统按照对数据利用情况和系统响应要求出发，将整个架构分为**离线层、近线层、在线层**三个模块。然后分析这三个模块分别承担推荐系统什么任务，有什么制约要求。这种角度不和召回、排序这种通俗我们理解算法架构，因为更多的是考虑推荐算法在工程技术实现上的问题，系统架构是如何权衡利弊，如何利用各种技术工具帮助我们达到想要的目的的，方便我们理解为什么推荐系统要这样设计。
|
||||
|
||||
而算法架构是从我们比较熟悉的**召回、粗排、排序、重排**等算法环节角度出发的，重要的是要去理解每个环节需要完成的任务，每个环节的评价体系，以及为什么要那么设计。还有一个重要问题是每个环节涉及到的技术栈和主流算法，这部分非常重要而且篇幅较大，所以我们放在下一个章节讲述。
|
||||
|
||||
架构设计是一个非常大的话题，设计的核心在于平衡和妥协。在推荐系统不同时期、不同的环境、不同的数据，架构都会面临不一样的问题。网飞官方博客有一段总结：
|
||||
|
||||
> We want the ability to use sophisticated machine learning algorithms that can grow to arbitrary complexity and can deal with huge amounts of data. We also want an architecture that allows for flexible and agile innovation where new approaches can be developed and plugged-in easily. Plus, we want our recommendation results to be fresh and respond quickly to new data and user actions. Finding the sweet spot between these desires is not trivial: it requires a thoughtful analysis of requirements, careful selection of technologies, and a strategic decomposition of recommendation algorithms to achieve the best outcomes for our members.
|
||||
> **“我们需要具备使用复杂机器学习算法的能力，这些算法要可以适应高度复杂性，可以处理大量数据。我们还要能够提供灵活、敏捷创新的架构，新的方法可以很容易在其基础上开发和插入。而且，我们需要我们的推荐结果足够新，能快速响应新的数据和用户行为。找到这些要求之间恰当的平衡并不容易，需要深思熟虑的需求分析，细心的技术选择，战略性的推荐算法分解，最终才能为客户达成最佳的结果。”**
|
||||
|
||||
所以在思考推荐系统架构考虑的第一个问题是确定边界：知道推荐系统要负责哪部分问题，这就是边界内的部分。在这个基础上，架构要分为哪几个部分，每一部分需要完成的子功能是什么，每一部分依赖外界的什么。了解推荐系统架构也和上文讲到的思路一样，我们需要知道的是推荐系统要负责的是怎么问题，每一个子模块分别承担了哪些功能，它们的主流技术栈是什么。从这个角度来阅读本文，将会有助于读者抓住重点。
|
||||
|
||||
## 系统架构
|
||||
|
||||
推荐系统架构，首先从数据驱动角度，对于数据，最简单的方法是存下来，留作后续离线处理，**离线层**就是我们用来管理离线作业的部分架构。**在线层**能更快地响应最近的事件和用户交互，但必须实时完成。这会限制使用算法的复杂性和处理的数据量。离线计算对于数据数量和算法复杂度限制更少，因为它以批量方式完成，没有很强的时间要求。不过，由于没有及时加入最新的数据，所以很容易过时。
|
||||
|
||||
个性化架构的关键问题，就是如何以无缝方式结合、管理在线和离线计算过程。**近线层**介于两种方法之间，可以执行类似于在线计算的方法，但又不必以实时方式完成。这种设计思想最经典的就是Netflix在2013年提出的架构，整个架构分为
|
||||
|
||||
1. 离线层：不用实时数据，不提供实时响应；
|
||||
2. 近线层：使用实时数据，不保证实时响应；
|
||||
3. 在线层：使用实时数据，保证实时在线服务；
|
||||
|
||||
### 设计思想
|
||||
网飞的这个架构提出的非常早，其中的技术也许不是现在常用的技术了，但是架构模型仍然被很多公司采用。
|
||||
|
||||
这个架构为什么要这么设计，本质上是因为推荐系统是由大量数据驱动的，大数据框架最经典的就是lambda架构和kappa架构。而推荐系统在不同环节所使用的数据、处理数据的量级、需要的读取速度都是不同的，目前的技术还是很难实现一套端到端的及时响应系统，所以这种架构的设计本质上还是一种权衡后的产物，所以有了下图这种模型：
|
||||
|
||||
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220409205047285.png" alt="在这里插入图片描述" style="zoom:70%;" />
|
||||
</div>
|
||||
|
||||
上面是网飞的原图，我搬运了更加容易理解的线条梳理后的结构：
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220409204658032.png" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
整个数据部分其实是一整个链路，主要是三块，分别是客户端及服务器实时数据处理、流处理平台准实时数据处理和大数据平台离线数据处理这三个部分。
|
||||
|
||||
看到这里，一个很直观的问题就是，为什么数据处理需要这么多步骤？这些步骤都是干嘛的，存在的意义是什么？
|
||||
|
||||
我们一个一个来说，首先是客户端和服务端的实时数据处理。这个很好理解，这个步骤的工作就是记录。将用户在平台上真实的行为记录下来，比如用户看到了哪些内容，和哪些内容发生了交互，和哪些没有发生了交互。如果再精细一点，还会记录用户停留的时间，用户使用的设备等等。除此之外还会记录行为发生的时间，行为发生的session等其他上下文信息。
|
||||
|
||||
这一部分主要是后端和客户端完成，行业术语叫做埋点。所谓的埋点其实就是记录点，因为数据这种东西需要工程师去主动记录，不记录就没有数据，记录了才有数据。既然我们要做推荐系统，要分析用户行为，还要训练模型，显然需要数据。需要数据，就需要记录。
|
||||
|
||||
第二个步骤是流处理平台准实时数据处理，这一步是干嘛的呢，其实也是记录数据，不过是记录一些准实时的数据。很多同学又会迷糊了，实时我理解，就是当下立即的意思，准实时是什么意思呢？准实时的意思也是实时，只不过没有那么即时，比如可能存在几分钟的误差。这样存在误差的即时数据，行业术语叫做准实时。那什么样的准实时数据需要记录呢？在推荐领域基本上只有一个类别，就是用户行为数据。也就是用户在观看这个内容之前还看过哪些内容，和哪些内容发生过交互。理想情况这部分数据也需要做成实时，但由于这部分数据量比较大，并且逻辑也相对复杂，所以很难做到非常实时，一般都是通过消息队列加在线缓存的方式做成准实时。
|
||||
|
||||
最后我们看第三个步骤，叫做离线数据处理，离线也就是线下处理，基本上就没有时限的要求了。
|
||||
|
||||
一般来说，离线处理才是数据处理的大头。所有“脏活累活”复杂的操作都是在离线完成的，比如说一些join操作。后端只是记录了用户交互的商品id，我们需要商品的详细信息怎么办？需要去和商品表关联查表。显然数据关联是一个非常耗时的操作，所以只能放到离线来做。
|
||||
|
||||
接下来详细介绍一下这三个模块。
|
||||
|
||||
### 离线层
|
||||
离线层是计算量最大的一个部分，它的特点是不依赖实时数据，也不需要实时提供服务。需要实现的主要功能模块是：
|
||||
|
||||
1. 数据处理、数据存储；
|
||||
2. 特征工程、离线特征计算；
|
||||
3. 离线模型的训练；
|
||||
|
||||
这里我们可以看出离线层的任务是最接近学校中我们处理数据、训练模型这种任务的，不同可能就是需要面临更大规模的数据。离线任务一般会按照天或者更久运行，比如每天晚上定期更新这一天的数据，然后重新训练模型，第二天上线新模型。
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220409205904314.png" alt="在这里插入图片描述" style="zoom:70%;" />
|
||||
</div>
|
||||
|
||||
#### 离线层优势和不足
|
||||
离线层面临的数据量级是最大的，面临主要的问题是海量数据存储、大规模特征工程、多机分布式机器学习模型训练。目前主流的做法是HDFS，收集到我们所有的业务数据，通过HIVE等工具，从全量数据中抽取出我们需要的数据，进行相应的加工，离线阶段主流使用的分布式框架一般是Spark。所以离线层有如下的优势：
|
||||
1. 可以处理大量的数据，进行大规模特征工程；
|
||||
2. 可以进行批量处理和计算；
|
||||
3. 不用有响应时间要求；
|
||||
|
||||
但是同样的，如果我们只使用用户离线数据，最大的不足就是无法反应用户的实时兴趣变化，这就促使了近线层的产生。
|
||||
|
||||
### 近线层
|
||||
近线层的主要特点是准实时，它可以获得实时数据，然后快速计算提供服务，但是并不要求它和在线层一样达到几十毫秒这种延时要求。近线层的产生是同时想要弥补离线层和在线层的不足，折中的产物。
|
||||
|
||||
它适合处理一些对延时比较敏感的任务，比如：
|
||||
1. 特征的事实更新计算：例如统计用户对不同type的ctr，推荐系统一个老生常谈的问题就是特征分布不一致怎么办，如果使用离线算好的特征就容易出现这个问题。近线层能够获取实时数据，按照用户的实时兴趣计算就能很好避免这个问题。
|
||||
2. 实时训练数据的获取：比如在使用DIN、DSIN这行网络会依赖于用户的实时兴趣变化，用户几分钟前的点击就可以通过近线层获取特征输入模型。
|
||||
3. 模型实时训练：可以通过在线学习的方法更新模型，实时推送到线上；
|
||||
|
||||
近线层的发展得益于最近几年大数据技术的发展，很多流处理框架的提出大大促进了近线层的进步。如今Flink、Storm等工具一统天下。
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220409205830027.png" alt="在这里插入图片描述" style="zoom:70%;" />
|
||||
</div>
|
||||
|
||||
### 在线层
|
||||
在线层，就是直接面向用户的的那一层了。最大的特点是对响应延时有要求，因为它是直接面对用户群体的，你可以想象你打开抖音淘宝等界面，几乎都是秒刷出来给你的推荐结果的，不会说还需要让你等待几秒钟时间。所有的用户请求都会发送到在线层，在线层需要快速返回结果，它主要承担的工作有：
|
||||
|
||||
1. 模型在线服务；包括了快速召回和排序；
|
||||
2. 在线特征快速处理拼接：：根据传入的用户ID和场景，快速读取特征和处理；
|
||||
3. AB实验或者分流：根据不同用户采用不一样的模型，比如冷启动用户和正常服务模型；
|
||||
4. 运筹优化和业务干预：比如要对特殊商家流量扶持、对某些内容限流；
|
||||
|
||||
典型的在线服务是用过RESTful/RPC等提供服务，一般是公司后台服务部门调用我们的这个服务，返回给前端。具体部署应用比较多的方式就是使用Docker在K8S部署。而在线服务的数据源就是我们在离线层计算好的每个用户和商品特征，我们事先存放在数据库中，在线层只需要实时拼接，不进行复杂的特征运算，然后输入近线层或者离线层已经训练好的模型，根据推理结果进行排序，最后返回给后台服务器，后台服务器根据我们对每一个用户的打分，再返回给用户。
|
||||
|
||||
在线层最大的问题就是对实时性要求特别高，一般来说是几十毫秒，这就限制了我们能做的工作，很多任务往往无法及时完成，需要近线层协助我们做。
|
||||
## 算法架构
|
||||
|
||||
我们在入门学习推荐系统的时候，更加关注的是哪个模型AUC更高、topK效果好，哪个模型更加牛逼的问题，从基本的协同过滤到点击率预估算法，从深度学习到强化学习，学术界都始终走在最前列。一个推荐算法从出现到在业界得到广泛应用是一个长期的过程，因为在实际的生产系统中，首先需要保证的是稳定、实时地向用户提供推荐服务，在这个前提下才能追求推荐系统的效果。
|
||||
|
||||
算法架构的设计思想就是在实际的工业场景中，不管是用户维度、物品维度还是用户和物品的交互维度，数据都是极其丰富的，学术界对算法的使用方法不能照搬到工业界。当一个用户访问推荐模块时，系统不可能针对该用户对所有的物品进行排序，那么推荐系统是怎么解决的呢？对应的商品众多，如何决定将哪些商品展示给用户？对于排序好的商品，如何合理地展示给用户？
|
||||
|
||||
所以一个通用的算法架构，设计思想就是对数据层层建模，层层筛选，帮助用户从海量数据中找出其真正感兴趣的部分。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220409211354342.png" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
- 召回
|
||||
|
||||
召回层的主要目标时从推荐池中选取几千上万的item，送给后续的排序模块。由于召回面对的候选集十分大，且一般需要在线输出，故召回模块必须轻量快速低延迟。由于后续还有排序模块作为保障，召回不需要十分准确，但不可遗漏（特别是搜索系统中的召回模块）。
|
||||
|
||||
如果没有召回层，每个User都能和每一个Item去在线排序阶段预测目标概率，理论上来说是效果最好，但是是不现实的，线上不延迟允许，所以召回和粗排阶段就要做一些候选集筛选的工作，保证在有限的能够给到排序层去做精排的候选集的时间里，效果最大化。另一个方面就是通过这种模型级联的方式，可以减少用排序阶段拟合多目标的压力，比如召回阶段我们现在主要是在保证Item质量的基础上注重覆盖率多样性，粗排阶段主要用简单的模型来解决不同路的召回和当前用户的相关性问题，最后截断到1k个以内的候选集，这个候选集符合一定的个性化相关性、视频质量和多样性的保证，然后做ranking去做复杂模型的predict。
|
||||
|
||||
目前基本上采用多路召回解决范式，分为非个性化召回和个性化召回。个性化召回又有content-based、behavior-based、feature-based等多种方式。
|
||||
|
||||
召回主要考虑的内容有：
|
||||
|
||||
1. **考虑用户层面**：用户兴趣的多元化，用户需求与场景的多元化：例如：新闻需求，重大要闻，相关内容沉浸阅读等等
|
||||
2. **考虑系统层面**：增强系统的鲁棒性；部分召回失效，其余召回队列兜底不会导致整个召回层失效；排序层失效，召回队列兜底不会导致整个推荐系统失效
|
||||
3. **系统多样性内容分发**：图文、视频、小视频；精准、试探、时效一定比例；召回目标的多元化，例如：相关性，沉浸时长，时效性，特色内容等等
|
||||
4. **可解释性推荐一部分召回是有明确推荐理由的**：很好的解决产品性数据的引入；
|
||||
|
||||
- 粗排
|
||||
|
||||
粗排的原因是有时候召回的结果还是太多，精排层速度还是跟不上，所以加入粗排。粗排可以理解为精排前的一轮过滤机制，减轻精排模块的压力。粗排介于召回和精排之间，要同时兼顾精准性和低延迟。目前粗排一般也都模型化了，其训练样本类似于精排，选取曝光点击为正样本，曝光未点击为负样本。但由于粗排一般面向上万的候选集，而精排只有几百上千，其解空间大很多。
|
||||
|
||||
粗排阶段的架构设计主要是考虑三个方面，一个是根据精排模型中的重要特征，来做候选集的截断，另一部分是有一些召回设计，比如热度或者语义相关的这些结果，仅考虑了item侧的特征，可以用粗排模型来排序跟当前User之间的相关性，据此来做截断，这样是比单独的按照item侧的倒排分数截断得到更加个性化的结果，最后是算法的选型要在在线服务的性能上有保证，因为这个阶段在pipeline中完成从召回到精排的截断工作，在延迟允许的范围内能处理更多的召回候选集理论上与精排效果正相关。
|
||||
|
||||
- 精排
|
||||
|
||||
精排层，也是我们学习推荐入门最常常接触的层，我们所熟悉的算法很大一部分都来自精排层。这一层的任务是获取粗排模块的结果，对候选集进行打分和排序。精排需要在最大时延允许的情况下，保证打分的精准性，是整个系统中至关重要的一个模块，也是最复杂，研究最多的一个模块。
|
||||
|
||||
精排是推荐系统各层级中最纯粹的一层，他的目标比较单一且集中，一门心思的实现目标的调优即可。最开始的时候精排模型的常见目标是ctr,后续逐渐发展了cvr等多类目标。精排和粗排层的基本目标是一致的，都是对商品集合进行排序，但是和粗排不同的是，精排只需要对少量的商品(即粗排输出的商品集合的topN)进行排序即可。因此，精排中可以使用比粗排更多的特征，更复杂的模型和更精细的策略（用户的特征和行为在该层的大量使用和参与也是基于这个原因）。
|
||||
|
||||
精排层模型是推荐系统中涵盖的研究方向最多，有非常多的子领域值得研究探索，这也是推荐系统中技术含量最高的部分，毕竟它是直接面对用户，产生的结果对用户影响最大的一层。目前精排层深度学习已经一统天下了，精排阶段采用的方案相对通用，首先一天的样本量是几十亿的级别，我们要解决的是样本规模的问题，尽量多的喂给模型去记忆，另一个方面时效性上，用户的反馈产生的时候，怎么尽快的把新的反馈给到模型里去，学到最新的知识。
|
||||
|
||||
- 重排
|
||||
|
||||
常见的有三种优化目标：Point Wise、Pair Wise 和 List Wise。重排序阶段对精排生成的Top-N个物品的序列进行重新排序，生成一个Top-K个物品的序列，作为排序系统最后的结果，直接展现给用户。重排序的原因是因为多个物品之间往往是相互影响的，而精排序是根据PointWise得分，容易造成推荐结果同质化严重，有很多冗余信息。而重排序面对的挑战就是海量状态空间如何求解的问题，一般在精排层我们使用AUC作为指标，但是在重排序更多关注NDCG等指标。
|
||||
|
||||
重排序在业务中，获取精排的排序结果，还会根据一些策略、运营规则参与排序，比如强制去重、间隔排序、流量扶持等、运营策略、多样性、context上下文等，重新进行一个微调。重排序更多的是List Wise作为优化目标的，它关注的是列表中商品顺序的问题来优化模型，但是一般List Wise因为状态空间大，存在训练速度慢的问题。
|
||||
|
||||
由于精排模型一般比较复杂，基于系统时延考虑，一般采用point-wise方式，并行对每个item进行打分。这就使得打分时缺少了上下文感知能力。用户最终是否会点击购买一个商品，除了和它自身有关外，和它周围其他的item也息息相关。重排一般比较轻量，可以加入上下文感知能力，提升推荐整体算法效率。比如三八节对美妆类目商品提权，类目打散、同图打散、同卖家打散等保证用户体验措施。重排中规则比较多，但目前也有不少基于模型来提升重排效果的方案。
|
||||
|
||||
- 混排
|
||||
|
||||
多个业务线都想在Feeds流中获取曝光，则需要对它们的结果进行混排。比如推荐流中插入广告、视频流中插入图文和banner等。可以基于规则策略（如广告定坑）和强化学习来实现。
|
||||
|
||||
## 总结
|
||||
|
||||
整篇文章从系统架构梳理了Netfliex的经典推荐系统架构，整个架构更多是偏向实时性能和效果之间tradeoff的结果。如果从另外的角度看推荐系统架构，比如从数据流向，或者说从推荐系统各个时序依赖来看，就是我们最熟悉的召回、粗排、精排、重排、混排等模块了。这种角度来看是把推荐系统从前往后串起来，其中每一个模块既有在离线层工作的，也有在在线层工作的。而从数据驱动角度看，更能够看到推荐系统的完整技术栈，推荐系统当前面临的局限和发展方向。
|
||||
|
||||
召回、排序这些里面单拿出任何一个模块都非常复杂。这也是为什么大家都说大厂拧螺丝的原因，因为很可能某个人只会负责其中很小的一个模块。许多人说起自己的模块来如数家珍，但对于全局缺乏认识，带来的结果是当你某天跳槽了或者是工作内容变化了，之前从工作当中的学习积累很难沉淀下来，这对于程序员的成长来说是很不利的。
|
||||
|
||||
所以希望这篇文章能够帮助大家在负责某一个模块，优化某一个功能的时候，除了能够有算法和数据，还能能够考虑对整个架构带来的影响，如何提升整体的一个性能，慢慢开阔自己的眼界，构建出一个更好的推荐系统。
|
||||
|
||||
|
||||
|
||||
**参考资料**
|
||||
- 《从零开始构建企业级推荐系统》
|
||||
- [Netflix](https://netflixtechblog.com/system-architectures-for-personalization-and-recommendation-e081aa94b5d8)
|
||||
- [回顾经典，Netflix的推荐系统架构](https://zhuanlan.zhihu.com/p/114590897)
|
||||
- [大数据处理中的Lambda架构和Kappa架构](https://www.cnblogs.com/xiaodf/p/11642555.html)
|
||||
- [张俊林：推荐系统技术演进趋势](https://mp.weixin.qq.com/s?__biz=MzU1NTMyOTI4Mw==&mid=2247496363&idx=1&sn=0d2b2ac176e2a72eb2e760b7b591788f&chksm=fbd740c7cca0c9d16c76fdeb1a874a53f7408d8125b2e1bed3173ecb69d131167c1c9c35c71f&scene=21#wechat_redirect)
|
||||
- [推荐算法架构1：召回/等](https://blog.csdn.net/u013510838/article/details/123023259)
|
||||
- [微信"看一看"多模型内容策略与召回](https://mp.weixin.qq.com/s?__biz=MzU1NTMyOTI4Mw==&mid=2247503484&idx=2&sn=e2a2cdd3a517ab09e903e69ccb1e9f94&chksm=fbd77c10cca0f50642dde47439ed919aa2e61b7ff57bc4cbaacc3acaac3c620a1ed6f92684ab&scene=21#wechat_redirect)
|
||||
- [阿里粗排技术体系](https://mp.weixin.qq.com/s/CN3a4Zb4yEjgi4mkm2lX6w)
|
||||
- [推荐系统架构与算法流程详解](https://mp.weixin.qq.com/s/tgZIdYENwQqDScjt7R28EQ)
|
||||
- [业内推荐系统架构介绍](https://mp.weixin.qq.com/s/waLW4aULeLoOB54_X-CzdQ)
|
||||
- [推荐系统笔记，一张图看懂系统架构](https://mp.weixin.qq.com/s/Zj4lCBe2bYNT6uT2-d-pNg)
|
||||
200
2023旧版内容/4.人工智能/ch01/ch1.3.md
Normal file
200
2023旧版内容/4.人工智能/ch01/ch1.3.md
Normal file
@@ -0,0 +1,200 @@
|
||||
## 推荐系统的技术栈
|
||||
|
||||
推荐系统是一个非常大的框架，有非常多的模块在里面，完整的一套推荐系统体系里，不仅会涉及到推荐算法工程师、后台开发工程师、数据挖掘/分析工程师、NLP/CV工程师还有前端、客户端甚至产品、运营等支持。我们作为算法工程师，需要掌握的技术栈主要就是在算法和工程两个区域了，所以这篇文章将会分别从算法和工程两个角度出发，结合两者分析当前主流的一些推荐算法技术栈。
|
||||
|
||||
## 算法
|
||||
|
||||
首先我们从推荐系统架构出发，一种分法是将整个推荐系统架构分为召回、粗排、精排、重排、混排等模块。它的分解方法是从一份数据如何从生产出来，到线上服务完整顺序的一个流程。因为在不同环节，我们一般会考虑不同的算法，所以这种角度出发我们来研究推荐系统主流的算法技术栈。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220409211354342.png" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
为了帮助新手在后文方便理解，首先简单介绍这些模块的功能主要是：
|
||||
- 召回：从推荐池中选取几千上万的item，送给后续的排序模块。由于召回面对的候选集十分大，且一般需要在线输出，故召回模块必须轻量快速低延迟。由于后续还有排序模块作为保障，召回不需要十分准确，但不可遗漏（特别是搜索系统中的召回模块）。目前基本上采用多路召回解决范式，分为非个性化召回和个性化召回。个性化召回又有content-based、behavior-based、feature-based等多种方式。
|
||||
- 粗排：粗拍的原因是有时候召回的结果还是太多，精排层速度还是跟不上，所以加入粗排。粗排可以理解为精排前的一轮过滤机制，减轻精排模块的压力。粗排介于召回和精排之间，要同时兼顾精准性和低延迟。一般模型也不能过于复杂
|
||||
- 精排：获取粗排模块的结果，对候选集进行打分和排序。精排需要在最大时延允许的情况下，保证打分的精准性，是整个系统中至关重要的一个模块，也是最复杂，研究最多的一个模块。精排系统构建一般需要涉及样本、特征、模型三部分。
|
||||
- 重排：获取精排的排序结果，基于运营策略、多样性、context上下文等，重新进行一个微调。比如三八节对美妆类目商品提权，类目打散、同图打散、同卖家打散等保证用户体验措施。重排中规则比较多，但目前也有不少基于模型来提升重排效果的方案。
|
||||
- 混排：多个业务线都想在Feeds流中获取曝光，则需要对它们的结果进行混排。比如推荐流中插入广告、视频流中插入图文和banner等。可以基于规则策略（如广告定坑）和强化学习来实现。
|
||||
|
||||
### 画像层
|
||||
|
||||
首先是推荐系统的物料库，这部分内容里，算法主要体现在如何绘制一个用户画像和商品画像。这个环节是推荐系统架构的基础设施，一般可能新用户/商品进来，或者每周定期会重新一次整个物料库，计算其中信息，为用户打上标签，计算统计信息，为商品做内容理解等内容。其中用户画像是大家比较容易理解的，比如用户年龄、爱好通常APP会通过注册界面收集这些信息。而商品画像形式就非常多了，比如淘宝主要推荐商品，抖音主要是短视频，所以大家的物料形式比较多，内容、质量差异也比较大，所以内容画像各家的做法也不同，当前比较主流的都会涉及到一个多模态信息内容理解。下面我贴了一个微信看一看的内容画像框架，然后我们来介绍下在这一块主要使用的算法技术。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220410143333692.png" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
一般推荐系统会加入多模态的一个内容理解。我们用短视频形式举个例子，假设用户拍摄了一条短视频，上传到了平台，从推荐角度看，首先我们有的信息是这条短视频的作者、长度、作者为它选择的标签、时间戳这些信息。但是这对于推荐来说是远远不够的，首先作者打上的标签不一定准确反映作品，原因可能是我们模型的语义空间可能和作者/现实世界不一致。其次我们需要更多维度的特征，比如有些用户喜欢看小姐姐跳舞，那我希望能够判断一条视频中是否有小姐姐，这就涉及到封面图的基于CV的内容抽取或者整个视频的抽取；再比如作品的标题一般能够反映主题信息，除了很多平台常用的用“#”加上一个标签以外，我们也希望能够通过标题抽取出基于NLP的信息。还有更多的维度可以考虑：封面图多维度的多媒体特征体系，包括人脸识别，人脸embedding，标签，一二级分类，视频embedding表示，水印，OCR识别，清晰度，低俗色情，敏感信息等多种维度。
|
||||
|
||||
这里面涉及的任务主要是CV的目标检测、语义分割等任务，NLP中的情感分析、摘要抽取、自然语言理解等任务。但是这部分算法一般团队都会有专门负责的组，不需要推荐算法工程师来负责，他们会有多模态的语意标签输出，主要形式是各种粒度的Embedding。我们只需要在我们的推荐模型中引入这些预训练的Embedding。
|
||||
|
||||
#### 文本理解
|
||||
|
||||
这应该是用的最多的模态信息，包括item的标题、正文、OCR、评论等数据。这里面也可以产生不同粒度的信息，比如文本分类，把整个item做一个粗粒度的分类。
|
||||
|
||||
这里的典型算法有：RNN、TextCNN、FastText、Bert等；
|
||||
|
||||
#### 关键词标签
|
||||
|
||||
相比文本分类，关键词是更细粒度的信息，往往是一个mutil-hot的形式，它会对item在我们的标签库的选取最合适的关键词或者标签。
|
||||
|
||||
这里典型的算法有：TF-IDF、Bert、LSTM-CRF等。
|
||||
|
||||
#### 内容理解
|
||||
|
||||
在很多场景下，推荐的主题都是视频或者图片，远远多于仅推荐文本的情况，这里视频/图片item中的内容中除了文本的内容以外，更多的信息其实来源于视频/图片内容本身, 因此需要尝试从多种模态中抽取更丰富的信息。主要包括分类信息、封面图OCR的信息、视频标签信息等
|
||||
|
||||
这里典型的算法有：TSN、RetinaFace、PSENet等。
|
||||
|
||||
#### 知识图谱
|
||||
|
||||
知识图谱作为知识承载系统，用于对接内外部关键词信息与词关系信息；内容画像会将原关系信息整合，并构建可业务应用的关系知识体系，其次，依赖业务中积累用户行为产生的实体关系数据，本身用户需求的标签信息，一并用于构建业务知识的兴趣图谱，基于同构网络与异构网络表示学习等核心模型，输出知识表示与表达，抽象后的图谱用于文本识别，推荐语义理解，兴趣拓展推理等场景，直接用于兴趣推理的冷启场景已经验证有很不错的收益。
|
||||
|
||||
这方面的算法有：KGAT、RippleNet等。
|
||||
|
||||
### 召回/粗排
|
||||
|
||||
推荐系统的召回阶段可以理解为根据用户的历史行为数据，为用户在海量的信息中粗选一批待推荐的内容，挑选出一个小的候选集的过程。粗排用到的很多技术与召回重合，所以放在一起讲，粗排也不是必需的环节，它的功能对召回的结果进行个粗略的排序，在保证一定精准的前提下，进一步减少往后传送的物品数量，这就是粗排的作用。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220410000221817.png" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
召回模块面对几百上千万的推荐池物料规模，候选集十分庞大。由于后续有排序模块作为保障，故不需要十分准确，但必须保证不要遗漏和低延迟。目前主要通过多路召回来实现，一方面各路可以并行计算，另一方面取长补短。可以看到各类同类竞品的系统虽然细节上多少存在差异，但不约而同的采取了多路召回的架构，这类设计考虑如下几点问题：
|
||||
|
||||
1. **考虑用户层面**：用户兴趣的多元化，用户需求与场景的多元化：例如：新闻需求，重大要闻，相关内容沉浸阅读等等
|
||||
|
||||
2. **考虑系统层面**：增强系统的鲁棒性；部分召回失效，其余召回队列兜底不会导致整个召回层失效；排序层失效，召回队列兜底不会导致整个推荐系统失效
|
||||
|
||||
3. **系统多样性内容分发**：图文、视频、小视频；精准、试探、时效一定比例；召回目标的多元化，例如：相关性，沉浸时长，时效性，特色内容等等
|
||||
|
||||
4. **可解释性推荐一部分召回是有明确推荐理由的**：很好的解决产品性数据的引入；
|
||||
|
||||
介绍了召回任务的目的和场景后，接下来分析召回层面主要的技术栈，因为召回一般都是多路召回，从模型角度分析有很多召回算法，这种一般是在召回层占大部分比例点召回，除此之外，还会有探索类召回、策略运营类召回、社交类召回等。接下来我们着重介绍模型类召回。
|
||||
|
||||
#### 经典模型召回
|
||||
|
||||
随着技术发展，在Embedding基础上的模型化召回是一个技术发展潮流方向。这种召回的范式是通过某种算法，对user和item分别打上Embedding，然后user与item在线进行KNN计算实时查询最近领结果作为召回结果，快速找出匹配的物品。需要注意的是如果召回采用模型召回方法，优化目标最好和排序的优化目标一致，否则可能被过滤掉。
|
||||
|
||||
在这方面典型的算法有：FM、双塔DSSM、Multi-View DNN等。
|
||||
|
||||
#### 序列模型召回
|
||||
|
||||
推荐系统主要解决的是基于用户的隐式阅读行为来做个性化推荐的问题，序列模型一些基于神经网络模型学习得到Word2Vec模型，再后面的基于RNN的语言模型，最先用的最多的Bert，这些方法都可以应用到召回的学习中。
|
||||
|
||||
用户在使用 APP 或者网站的时候，一般会产生一些针对物品的行为，比如点击一些感兴趣的物品，收藏或者互动行为，或者是购买商品等。而一般用户之所以会对物品发生行为，往往意味着这些物品是符合用户兴趣的，而不同类型的行为，可能代表了不同程度的兴趣。比如购买就是比点击更能表征用户兴趣的行为。在召回阶段，如何根据用户行为序列打 embedding，可以采取有监督的模型，比如 Next Item Prediction 的预测方式即可；也可以采用无监督的方式，比如物品只要能打出 embedding，就能无监督集成用户行为序列内容，例如 Sum Pooling。
|
||||
|
||||
这方面典型的算法有：CBOW、Skip-Gram、GRU、Bert等。
|
||||
|
||||
#### 用户序列拆分
|
||||
|
||||
上文讲了利用用户行为物品序列，打出用户兴趣 Embedding 的做法。但是，另外一个现实是：用户往往是多兴趣的，比如可能同时对娱乐、体育、收藏感兴趣。这些不同的兴趣也能从用户行为序列的物品构成上看出来，比如行为序列中大部分是娱乐类，一部分体育类，少部分收藏类等。那么能否把用户行为序列物品中，这种不同类型的用户兴趣细分，而不是都笼统地打到一个用户兴趣 Embedding 里呢？用户多兴趣拆分就是解决这类更细致刻画用户兴趣的方向。
|
||||
|
||||
本质上，把用户行为序列打到多个 embedding 上，实际它是个类似聚类的过程，就是把不同的 Item，聚类到不同的兴趣类别里去。目前常用的拆分用户兴趣 embedding 的方法，主要是胶囊网络和 Memory Network，但是理论上，很多类似聚类的方法应该都是有效的，所以完全可以在这块替换成你自己的能产生聚类效果的方法来做。
|
||||
|
||||
这方面典型的算法有：Multi-Interest Network with Dynamic Routing for Recommendation at Tmall等。
|
||||
|
||||
#### 知识图谱
|
||||
|
||||
知识图谱有一个独有的优势和价值，那就是对于推荐结果的可解释性；比如推荐给用户某个物品，可以在知识图谱里通过物品的关键关联路径给出合理解释，这对于推荐结果的解释性来说是很好的，因为知识图谱说到底是人编码出来让自己容易理解的一套知识体系，所以人非常容易理解其间的关系。知识图谱的可解释性往往是和图路径方法关联在一起的，而 Path 类方法，很多实验证明了，在排序角度来看，是效果最差的一类方法，但是它在可解释性方面有很好的效果，所以往往可以利用知识图谱构建一条可解释性的召回通路。
|
||||
|
||||
这方面的算法有：KGAT、RippleNet等。
|
||||
|
||||
#### 图模型
|
||||
|
||||
推荐系统中User和Item相关的行为、需求、属性和社交信息具有天然的图结构，可以使用一张复杂的异构图来表示整个推荐系统。图神经网络模型推荐就是基于这个想法，把异构网络中包含的结构和语义信息编码到结点Embedding表示中，并使用得到向量进行个性化推荐。知识图谱其实是图神经网络的一个比较特殊的具体实例，但是，知识图谱因为编码的是静态知识，而不是用户比较直接的行为数据，和具体应用距离比较远，这可能是导致两者在推荐领域表现有差异的主要原因。
|
||||
|
||||
这方面典型的算法有：GraphSAGE、PinSage等。
|
||||
|
||||
### 精排
|
||||
|
||||
排序模型是推荐系统中涵盖的研究方向最多，有非常多的子领域值得研究探索，这也是推荐系统中技术含量最高的部分，毕竟它是直接面对用户，产生的结果对用户影响最大的一层。目前精排层深度学习已经一统天下了，这是王喆老师《深度学习推荐算法》书中的精排层模型演化线路。具体来看分为DNN、Wide&Deep两大块，实际深入还有序列建模，以及没有提到的多任务建模都是工业界非常常用的，所以我们接下来具体谈论其中每一块的技术栈。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220410234144149.png" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
#### 特征交叉模型
|
||||
|
||||
在深度学习推荐算法发展早期，很多论文聚焦于如何提升模型的特征组合和交叉的能力，这其中既包含隐式特征交叉Deep Crossing也有采用显式特征交叉的探究。本质上是希望模型能够摆脱人工先验的特征工程，实现端到端的一套模型。
|
||||
|
||||
在早期的推荐系统中，基本是由人工进行特征交叉的，往往凭借对业务的理解和经验，但是费时费力。于是有了很多的这方面的研究，从FM到GBDT+LR都是引入模型进行自动化的特征交叉。再往后就是深度模型，深度模型虽然有万能近似定理，但是真正想要发挥模型的潜力，显式的特征交叉还是必不可少的。
|
||||
|
||||
这方面的经典研究工作有：DCN、DeepFM、xDeepFM等；
|
||||
|
||||
#### 序列模型
|
||||
|
||||
在推荐系统中，历史行为序列是非常重要的特征。在序列建模中，主要任务目标是得到用户此刻的兴趣向量（user interest vector）。如何刻画用户兴趣的广泛性，是推荐系统比较大的一个难点，用户历史行为序列建模的研究经历了从Pooling、RNN到attention、capsule再到transformer的顺序。在序列模型中，又有很多细分的方向，比如根据用户行为长度有研究用户终身行为序列的，也有聚焦当下兴趣的，还有研究如何抽取序列特征的抽取器，比如研究attention还是胶囊网络。
|
||||
|
||||
这方面典型的研究工作有：DIN、DSIN、DIEN、SIM等；
|
||||
|
||||
#### 多模态信息融合
|
||||
|
||||
在上文我们提到算法团队往往会利用内容画像信息，既有基于CV也有基于NLP抽取出来的信息。这是非常合理的，我们在逛抖音、淘宝的时候关注的不仅仅item的价格、品牌，同样会关注封面小姐姐好不好看、标题够不够震惊等信息。除此之外，在冷启动场景下，我们能够利用等信息不够多，如果能够使用多模态信息，能很大程度上解决数据稀疏的问题。
|
||||
|
||||
传统做法在多模态信息融合就是希望把不同模态信息利用起来，通过Embedding技术融合进模型。在推荐领域，主流的做法还是一套非端到端的体系，由其他模型抽取出多模态信息，推荐只需要融合入这些信息就好了。同时也有其他工作是利用注意力机制等方法来学习不同模态之间的关联，来增强多模态的表示。
|
||||
|
||||
比较典型的工作有：Image Matters: Visually modeling user behaviors using Advanced Model Server、UMPR等。
|
||||
|
||||
#### 多任务学习
|
||||
|
||||
很多场景下我们模型优化的目标都是CTR，有一些场景只考虑CTR是不够的，点击率模型、时长模型和完播率模型是大部分信息流产品推荐算法团队都会尝试去做的模型。单独优化点击率模型容易推出来标题党，单独优化时长模型可能推出来的都是长视频或长文章，单独优化完播率模型可能短视频短图文就容易被推出来，所以多目标就应运而生。信息流推荐中，我们不仅希望用户点进我们的item，还希望能有一个不错的完播率，即希望用户能看完我们推荐的商品。或者电商场景希望用户不仅点进来，还希望他买下或者加入购物车了。这些概率实际上就是模型要学习的目标，多种目标综合起来，包括阅读、点赞、收藏、分享等等一系列的行为，归纳到一个模型里面进行学习，这就是推荐系统的多目标学习。
|
||||
|
||||
这方面比较典型的算法有：ESSM、MMoE、DUPN等。
|
||||
|
||||
#### 强化学习
|
||||
|
||||
强化学习与一般有监督的深度学习相比有一些很显著的优势，首先强化学习能够比较灵活的定义优化的业务目标，考虑推荐系统长短期的收益，比如用户留存，在深度模型下，我们很难设计这个指标的优化函数，而强化学习是可以对长期收益下来建模。第二是能够体现用户兴趣的动态变化，比如在新闻推荐下，用户兴趣变化很快，强化学习更容易通过用户行为动态产生推荐结果。最后是EE也就是利用探索机制，这种一种当前和长期收益的权衡，强化学习能够更好的调节这里的回报。
|
||||
|
||||
这方面比较典型的算法有：DQN、Reinforcement Learning for Slate-based Recommender Systems: A Tractable Decomposition and Practical Methodology；
|
||||
|
||||
#### 跨域推荐
|
||||
|
||||
一般一家公司业务线都是非常多的，比如腾讯既有腾讯视频，也有微信看一看、视频号，还有腾讯音乐，如果能够结合这几个场景的数据，同时进行推荐，一方面对于冷启动是非常有利的，另一方面也能补充更多数据，更好的进行精确推荐。
|
||||
|
||||
跨域推荐系统相比一般的推荐系统要更加复杂。在传统推荐系统中，我们只需要考虑建立当前领域内的一个推荐模型进行分析；而在跨域推荐中，我们更要关心在不同领域间要选择何种信息进行迁移，以及如何迁移这些信息，这是跨域推荐系统中非常关键的问题。
|
||||
|
||||
这方面典型的模型有：DTCDR、MV-DNN、EMCDR等；
|
||||
|
||||
### 重排序
|
||||
|
||||
我们知道常见的有三种优化目标：Point Wise、Pair Wise 和 List Wise。重排序阶段对精排生成的Top-N个物品的序列进行重新排序，生成一个Top-K个物品的序列，作为排序系统最后的结果，直接展现给用户。重排序的原因是因为多个物品之间往往是相互影响的，而精排序是根据PointWise得分，容易造成推荐结果同质化严重，有很多冗余信息。而重排序面对的挑战就是海量状态空间如何求解的问题，一般在精排层我们使用AUC作为指标，但是在重排序更多关注NDCG等指标。
|
||||
|
||||
重排序在业务中，还会根据一些策略、运营规则参与排序，比如强制去重、间隔排序、流量扶持等，但是总计趋势上看还是算法排序越来越占据主流趋势。重排序更多的是List Wise作为优化目标的，它关注的是列表中商品顺序的问题来优化模型，但是一般List Wise因为状态空间大，存在训练速度慢的问题。这方面典型的做法，基于RNN、Transformer、强化学习的都有，这方面因为不是推荐的一个核心，所以没有展开来讲，而且这一块比较依赖实际的业务场景。
|
||||
|
||||
这里的经典算法有：MRR、DPP、RNN等；
|
||||
|
||||
## 工程
|
||||
|
||||
推荐系统的实现需要依托工程，很多研究界Paper的idea满天飞，却忽视了工业界能否落地，进入工业界我们很难或者很少有组是做纯research的，所以我们同样有很多工程技术需要掌握。下面列举了在推荐中主要用到的工程技术：
|
||||
|
||||
- **编程语言**：Python、Java（scala）、C++、sql、shell；
|
||||
- **机器学习**：Tensorflow/Pytorch、GraphLab/GraphCHI、LGB/Xgboost、SKLearn；
|
||||
- **数据分析**：Pandas、Numpy、Seaborn、Spark；
|
||||
- 数据存储：mysql、redis、mangodb、hive、kafka、es、hbase；
|
||||
- 相似计算：annoy、faiss、kgraph
|
||||
- 流计算：Spark Streaming、Flink
|
||||
- 分布式：Hadoop、Spark
|
||||
|
||||
上面那么多技术，我内容最重要的就是加粗的三部分，第一是语言：必须掌握的是Python，C++和JAVA中根据不同的组使用的是不同的语言，这个如果没有时间可以等进组后慢慢学习。然后是机器学习框架：Tensorflow和Pytorch至少要掌握一个吧，前期不用纠结学哪个，这个迁移成本很低，基本能够达到触类旁通，而且面试官不会为难你只会这个不会那个。最后是数据分析工具：Pandas是我们处理单机规模数据的利器，但是进入工业界，Hadoop和Spark是需要会用的，不过不用学太深，会用即可。
|
||||
|
||||
## 总结
|
||||
|
||||
本文从算法和工程两个角度分析了推荐系统的一个技术栈，但是还有很多方向遗漏，也有很多方向受限于现在的技术水平深度不够和有错误的情况，后续会不断补充和更正。
|
||||
|
||||
所以技术栈我列出的是一个非常广度的技术，实际上每一个技术钻研下去都需要非常多时间，而且不一定是你实际工作中会遇到的，所以不要被那么多技术吓到，也要避免陷入技术细节的海洋中。
|
||||
|
||||
我和非常多的大厂面试官讨论过技术深度和广度的问题，得出来的结论是对于入门的推荐算法工程师而言，实际上深度和广度的要求取决于你要去的组，有些组有很深的推荐技术沉淀，有很强的工程师团队，这样的组就会希望候选者能够在某个方面有比较深入的研究，这个方面既包含工程方面也包含研究方面。但是如果是比较新的组、或者技术沉淀不深、推荐不是主要任务的组，对深度要求就不会很高。总而言之，我认为对于应届生/实习生来说，在推荐最重要的工程技术/研究方向，至少在召回和排序模块，需要选一个作为方向，是需要较深钻研。对于其他技术/研究方向需要有一定了解，比如可以没用过强化学习，但是要知道强化学习能够在推荐中解决什么问题，剩下的可以等到真实**遇到需要后再去学习**。
|
||||
|
||||
|
||||
|
||||
**参考资料**
|
||||
|
||||
- [万字入门推荐系统](https://mp.weixin.qq.com/s/aaOosZ57qJpIU6cma820Xw)
|
||||
- [张俊林：技术演进趋势：召回->排序->重排](https://mp.weixin.qq.com/s?__biz=MzU1NTMyOTI4Mw==&mid=2247496363&idx=1&sn=0d2b2ac176e2a72eb2e760b7b591788f&chksm=fbd740c7cca0c9d16c76fdeb1a874a53f7408d8125b2e1bed3173ecb69d131167c1c9c35c71f&scene=21#wechat_redirect)
|
||||
- [微信"看一看"多模型内容策略与召回](https://mp.weixin.qq.com/s?__biz=MzU1NTMyOTI4Mw==&mid=2247503484&idx=2&sn=e2a2cdd3a517ab09e903e69ccb1e9f94&chksm=fbd77c10cca0f50642dde47439ed919aa2e61b7ff57bc4cbaacc3acaac3c620a1ed6f92684ab&scene=21#wechat_redirect)
|
||||
- [多目标学习在推荐系统中的应用](https://mp.weixin.qq.com/s/u_5RdZ-BcIu_RoWNri76ig)
|
||||
- [强化学习在美团“猜你喜欢”的实践](https://mp.weixin.qq.com/s?__biz=MjM5NjQ5MTI5OA==&mid=2651749434&idx=2&sn=343e811408542dd1984582b8639240a6&chksm=bd12a5778a652c61ed4297f1a17582cad4ca6b8e8d4d66843f169e0eda9f6aede988bc675743&mpshare=1&scene=23&srcid=1115EcgbMw6GAhMnzV0URvgd#rd)
|
||||
- [推荐系统技术演进趋势：重排篇](https://mp.weixin.qq.com/s/YorzRyK0iplzqutnhEhrvw)
|
||||
- [阿里强化学习重排实践](https://mp.weixin.qq.com/s/ylavFA_MXLUhIBLCqxAjLQ)
|
||||
288
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.1/Swing.md
Normal file
288
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.1/Swing.md
Normal file
@@ -0,0 +1,288 @@
|
||||
# Swing(Graph-based)
|
||||
## 动机
|
||||
大规模推荐系统需要实时对用户行为做出海量预测，为了保证这种实时性，大规模的推荐系统通常严重依赖于预先计算好的产品索引。产品索引的功能为：给定种子产品返回排序后的候选相关产品列表。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片2relations.png" alt="在这里插入图片描述" style="zoom:30%;" />
|
||||
</div>
|
||||
|
||||
相关性产品索引主要包含两部分：替代性产品和互补性产品。例如图中的不同种类的衬衫构成了替代关系，而衬衫和风衣裤子等构成了互补关系。用户通常希望在完成购买行为之前尽可能看更多的衬衫，而用户购买过衬衫之后更希望看到与之搭配的单品而不是其他衬衫了。
|
||||
|
||||
## 之前方法局限性
|
||||
- 基于 Cosine, Jaccard, 皮尔逊相关性等相似度计算的协同过滤算法，在计算邻居关联强度的时候只关注于 Item-based (常用，因为item相比于用户变化的慢，且新Item特征比较容易获得)，Item-based CF 只关注于 Item-User-Item 的路径，把所有的User-Item交互都平等得看待，从而忽视了 User-Item 交互中的大量噪声，推荐精度存在局限性。
|
||||
- 对互补性产品的建模不足，可能会导致用户购买过手机之后还继续推荐手机，但用户短时间内不会再继续购买手机，因此产生无效曝光。
|
||||
|
||||
## 贡献
|
||||
提出了高效建立产品索引图的技术。
|
||||
主要包括：
|
||||
- Swing 算法利用 user-item 二部图的子结构捕获产品间的替代关系。
|
||||
- Surprise 算法利用商品分类信息和用户共同购买图上的聚类技术来建模产品之间的组合关系。
|
||||
|
||||
## Swing算法
|
||||
Swing 通过利用 User-Item-User 路径中所包含的信息，考虑 User-Item 二部图中的鲁棒内部子结构计算相似性。
|
||||
- 什么是内部子结构？
|
||||
以经典的啤酒尿布故事为例，张三同时购买了啤酒和尿布，这可能是一种巧合。但两个甚至多个顾客都同时购买了啤酒尿布，这就证明啤酒和尿布具有相关关系。这样共同购买啤酒和尿布的用户越多，啤酒和尿布的相关度就会越高。
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片example_of_swing.png" alt="在这里插入图片描述" style="zoom:30%;" />
|
||||
</div>
|
||||
图中的红色四边形就是一种Swing子结构，这种子结构可以作为给王五推荐尿布的依据。
|
||||
|
||||
- 通俗解释：若用户 $u$ 和用户 $v$ 之间除了购买过 $i$ 外，还购买过商品 $j$ ，则认为两件商品是具有某种程度上的相似的。也就是说，商品与商品之间的相似关系，是通过用户关系来传递的。为了衡量物品 $i$ 和 $j$ 的相似性，比较同时购买了物品 $i$ 和 $j$ 的用户 $u$ 和用户 $v$， 如果这两个用户共同购买的物品越少，即这两个用户原始兴趣不相似，但仍同时购买了两个相同的物品 $i$ 和 $j$， 则物品 $i$ 和 $j$ 的相似性越高。
|
||||
|
||||
- 计算公式
|
||||
|
||||
$$s(i,j)=\sum\limits_{u\in U_i\cap U_j} \sum\limits_{v \in U_i\cap U_j}w_u*w_v* \frac{1}{\alpha+|I_u \cap I_v|}$$
|
||||
|
||||
其中$U_i$ 是点击过商品i的用户集合，$I_u$ 是用户u点击过的商品集合，$\alpha$是平滑系数。
|
||||
|
||||
$w_u=\frac{1}{\sqrt{|I_u|}},w_v=\frac{1}{\sqrt{|I_v|}}$ 是用户权重参数，来降低活跃用户的影响。
|
||||
|
||||
- 代码实现
|
||||
- Python （建议自行debug方便理解）
|
||||
```python
|
||||
from itertools import combinations
|
||||
import pandas as pd
|
||||
alpha = 0.5
|
||||
top_k = 20
|
||||
def load_data(train_path):
|
||||
train_data = pd.read_csv(train_path, sep="\t", engine="python", names=["userid", "itemid", "rate"])#提取用户交互记录数据
|
||||
print(train_data.head(3))
|
||||
return train_data
|
||||
|
||||
def get_uitems_iusers(train):
|
||||
u_items = dict()
|
||||
i_users = dict()
|
||||
for index, row in train.iterrows():#处理用户交互记录
|
||||
u_items.setdefault(row["userid"], set())
|
||||
i_users.setdefault(row["itemid"], set())
|
||||
u_items[row["userid"]].add(row["itemid"])#得到user交互过的所有item
|
||||
i_users[row["itemid"]].add(row["userid"])#得到item交互过的所有user
|
||||
print("使用的用户个数为：{}".format(len(u_items)))
|
||||
print("使用的item个数为：{}".format(len(i_users)))
|
||||
return u_items, i_users
|
||||
|
||||
def swing_model(u_items, i_users):
|
||||
# print([i for i in i_users.values()][:5])
|
||||
# print([i for i in u_items.values()][:5])
|
||||
item_pairs = list(combinations(i_users.keys(), 2)) #全排列组合对
|
||||
print("item pairs length：{}".format(len(item_pairs)))
|
||||
item_sim_dict = dict()
|
||||
for (i, j) in item_pairs:
|
||||
user_pairs = list(combinations(i_users[i] & i_users[j], 2)) #item_i和item_j对应的user取交集后全排列 得到user对
|
||||
result = 0
|
||||
for (u, v) in user_pairs:
|
||||
result += 1 / (alpha + list(u_items[u] & u_items[v]).__len__()) #分数公式
|
||||
if result != 0 :
|
||||
item_sim_dict.setdefault(i, dict())
|
||||
item_sim_dict[i][j] = format(result, '.6f')
|
||||
return item_sim_dict
|
||||
|
||||
def save_item_sims(item_sim_dict, top_k, path):
|
||||
new_item_sim_dict = dict()
|
||||
try:
|
||||
writer = open(path, 'w', encoding='utf-8')
|
||||
for item, sim_items in item_sim_dict.items():
|
||||
new_item_sim_dict.setdefault(item, dict())
|
||||
new_item_sim_dict[item] = dict(sorted(sim_items.items(), key = lambda k:k[1], reverse=True)[:top_k])#排序取出 top_k个相似的item
|
||||
writer.write('item_id:%d\t%s\n' % (item, new_item_sim_dict[item]))
|
||||
print("SUCCESS: top_{} item saved".format(top_k))
|
||||
except Exception as e:
|
||||
print(e.args)
|
||||
|
||||
if __name__ == "__main__":
|
||||
train_data_path = "./ratings_final.txt"
|
||||
item_sim_save_path = "./item_sim_dict.txt"
|
||||
top_k = 10 #与item相似的前 k 个item
|
||||
train = load_data(train_data_path)
|
||||
u_items, i_users = get_uitems_iusers(train)
|
||||
item_sim_dict = swing_model(u_items, i_users)
|
||||
save_item_sims(item_sim_dict, top_k, item_sim_save_path)
|
||||
```
|
||||
|
||||
- Spark（仅为核心代码需要补全配置才能跑通）
|
||||
```scala
|
||||
object Swing {
|
||||
|
||||
def main(args: Array[String]): Unit = {
|
||||
val spark = SparkSession.builder()
|
||||
.appName("test")
|
||||
.master("local[2]")
|
||||
.getOrCreate()
|
||||
val alpha = 1 //分数计算参数
|
||||
val filter_n_items = 10000 //想要计算的item数量 测试的时候取少点
|
||||
val top_n_items = 500 //保存item的score排序前500个相似的item
|
||||
val model = new SwingModel(spark)
|
||||
.setAlpha(alpha.toDouble)
|
||||
.setFilter_N_Items(filter_n_items.toInt)
|
||||
.setTop_N_Items(top_n_items.toInt)
|
||||
val url = "file:///usr/local/var/scala/common/part-00022-e17c0014.snappy.parquet"
|
||||
val ratings = DataLoader.getRatingLog(spark, url)
|
||||
val df = model.fit(ratings).item2item()
|
||||
df.show(3,false)
|
||||
// df.write.mode("overwrite").parquet(dest_url)
|
||||
}
|
||||
|
||||
}
|
||||
```
|
||||
|
||||
```scala
|
||||
/**
|
||||
* swing
|
||||
* @param ratings 打分dataset
|
||||
* @return
|
||||
*/
|
||||
def fit(ratings: Dataset[Rating]): SwingModel = {
|
||||
|
||||
def interWithAlpha = udf(
|
||||
(array_1: Seq[GenericRowWithSchema],
|
||||
array_2: Seq[GenericRowWithSchema]) => {
|
||||
var score = 0.0
|
||||
val u_set_1 = array_1.toSet
|
||||
val u_set_2 = array_2.toSet
|
||||
val user_set = u_set_1.intersect(u_set_2).toArray //取交集得到两个item共同user
|
||||
|
||||
for (i <- user_set.indices; j <- i + 1 until user_set.length) {
|
||||
val user_1 = user_set(i)
|
||||
val user_2 = user_set(j)
|
||||
val item_set_1 = user_1.getAs[Seq[String]]("_2").toSet
|
||||
val item_set_2 = user_2.getAs[Seq[String]]("_2").toSet
|
||||
score = score + 1 / (item_set_1
|
||||
.intersect(item_set_2)
|
||||
.size
|
||||
.toDouble + alpha.get)
|
||||
}
|
||||
score
|
||||
}
|
||||
)
|
||||
val df = ratings.repartition(defaultParallelism).cache()
|
||||
|
||||
val groupUsers = df
|
||||
.groupBy("user_id")
|
||||
.agg(collect_set("item_id")) //聚合itme_id
|
||||
.toDF("user_id", "item_set")
|
||||
.repartition(defaultParallelism)
|
||||
println("groupUsers")
|
||||
groupUsers.show(3, false)//user_id|[item_id_set]: 422|[6117,611,6117]
|
||||
|
||||
val groupItems = df
|
||||
.join(groupUsers, "user_id")
|
||||
.rdd
|
||||
.map { x =>
|
||||
val item_id = x.getAs[String]("item_id")
|
||||
val user_id = x.getAs[String]("user_id")
|
||||
val item_set = x.getAs[Seq[String]]("item_set")
|
||||
(item_id, (user_id, item_set))
|
||||
}//i_[user(item_set)]
|
||||
.toDF("item_id", "user")
|
||||
.groupBy("item_id")
|
||||
.agg(collect_set("user"), count("item_id"))
|
||||
.toDF("item_id", "user_set", "count")
|
||||
.filter("size(user_set) > 1")//过滤掉没有交互的
|
||||
.sort($"count".desc) //根据count倒排item_id数量
|
||||
.limit(filter_n_items.get)//item可能百万级别但后面召回的需求量小所以只取前n个item进行计算
|
||||
.drop("count")
|
||||
.repartition(defaultParallelism)
|
||||
.cache()
|
||||
println("groupItems") //得到与itme_id有交互的user_id
|
||||
groupItems.show(3, false)//item_id|[[user_id,[item_set]],[user_id,[item_set]]]: 67|[[562,[66, 813, 61, 67]],[563,[67, 833, 62, 64]]]
|
||||
|
||||
val itemJoined = groupItems
|
||||
.join(broadcast(groupItems))//内连接两个item列表
|
||||
.toDF("item_id_1", "user_set_1", "item_id_2", "user_set_2")
|
||||
.filter("item_id_1 > item_id_2")//内连接 item两两配对
|
||||
.withColumn("score", interWithAlpha(col("user_set_1"), col("user_set_2")))//将上面得到的与item相关的user_set输入到函数interWithAlpha计算分数
|
||||
.select("item_id_1", "item_id_2", "score")
|
||||
.filter("score > 0")
|
||||
.repartition(defaultParallelism)
|
||||
.cache()
|
||||
println("itemJoined")
|
||||
itemJoined.show(5)//得到两两item之间的分数结果 item_id_1 item_id_2 score
|
||||
similarities = Option(itemJoined)
|
||||
this
|
||||
}
|
||||
|
||||
/**
|
||||
* 从fit结果，对item_id进行聚合并排序，每个item后截取n个item，并返回。
|
||||
* @param num 取n个item
|
||||
* @return
|
||||
*/
|
||||
def item2item(): DataFrame = {
|
||||
|
||||
case class itemWithScore(item_id: String, score: Double)
|
||||
val sim = similarities.get.select("item_id_1", "item_id_2", "score")
|
||||
val topN = sim
|
||||
.map { x =>
|
||||
val item_id_1 = x.getAs[String]("item_id_1")
|
||||
val item_id_2 = x.getAs[String]("item_id_2")
|
||||
val score = x.getAs[Double]("score")
|
||||
(item_id_1, (item_id_2, score))
|
||||
}
|
||||
.toDF("item_id", "itemWithScore")
|
||||
.groupBy("item_id")
|
||||
.agg(collect_set("itemWithScore"))
|
||||
.toDF("item_id", "item_set")//item_id |[[item_id1:score],[item_id2:score]]
|
||||
.rdd
|
||||
.map { x =>
|
||||
val item_id_1 = x.getAs[String]("item_id")
|
||||
val item_set = x //对itme_set中score进行排序操作
|
||||
.getAs[Seq[GenericRowWithSchema]]("item_set")
|
||||
.map { x =>
|
||||
val item_id_2 = x.getAs[String]("_1")
|
||||
val score = x.getAs[Double]("_2")
|
||||
(item_id_2, score)
|
||||
}
|
||||
.sortBy(-_._2)//根据score进行排序
|
||||
.take(top_n_items.get)//取top_n
|
||||
.map(x => x._1 + ":" + x._2.toString)
|
||||
(item_id_1, item_set)
|
||||
}
|
||||
.filter(_._2.nonEmpty)
|
||||
.toDF("id", "sorted_items")
|
||||
topN
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Surprise算法
|
||||
首先在行为相关性中引入连续时间衰减因子，然后引入基于交互数据的聚类方法解决数据稀疏的问题，旨在帮助用户找到互补商品。互补相关性主要从三个层面考虑，类别层面，商品层面和聚类层面。
|
||||
|
||||
- 类别层面
|
||||
首先通过商品和类别的映射关系，我们可以得到 user-category 矩阵。随后使用简单的相关性度量可以计算出类别 $i,j$ 的相关性。
|
||||
|
||||
$\theta_{i,j}=p(c_{i,j}|c_j)=\frac{N(c_{i,j})}{N(c_j)}$
|
||||
|
||||
即，$N(c_{i,j})$为在购买过i之后购买j类的数量，$N(c_{j})$为购买j类的数量。
|
||||
|
||||
由于类别直接的种类差异，每个类别的相关类数量存在差异，因此采用最大相对落点来作为划分阈值。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片max_drop.png" alt="在这里插入图片描述" style="zoom:30%;" />
|
||||
</div>
|
||||
|
||||
例如图(a)中T恤的相关类选择前八个，图(b)中手机的相关类选择前三个。
|
||||
|
||||
- 商品层面
|
||||
商品层面的相关性挖掘主要有两个关键设计：
|
||||
- 商品的购买顺序是需要被考虑的，例如在用户购买手机后推荐充电宝是合理的，但在用户购买充电宝后推荐手机是不合理的。
|
||||
- 两个商品购买的时间间隔也是需要被考虑的，时间间隔越短越能证明两个商品的互补关系。
|
||||
|
||||
最终商品层面的互补相关性被定义为：
|
||||
|
||||
$s_{1}(i, j)=\frac{\sum_{u \in U_{i} \cap U_{j}} 1 /\left(1+\left|t_{u i}-t_{u j}\right|\right)}{\left\|U_{i}\right\| \times\left\|U_{j}\right\|}$,其中$j$属于$i$的相关类，且$j$ 的购买时间晚于$i$。
|
||||
|
||||
- 聚类层面
|
||||
- 如何聚类？
|
||||
传统的聚类算法（基于密度和 k-means ）在数十亿产品规模下的淘宝场景中不可行，所以作者采用了标签传播算法。
|
||||
- 在哪里标签传播？
|
||||
Item-item 图，其中又 Swing 计算的排名靠前 item 为邻居，边的权重就是 Swing 分数。
|
||||
- 表现如何？
|
||||
快速而有效，15分钟即可对数十亿个项目进行聚类。
|
||||
最终聚类层面的相关度计算同上面商品层面的计算公式
|
||||
|
||||
- 线性组合：
|
||||
$s(i, j)=\omega * s_{1}(i, j)+(1-\omega) * s_{2}(i, j)$,其中$\omega=0.8$是作者设置的权重超参数。
|
||||
Surprise算法通过利用类别信息和标签传播技术解决了用户共同购买图上的稀疏性问题。
|
||||
|
||||
**参考资料**
|
||||
- [Large Scale Product Graph Construction for Recommendation in E-commerce](https://arxiv.org/pdf/2010.05525)
|
||||
- [推荐召回-Swing](https://zhuanlan.zhihu.com/p/383346471)
|
||||
263
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.1/itemcf.md
Normal file
263
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.1/itemcf.md
Normal file
@@ -0,0 +1,263 @@
|
||||
# 基于物品的协同过滤
|
||||
|
||||
## 基本思想
|
||||
|
||||
基于物品的协同过滤（ItemCF）：
|
||||
|
||||
+ 预先根据所有用户的历史行为数据，计算物品之间的相似性。
|
||||
+ 然后，把与用户喜欢的物品相类似的物品推荐给用户。
|
||||
|
||||
举例来说，如果用户 1 喜欢物品 A ，而物品 A 和 C 非常相似，则可以将物品 C 推荐给用户1。ItemCF算法并不利用物品的内容属性计算物品之间的相似度， 主要通过分析用户的行为记录计算物品之间的相似度， 该算法认为， 物品 A 和物品 C 具有很大的相似度是因为喜欢物品 A 的用户极可能喜欢物品 C。
|
||||
|
||||
|
||||
|
||||
## 计算过程
|
||||
|
||||
基于物品的协同过滤算法和基于用户的协同过滤算法很像， 所以我们这里直接还是拿上面 Alice 的那个例子来看。
|
||||
|
||||
|
||||
|
||||
如果想知道 Alice 对物品5打多少分， 基于物品的协同过滤算法会这么做：
|
||||
|
||||
+ 首先计算一下物品5和物品1， 2， 3， 4之间的相似性。
|
||||
|
||||
+ 在Alice找出与物品 5 最相近的 n 个物品。
|
||||
|
||||
+ 根据 Alice 对最相近的 n 个物品的打分去计算对物品 5 的打分情况。
|
||||
|
||||
**手动计算：**
|
||||
|
||||
1. 手动计算物品之间的相似度
|
||||
|
||||
>物品向量: $物品 1(3,4,3,1) ,物品2(1,3,3,5) ,物品3(2,4,1,5) ,物品4(3,3,5,2) ,物品5(3,5,41)$
|
||||
>
|
||||
>+ 下面计算物品 5 和物品 1 之间的余弦相似性:
|
||||
> $$
|
||||
> \operatorname{sim}(\text { 物品1, 物品5 })=\operatorname{cosine}(\text { 物品1, 物品5 } )=\frac{9+20+12+1}{\operatorname{sqrt}(9+16+9+1)*\operatorname{sqrt}(9+25+16+1)}
|
||||
> $$
|
||||
>
|
||||
>+ 皮尔逊相关系数类似。
|
||||
>
|
||||
|
||||
2. 基于 `sklearn` 计算物品之间的皮尔逊相关系数：
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/JavaJOyFti58um61zPsa.png!thumbnail" alt="图片" style="zoom:80%;" />
|
||||
|
||||
3. 根据皮尔逊相关系数， 可以找到与物品5最相似的2个物品是 item1 和 item4， 下面基于上面的公式计算最终得分：
|
||||
|
||||
$$
|
||||
P_{Alice, 物品5}=\bar{R}_{物品5}+\frac{\sum_{k=1}^{2}\left(w_{物品5,物品 k}\left(R_{Alice, 物品k}-\bar{R}_{物品k}\right)\right)}{\sum_{k=1}^{2} w_{物品k, 物品5}} \\
|
||||
=\frac{13}{4}+\frac{0.97*(5-3.2)+0.58*(4-3.4)}{0.97+0.58}=4.6
|
||||
$$
|
||||
|
||||
## ItemCF编程实现
|
||||
|
||||
1. 构建物品-用户的评分矩阵
|
||||
|
||||
```python
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
|
||||
|
||||
def loadData():
|
||||
items = {'A': {'Alice': 5.0, 'user1': 3.0, 'user2': 4.0, 'user3': 3.0, 'user4': 1.0},
|
||||
'B': {'Alice': 3.0, 'user1': 1.0, 'user2': 3.0, 'user3': 3.0, 'user4': 5.0},
|
||||
'C': {'Alice': 4.0, 'user1': 2.0, 'user2': 4.0, 'user3': 1.0, 'user4': 5.0},
|
||||
'D': {'Alice': 4.0, 'user1': 3.0, 'user2': 3.0, 'user3': 5.0, 'user4': 2.0},
|
||||
'E': {'user1': 3.0, 'user2': 5.0, 'user3': 4.0, 'user4': 1.0}
|
||||
}
|
||||
return items
|
||||
```
|
||||
|
||||
2. 计算物品间的相似度矩阵
|
||||
|
||||
```python
|
||||
item_data = loadData()
|
||||
|
||||
similarity_matrix = pd.DataFrame(
|
||||
np.identity(len(item_data)),
|
||||
index=item_data.keys(),
|
||||
columns=item_data.keys(),
|
||||
)
|
||||
|
||||
# 遍历每条物品-用户评分数据
|
||||
for i1, users1 in item_data.items():
|
||||
for i2, users2 in item_data.items():
|
||||
if i1 == i2:
|
||||
continue
|
||||
vec1, vec2 = [], []
|
||||
for user, rating1 in users1.items():
|
||||
rating2 = users2.get(user, -1)
|
||||
if rating2 == -1:
|
||||
continue
|
||||
vec1.append(rating1)
|
||||
vec2.append(rating2)
|
||||
similarity_matrix[i1][i2] = np.corrcoef(vec1, vec2)[0][1]
|
||||
|
||||
print(similarity_matrix)
|
||||
```
|
||||
|
||||
```python
|
||||
A B C D E
|
||||
A 1.000000 -0.476731 -0.123091 0.532181 0.969458
|
||||
B -0.476731 1.000000 0.645497 -0.310087 -0.478091
|
||||
C -0.123091 0.645497 1.000000 -0.720577 -0.427618
|
||||
D 0.532181 -0.310087 -0.720577 1.000000 0.581675
|
||||
E 0.969458 -0.478091 -0.427618 0.581675 1.000000
|
||||
```
|
||||
|
||||
3. 从 Alice 购买过的物品中，选出与物品 `E` 最相似的 `num` 件物品。
|
||||
|
||||
```python
|
||||
target_user = ' Alice '
|
||||
target_item = 'E'
|
||||
num = 2
|
||||
|
||||
sim_items = []
|
||||
sim_items_list = similarity_matrix[target_item].sort_values(ascending=False).index.tolist()
|
||||
for item in sim_items_list:
|
||||
# 如果target_user对物品item评分过
|
||||
if target_user in item_data[item]:
|
||||
sim_items.append(item)
|
||||
if len(sim_items) == num:
|
||||
break
|
||||
print(f'与物品{target_item}最相似的{num}个物品为：{sim_items}')
|
||||
```
|
||||
|
||||
```python
|
||||
与物品E最相似的2个物品为：['A', 'D']
|
||||
```
|
||||
|
||||
4. 预测用户 Alice 对物品 `E` 的评分
|
||||
|
||||
```python
|
||||
target_user_mean_rating = np.mean(list(item_data[target_item].values()))
|
||||
weighted_scores = 0.
|
||||
corr_values_sum = 0.
|
||||
|
||||
target_item = 'E'
|
||||
for item in sim_items:
|
||||
corr_value = similarity_matrix[target_item][item]
|
||||
user_mean_rating = np.mean(list(item_data[item].values()))
|
||||
|
||||
weighted_scores += corr_value * (item_data[item][target_user] - user_mean_rating)
|
||||
corr_values_sum += corr_value
|
||||
|
||||
target_item_pred = target_user_mean_rating + weighted_scores / corr_values_sum
|
||||
print(f'用户{target_user}对物品{target_item}的预测评分为：{target_item_pred}')
|
||||
```
|
||||
|
||||
```python
|
||||
用户 Alice 对物品E的预测评分为：4.6
|
||||
```
|
||||
|
||||
# 协同过滤算法的权重改进
|
||||
|
||||
* base 公式
|
||||
$$
|
||||
w_{i j}=\frac{|N(i) \bigcap N(j)|}{|N(i)|}
|
||||
$$
|
||||
|
||||
+ 该公式表示同时喜好物品 $i$ 和物品 $j$ 的用户数，占喜爱物品 $i$ 的比例。
|
||||
+ 缺点：若物品 $j$ 为热门物品，那么它与任何物品的相似度都很高。
|
||||
|
||||
* 对热门物品进行惩罚
|
||||
$$
|
||||
w_{i j}=\frac{|N(i) \cap N(j)|}{\sqrt{|N(i)||N(j)|}}
|
||||
$$
|
||||
|
||||
|
||||
* 根据 base 公式在的问题，对物品 $j$ 进行打压。打压的出发点很简单，就是在分母再除以一个物品 $j$ 被购买的数量。
|
||||
* 此时，若物品 $j$ 为热门物品，那么对应的 $N(j)$ 也会很大，受到的惩罚更多。
|
||||
|
||||
* 控制对热门物品的惩罚力度
|
||||
$$
|
||||
w_{i j}=\frac{|N(i) \cap N(j)|}{|N(i)|^{1-\alpha}|N(j)|^{\alpha}}
|
||||
$$
|
||||
|
||||
* 除了第二点提到的办法，在计算物品之间相似度时可以对热门物品进行惩罚外。
|
||||
* 可以在此基础上，进一步引入参数 $\alpha$ ，这样可以通过控制参数 $\alpha$来决定对热门物品的惩罚力度。
|
||||
|
||||
* 对活跃用户的惩罚
|
||||
|
||||
* 在计算物品之间的相似度时，可以进一步将用户的活跃度考虑进来。
|
||||
$$
|
||||
w_{i j}=\frac{\sum_{\operatorname{\text {u}\in N(i) \cap N(j)}} \frac{1}{\log 1+|N(u)|}}{|N(i)|^{1-\alpha}|N(j)|^{\alpha}}
|
||||
$$
|
||||
|
||||
+ 对于异常活跃的用户，在计算物品之间的相似度时，他的贡献应该小于非活跃用户。
|
||||
|
||||
# 协同过滤算法的问题分析
|
||||
|
||||
协同过滤算法存在的问题之一就是泛化能力弱：
|
||||
|
||||
+ 即协同过滤无法将两个物品相似的信息推广到其他物品的相似性上。
|
||||
+ 导致的问题是**热门物品具有很强的头部效应， 容易跟大量物品产生相似， 而尾部物品由于特征向量稀疏， 导致很少被推荐**。
|
||||
|
||||
比如下面这个例子：
|
||||
|
||||
|
||||
|
||||
+ 左边矩阵中，$A, B, C, D$ 表示的是物品。
|
||||
+ 可以看出，$D $ 是一件热门物品，其与 $A、B、C$ 的相似度比较大。因此，推荐系统更可能将 $D$ 推荐给用过 $A、B、C$ 的用户。
|
||||
+ 但是，推荐系统无法找出 $A,B,C$ 之间相似性的原因是交互数据太稀疏， 缺乏相似性计算的直接数据。
|
||||
|
||||
所以这就是协同过滤的天然缺陷：**推荐系统头部效应明显， 处理稀疏向量的能力弱**。
|
||||
|
||||
为了解决这个问题， 同时增加模型的泛化能力。2006年，**矩阵分解技术(Matrix Factorization, MF**)被提出：
|
||||
|
||||
+ 该方法在协同过滤共现矩阵的基础上， 使用更稠密的隐向量表示用户和物品， 挖掘用户和物品的隐含兴趣和隐含特征。
|
||||
+ 在一定程度上弥补协同过滤模型处理稀疏矩阵能力不足的问题。
|
||||
|
||||
# 课后思考
|
||||
|
||||
1. **什么时候使用UserCF，什么时候使用ItemCF？为什么？**
|
||||
|
||||
> （1）UserCF
|
||||
>
|
||||
> + 由于是基于用户相似度进行推荐， 所以具备更强的社交特性， 这样的特点非常适于**用户少， 物品多， 时效性较强的场合**。
|
||||
>
|
||||
> + 比如新闻推荐场景， 因为新闻本身兴趣点分散， 相比用户对不同新闻的兴趣偏好， 新闻的及时性，热点性往往更加重要， 所以正好适用于发现热点，跟踪热点的趋势。
|
||||
> + 另外还具有推荐新信息的能力， 更有可能发现惊喜, 因为看的是人与人的相似性, 推出来的结果可能更有惊喜，可以发现用户潜在但自己尚未察觉的兴趣爱好。
|
||||
>
|
||||
> （2）ItemCF
|
||||
>
|
||||
> + 这个更适用于兴趣变化较为稳定的应用， 更接近于个性化的推荐， 适合**物品少，用户多，用户兴趣固定持久， 物品更新速度不是太快的场合**。
|
||||
> + 比如推荐艺术品， 音乐， 电影。
|
||||
|
||||
|
||||
|
||||
2.**协同过滤在计算上有什么缺点？有什么比较好的思路可以解决（缓解）？**
|
||||
|
||||
> 该问题答案参考上一小节的**协同过滤算法的问题分析**。
|
||||
|
||||
|
||||
|
||||
**3.上面介绍的相似度计算方法有什么优劣之处？**
|
||||
|
||||
> cosine相似度计算简单方便，一般较为常用。但是，当用户的评分数据存在 bias 时，效果往往不那么好。
|
||||
>
|
||||
> + 简而言之，就是不同用户评分的偏向不同。部分用户可能乐于给予好评，而部分用户习惯给予差评或者乱评分。
|
||||
> + 这个时候，根据cosine 相似度计算出来的推荐结果效果会打折扣。
|
||||
>
|
||||
> 举例来说明，如下图（`X,Y,Z` 表示物品，`d,e,f`表示用户）：
|
||||
>
|
||||
> 
|
||||
>
|
||||
> + 如果使用余弦相似度进行计算，用户 d 和 e 之间较为相似。但是实际上，用户 d 和 f 之间应该更加相似。只不过由于 d 倾向于打高分，e 倾向于打低分导致二者之间的余弦相似度更高。
|
||||
> + 这种情况下，可以考虑使用皮尔逊相关系数计算用户之间的相似性关系。
|
||||
|
||||
|
||||
|
||||
4.**协同过滤还存在其他什么缺陷？有什么比较好的思路可以解决（缓解）？**
|
||||
|
||||
> + 协同过滤的优点就是没有使用更多的用户或者物品属性信息，仅利用用户和物品之间的交互信息就能完成推荐，该算法简单高效。
|
||||
> + 但这也是协同过滤算法的一个弊端。由于未使用更丰富的用户和物品特征信息，这也导致协同过滤算法的模型表达能力有限。
|
||||
> + 对于该问题，逻辑回归模型（LR）可以更好地在推荐模型中引入更多特征信息，提高模型的表达能力。
|
||||
|
||||
|
||||
|
||||
# 参考资料
|
||||
|
||||
* [基于用户的协同过滤来构建推荐系统：https://mp.weixin.qq.com/s/ZtnaQrVIpVOPJpqMdLWOcw](https://mp.weixin.qq.com/s/ZtnaQrVIpVOPJpqMdLWOcw)
|
||||
* B站黑马推荐系统实战课程
|
||||
370
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.1/mf.md
Normal file
370
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.1/mf.md
Normal file
@@ -0,0 +1,370 @@
|
||||
# 隐语义模型与矩阵分解
|
||||
|
||||
协同过滤算法的特点：
|
||||
|
||||
+ 协同过滤算法的特点就是完全没有利用到物品本身或者是用户自身的属性， 仅仅利用了用户与物品的交互信息就可以实现推荐，是一个可解释性很强， 非常直观的模型。
|
||||
+ 但是也存在一些问题，处理稀疏矩阵的能力比较弱。
|
||||
|
||||
为了使得协同过滤更好处理稀疏矩阵问题， 增强泛化能力。从协同过滤中衍生出矩阵分解模型(Matrix Factorization, MF)或者叫隐语义模型：
|
||||
|
||||
+ 在协同过滤共现矩阵的基础上， 使用更稠密的隐向量表示用户和物品。
|
||||
+ 通过挖掘用户和物品的隐含兴趣和隐含特征， 在一定程度上弥补协同过滤模型处理稀疏矩阵能力不足的问题。
|
||||
|
||||
|
||||
|
||||
# 隐语义模型
|
||||
|
||||
隐语义模型最早在文本领域被提出，用于找到文本的隐含语义。在2006年， 被用于推荐中， 它的核心思想是通过隐含特征（latent factor）联系用户兴趣和物品（item）， 基于用户的行为找出潜在的主题和分类， 然后对物品进行自动聚类，划分到不同类别/主题(用户的兴趣)。
|
||||
|
||||
以项亮老师《推荐系统实践》书中的内容为例：
|
||||
|
||||
>如果我们知道了用户A和用户B两个用户在豆瓣的读书列表， 从他们的阅读列表可以看出，用户A的兴趣涉及侦探小说、科普图书以及一些计算机技术书， 而用户B的兴趣比较集中在数学和机器学习方面。 那么如何给A和B推荐图书呢？ 先说说协同过滤算法， 这样好对比不同：
|
||||
>* 对于UserCF，首先需要找到和他们看了同样书的其他用户（兴趣相似的用户），然后给他们推荐那些用户喜欢的其他书。
|
||||
>* 对于ItemCF，需要给他们推荐和他们已经看的书相似的书，比如作者B看了很多关于数据挖掘的书，可以给他推荐机器学习或者模式识别方面的书。
|
||||
>
|
||||
>而如果是隐语义模型的话， 它会先通过一些角度把用户兴趣和这些书归一下类， 当来了用户之后， 首先得到他的兴趣分类， 然后从这个分类中挑选他可能喜欢的书籍。
|
||||
|
||||
隐语义模型和协同过滤的不同主要体现在隐含特征上， 比如书籍的话它的内容， 作者， 年份， 主题等都可以算隐含特征。
|
||||
|
||||
以王喆老师《深度学习推荐系统》中的一个原理图为例，看看是如何通过隐含特征来划分开用户兴趣和物品的。
|
||||
|
||||
<img src="https://img-blog.csdnimg.cn/20200822212051499.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="在这里插入图片描述" style="zoom:80%;" />
|
||||
|
||||
## 音乐评分实例
|
||||
|
||||
假设每个用户都有自己的听歌偏好， 比如用户 A 喜欢带有**小清新的**， **吉他伴奏的**， **王菲**的歌曲，如果一首歌正好**是王菲唱的， 并且是吉他伴奏的小清新**， 那么就可以将这首歌推荐给这个用户。 也就是说是**小清新， 吉他伴奏， 王菲**这些元素连接起了用户和歌曲。
|
||||
|
||||
当然每个用户对不同的元素偏好不同， 每首歌包含的元素也不一样， 所以我们就希望找到下面的两个矩阵：
|
||||
|
||||
1. 潜在因子—— 用户矩阵Q
|
||||
这个矩阵表示不同用户对于不同元素的偏好程度， 1代表很喜欢， 0代表不喜欢， 比如下面这样：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/2020082222025968.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="在这里插入图片描述" style="zoom:70%;" />
|
||||
</div>
|
||||
2. 潜在因子——音乐矩阵P
|
||||
表示每种音乐含有各种元素的成分， 比如下表中， 音乐A是一个偏小清新的音乐， 含有小清新的Latent Factor的成分是0.9， 重口味的成分是0.1， 优雅成分0.2...
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20200822220751394.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="在这里插入图片描述" style="zoom:70%;" />
|
||||
</div>
|
||||
**计算张三对音乐A的喜爱程度**
|
||||
|
||||
利用上面的这两个矩阵，将对应向量进行内积计算，我们就能得出张三对音乐A的喜欢程度：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20200822221627219.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="在这里插入图片描述" style="zoom:55%;" />
|
||||
</div>
|
||||
|
||||
+ 张三对**小清新**的偏好 * 音乐A含有**小清新**的成分 + 张三对**重口味**的偏好 * 音乐A含有**重口味**的成分 + 张三对**优雅**的偏好 * 音乐A含有**优雅**的成分...
|
||||
|
||||
+ 根据隐向量其实就可以得到张三对音乐A的打分，即： $$0.6 * 0.9 + 0.8 * 0.1 + 0.1 * 0.2 + 0.1 * 0.4 + 0.7 * 0 = 0.68$$。
|
||||
|
||||
**计算所有用户对不同音乐的喜爱程度**
|
||||
|
||||
按照这个计算方式， 每个用户对每首歌其实都可以得到这样的分数， 最后就得到了我们的评分矩阵：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20200822222141231.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="在这里插入图片描述" style="zoom:60%;" />
|
||||
</div>
|
||||
+ 红色部分表示用户没有打分，可以通过隐向量计算得到的。
|
||||
|
||||
**小结**
|
||||
|
||||
+ 上面例子中的小清晰， 重口味， 优雅这些就可以看做是隐含特征， 而通过这个隐含特征就可以把用户的兴趣和音乐的进行一个分类， 其实就是找到了每个用户每个音乐的一个隐向量表达形式（与深度学习中的embedding等价）
|
||||
+ 这个隐向量就可以反映出用户的兴趣和物品的风格，并能将相似的物品推荐给相似的用户等。 **有没有感觉到是把协同过滤算法进行了一种延伸， 把用户的相似性和物品的相似性通过了一个叫做隐向量的方式进行表达**
|
||||
|
||||
+ 现实中，类似于上述的矩阵 $P,Q$ 一般很难获得。有的只是用户的评分矩阵，如下：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20200822223313349.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="在这里插入图片描述" style="zoom:60%;" />
|
||||
</div>
|
||||
|
||||
+ 这种矩阵非常的稀疏，如果直接基于用户相似性或者物品相似性去填充这个矩阵是不太容易的。
|
||||
+ 并且很容易出现长尾问题， 而矩阵分解就可以比较容易的解决这个问题。
|
||||
|
||||
+ 矩阵分解模型:
|
||||
|
||||
+ 基于评分矩阵，将其分解成Q和P两个矩阵乘积的形式，获取用户兴趣和物品的隐向量表达。
|
||||
+ 然后，基于两个分解矩阵去预测某个用户对某个物品的评分了。
|
||||
+ 最后，基于预测评分去进行物品推荐。
|
||||
|
||||
|
||||
|
||||
# 矩阵分解算法
|
||||
|
||||
## 算法原理
|
||||
|
||||
在矩阵分解的算法框架下， **可以通过分解协同过滤的共现矩阵（评分矩阵）来得到用户和物品的隐向量**，原理如下：。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20200823101513233.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="在这里插入图片描述" style="zoom:70%;" />
|
||||
</div>
|
||||
+ 矩阵分解算法将 $m\times n$ 维的共享矩阵 $R$ ，分解成 $m \times k$ 维的用户矩阵 $U$ 和 $k \times n$ 维的物品矩阵 $V$ 相乘的形式。
|
||||
+ 其中，$m$ 是用户数量， $n$ 是物品数量， $k$ 是隐向量维度， 也就是隐含特征个数。
|
||||
+ 这里的隐含特征没有太好的可解释性，需要模型自己去学习。
|
||||
+ 一般而言， $k$ 越大隐向量能承载的信息内容越多，表达能力也会更强，但相应的学习难度也会增加。所以，我们需要根据训练集样本的数量去选择合适的数值，在保证信息学习相对完整的前提下，降低模型的学习难度。
|
||||
|
||||
## 评分预测
|
||||
|
||||
在分解得到用户矩阵和物品矩阵后，若要计算用户 $u$ 对物品 $i$ 的评分，公式如下：
|
||||
$$
|
||||
\operatorname{Preference}(u, i)=r_{u i}=p_{u}^{T} q_{i}=\sum_{k=1}^{K} p_{u, k} q_{i,k}
|
||||
$$
|
||||
+ 其中，向量 $p_u$ 表示用户 $u$ 的隐向量，向量 $q_i$ 表示物品 $i$ 的隐向量。
|
||||
+ 用户向量和物品向量的内积 $p_{u}^{T} q_{i}$ 可以表示为用户 $u$ 对物品 $i$ 的预测评分。
|
||||
+ $p_{u,k}$ 和 $q_{i,k}$ 是模型的参数， $p_{u,k}$ 度量的是用户 $u$ 的兴趣和第 $k$ 个隐类的关系，$q_{i,k}$ 度量了第 $k$ 个隐类和物品 $i$ 之间的关系。
|
||||
|
||||
## 矩阵分解求解
|
||||
|
||||
常用的矩阵分解方法有特征值分解(EVD)或者奇异值分解(SVD）， 具体原理可参考：
|
||||
|
||||
> [奇异值分解svd原理详解及推导](https://blog.csdn.net/wuzhongqiang/article/details/108168238)
|
||||
|
||||
+ 对于 EVD， 它要求分解的矩阵是方阵， 绝大部分场景下用户-物品矩阵不满足这个要求。
|
||||
+ 传统的 SVD 分解， 会要求原始矩阵是稠密的。但现实中用户的评分矩阵是非常稀疏的。
|
||||
+ 如果想用奇异值分解， 就必须对缺失的元素进行填充（比如填 0 ）。
|
||||
+ 填充不但会导致空间复杂度增高，且补全内容不一定准确。
|
||||
+ 另外，SVD 分解计算复杂度非常高，而用户-物品的评分矩阵较大，不具备普适性。
|
||||
|
||||
## FunkSVD
|
||||
|
||||
2006年的Netflix Prize之后， Simon Funk公布了一个矩阵分解算法叫做**Funk-SVD**, 后来被 Netflix Prize 的冠军Koren称为**Latent Factor Model(LFM)**。
|
||||
|
||||
Funk-SVD的思想很简单： **把求解上面两个矩阵的参数问题转换成一个最优化问题， 可以通过训练集里面的观察值利用最小化来学习用户矩阵和物品矩阵**。
|
||||
|
||||
**算法过程**
|
||||
|
||||
1. 根据前面提到的，在有用户矩阵和物品矩阵的前提下，若要计算用户 $u$ 对物品 $i$ 的评分， 可以根据公式：
|
||||
$$
|
||||
\operatorname{Preference}(u, i)=r_{u i}=p_{u}^{T} q_{i}=\sum_{k=1}^{K} p_{u, k} q_{i,k}
|
||||
$$
|
||||
|
||||
+ 其中，向量 $p_u$ 表示用户 $u$ 的隐向量，向量 $q_i$ 表示物品 $i$ 的隐向量。
|
||||
|
||||
2. 随机初始化一个用户矩阵 $U$ 和一个物品矩阵 $V$，获取每个用户和物品的初始隐语义向量。
|
||||
|
||||
3. 将用户和物品的向量内积 $p_{u}^{T} q_{i}$， 作为用户对物品的预测评分 $\hat{r}_{u i}$。
|
||||
|
||||
+ $\hat{r}_{u i}=p_{u}^{T} q_{i}$ 表示的是通过建模，求得的用户 $u$ 对物品的预测评分。
|
||||
+ 在用户对物品的评分矩阵中，矩阵中的元素 $r_{u i}$ 才是用户对物品的真实评分。
|
||||
|
||||
4. 对于评分矩阵中的每个元素，计算预测误差 $e_{u i}=r_{u i}-\hat{r}_{u i}$，对所有训练样本的平方误差进行累加：
|
||||
$$
|
||||
\operatorname{SSE}=\sum_{u, i} e_{u i}^{2}=\sum_{u, i}\left(r_{u i}-\sum_{k=1}^{K} p_{u,k} q_{i,k}\right)^{2}
|
||||
$$
|
||||
|
||||
+ 从上述公式可以看出，$SSE$ 建立起了训练数据和预测模型之间的关系。
|
||||
|
||||
+ 如果我们希望模型预测的越准确，那么在训练集（已有的评分矩阵）上的预测误差应该仅可能小。
|
||||
|
||||
+ 为方便后续求解，给 $SSE$ 增加系数 $1/2$ ：
|
||||
$$
|
||||
\operatorname{SSE}=\frac{1}{2} \sum_{u, i} e_{u i}^{2}=\frac{1}{2} \sum_{u, i}\left(r_{u i}-\sum_{k=1}^{K} p_{u k} q_{i k}\right)^{2}
|
||||
$$
|
||||
|
||||
5. 前面提到，模型预测越准确等价于预测误差越小，那么优化的目标函数变为：
|
||||
$$
|
||||
\min _{\boldsymbol{q}^{*}, \boldsymbol{p}^{*}} \frac{1}{2} \sum_{(u, i) \in K}\left(\boldsymbol{r}_{\mathrm{ui}}-p_{u}^{T} q_{i}\right)^{2}
|
||||
$$
|
||||
|
||||
+ $K$ 表示所有用户评分样本的集合，**即评分矩阵中不为空的元素**，其他空缺值在测试时是要预测的。
|
||||
+ 该目标函数需要优化的目标是用户矩阵 $U$ 和一个物品矩阵 $V$。
|
||||
|
||||
6. 对于给定的目标函数，可以通过梯度下降法对参数进行优化。
|
||||
|
||||
+ 求解目标函数 $SSE$ 关于用户矩阵中参数 $p_{u,k}$ 的梯度：
|
||||
$$
|
||||
\frac{\partial}{\partial p_{u,k}} S S E=\frac{\partial}{\partial p_{u,k}}\left(\frac{1}{2}e_{u i}^{2}\right) =e_{u i} \frac{\partial}{\partial p_{u,k}} e_{u i}=e_{u i} \frac{\partial}{\partial p_{u,k}}\left(r_{u i}-\sum_{k=1}^{K} p_{u,k} q_{i,k}\right)=-e_{u i} q_{i,k}
|
||||
$$
|
||||
|
||||
+ 求解目标函数 $SSE$ 关于 $q_{i,k}$ 的梯度：
|
||||
$$
|
||||
\frac{\partial}{\partial q_{i,k}} S S E=\frac{\partial}{\partial q_{i,k}}\left(\frac{1}{2}e_{u i}^{2}\right) =e_{u i} \frac{\partial}{\partial q_{i,k}} e_{u i}=e_{u i} \frac{\partial}{\partial q_{i,k}}\left(r_{u i}-\sum_{k=1}^{K} p_{u,k} q_{i,k}\right)=-e_{u i} p_{u,k}
|
||||
$$
|
||||
|
||||
7. 参数梯度更新
|
||||
$$
|
||||
p_{u, k}=p_{u,k}-\eta (-e_{ui}q_{i, k})=p_{u,k}+\eta e_{ui}q_{i, k} \\
|
||||
q_{i, k}=q_{i,k}-\eta (-e_{ui}p_{u,k})=q_{i, k}+\eta e_{ui}p_{u, k}
|
||||
$$
|
||||
|
||||
+ 其中，$\eta$ 表示学习率， 用于控制步长。
|
||||
+ 但上面这个有个问题就是当参数很多的时候， 就是两个矩阵很大的时候， 往往容易陷入过拟合的困境， 这时候， 就需要在目标函数上面加上正则化的损失， 就变成了RSVD， 关于RSVD的详细内容， 可以参考下面给出的链接， 由于篇幅原因， 这里不再过多的赘述。
|
||||
|
||||
**加入正则项**
|
||||
|
||||
为了控制模型的复杂度。在原有模型的基础上，加入 $l2$ 正则项，来防止过拟合。
|
||||
|
||||
+ 当模型参数过大，而输入数据发生变化时，可能会造成输出的不稳定。
|
||||
|
||||
+ $l2$ 正则项等价于假设模型参数符合0均值的正态分布，从而使得模型的输出更加稳定。
|
||||
|
||||
$$
|
||||
\min _{\boldsymbol{q}^{*}, \boldsymbol{p}^{*}} \frac{1}{2} \sum_{(u, i) \in K}\left(\boldsymbol{r}_{\mathrm{ui}}-p_{u}^{T} q_{i}\right)^{2}
|
||||
+ \lambda\left(\left\|p_{u}\right\|^{2}+\left\|q_{i}\right\|^{2}\right)
|
||||
$$
|
||||
|
||||
## BiasSVD
|
||||
|
||||
在推荐系统中，评分预测除了与用户的兴趣偏好、物品的特征属性相关外，与其他的因素也相关。例如：
|
||||
|
||||
+ 例如，对于乐观的用户来说，它的评分行为普遍偏高，而对批判性用户来说，他的评分记录普遍偏低，即使他们对同一物品的评分相同，但是他们对该物品的喜好程度却并不一样。
|
||||
+ 对物品来说也是类似的。以电影为例，受大众欢迎的电影得到的评分普遍偏高，而一些烂片的评分普遍偏低，这些因素都是独立于用户或产品的因素，和用户对产品的的喜好无关。
|
||||
|
||||
因此， Netfix Prize中提出了另一种LFM， 在原来的基础上加了偏置项， 来消除用户和物品打分的偏差， 即预测公式如下：
|
||||
$$
|
||||
\hat{r}_{u i}=\mu+b_{u}+b_{i}+p_{u}^{T} \cdot q_{i}
|
||||
$$
|
||||
这个预测公式加入了3项偏置参数 $\mu,b_u,b_i$, 作用如下：
|
||||
|
||||
- $\mu$： 该参数反映的是推荐模型整体的平均评分，一般使用所有样本评分的均值。
|
||||
- $b_u$：用户偏差系数。可以使用用户 $u$ 给出的所有评分的均值， 也可以当做训练参数。
|
||||
- 这一项表示了用户的评分习惯中和物品没有关系的那种因素。 比如有些用户比较苛刻， 对什么东西要求很高， 那么他评分就会偏低， 而有些用户比较宽容， 对什么东西都觉得不错， 那么评分就偏高
|
||||
- $b_i$：物品偏差系数。可以使用物品 $i$ 收到的所有评分的均值， 也可以当做训练参数。
|
||||
- 这一项表示了物品接受的评分中和用户没有关系的因素。 比如有些物品本身质量就很高， 因此获得的评分相对比较高， 有的物品本身质量很差， 因此获得的评分相对较低。
|
||||
|
||||
加了用户和物品的打分偏差之后， 矩阵分解得到的隐向量更能反映不同用户对不同物品的“真实”态度差异， 也就更容易捕捉评价数据中有价值的信息， 从而避免推荐结果有偏。
|
||||
|
||||
**优化函数**
|
||||
|
||||
在加入正则项的FunkSVD的基础上，BiasSVD 的目标函数如下：
|
||||
$$
|
||||
\begin{aligned}
|
||||
\min _{q^{*}, p^{*}} \frac{1}{2} \sum_{(u, i) \in K} &\left(r_{u i}-\left(\mu+b_{u}+b_{i}+q_{i}^{T} p_{u}\right)\right)^{2} \\
|
||||
&+\lambda\left(\left\|p_{u}\right\|^{2}+\left\|q_{i}\right\|^{2}+b_{u}^{2}+b_{i}^{2}\right)
|
||||
\end{aligned}
|
||||
$$
|
||||
可得偏置项的梯度更新公式如下：
|
||||
|
||||
+ $\frac{\partial}{\partial b_{i}} S S E=-e_{u i}+\lambda b_{i}$
|
||||
+ $ \frac{\partial}{\partial b_{u}} S S E=-e_{u i}+\lambda b_{u} \ $
|
||||
|
||||
# 编程实现
|
||||
|
||||
本小节，使用如下图表来预测Alice对物品5的评分：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20200827150237921.png#pic_center" alt="在这里插入图片描述" style="zoom:80%;" />
|
||||
</div>
|
||||
基于矩阵分解算法的流程如下：
|
||||
|
||||
1. 首先， 它会先初始化用户矩阵 $P$ 和物品矩阵 $Q$ ， $P$ 的维度是`[users_num, K]`，$Q$ 的维度是`[items_num, K]`，
|
||||
|
||||
+ 其中，`F`表示隐向量的维度。 也就是把通过隐向量的方式把用户的兴趣和`F`的特点关联了起来。
|
||||
|
||||
+ 初始化这两个矩阵的方式很多， 但根据经验， 随机数需要和`1/sqrt(F)`成正比。
|
||||
|
||||
2. 根据预测评分和真实评分的偏差，利用梯度下降法进行参数更新。
|
||||
|
||||
+ 遍历用户及其交互过的物品，对已交互过的物品进行评分预测。
|
||||
+ 由于预测评分与真实评分存在偏差， 再根据第3节的梯度更新公式更新参数。
|
||||
|
||||
3. 训练完成后，利用用户向量与目标物品向量的内积进行评分预测。
|
||||
|
||||
**完整代码如下：**
|
||||
|
||||
```python
|
||||
import random
|
||||
import math
|
||||
|
||||
|
||||
class BiasSVD():
|
||||
def __init__(self, rating_data, F=5, alpha=0.1, lmbda=0.1, max_iter=100):
|
||||
self.F = F # 这个表示隐向量的维度
|
||||
self.P = dict() # 用户矩阵P 大小是[users_num, F]
|
||||
self.Q = dict() # 物品矩阵Q 大小是[item_nums, F]
|
||||
self.bu = dict() # 用户偏置系数
|
||||
self.bi = dict() # 物品偏置系数
|
||||
self.mu = 0 # 全局偏置系数
|
||||
self.alpha = alpha # 学习率
|
||||
self.lmbda = lmbda # 正则项系数
|
||||
self.max_iter = max_iter # 最大迭代次数
|
||||
self.rating_data = rating_data # 评分矩阵
|
||||
|
||||
for user, items in self.rating_data.items():
|
||||
# 初始化矩阵P和Q, 随机数需要和1/sqrt(F)成正比
|
||||
self.P[user] = [random.random() / math.sqrt(self.F) for x in range(0, F)]
|
||||
self.bu[user] = 0
|
||||
for item, rating in items.items():
|
||||
if item not in self.Q:
|
||||
self.Q[item] = [random.random() / math.sqrt(self.F) for x in range(0, F)]
|
||||
self.bi[item] = 0
|
||||
|
||||
# 采用随机梯度下降的方式训练模型参数
|
||||
def train(self):
|
||||
cnt, mu_sum = 0, 0
|
||||
for user, items in self.rating_data.items():
|
||||
for item, rui in items.items():
|
||||
mu_sum, cnt = mu_sum + rui, cnt + 1
|
||||
self.mu = mu_sum / cnt
|
||||
|
||||
for step in range(self.max_iter):
|
||||
# 遍历所有的用户及历史交互物品
|
||||
for user, items in self.rating_data.items():
|
||||
# 遍历历史交互物品
|
||||
for item, rui in items.items():
|
||||
rhat_ui = self.predict(user, item) # 评分预测
|
||||
e_ui = rui - rhat_ui # 评分预测偏差
|
||||
|
||||
# 参数更新
|
||||
self.bu[user] += self.alpha * (e_ui - self.lmbda * self.bu[user])
|
||||
self.bi[item] += self.alpha * (e_ui - self.lmbda * self.bi[item])
|
||||
for k in range(0, self.F):
|
||||
self.P[user][k] += self.alpha * (e_ui * self.Q[item][k] - self.lmbda * self.P[user][k])
|
||||
self.Q[item][k] += self.alpha * (e_ui * self.P[user][k] - self.lmbda * self.Q[item][k])
|
||||
# 逐步降低学习率
|
||||
self.alpha *= 0.1
|
||||
|
||||
|
||||
# 评分预测
|
||||
def predict(self, user, item):
|
||||
return sum(self.P[user][f] * self.Q[item][f] for f in range(0, self.F)) + self.bu[user] + self.bi[
|
||||
item] + self.mu
|
||||
|
||||
|
||||
# 通过字典初始化训练样本，分别表示不同用户（1-5）对不同物品（A-E)的真实评分
|
||||
def loadData():
|
||||
rating_data={1: {'A': 5, 'B': 3, 'C': 4, 'D': 4},
|
||||
2: {'A': 3, 'B': 1, 'C': 2, 'D': 3, 'E': 3},
|
||||
3: {'A': 4, 'B': 3, 'C': 4, 'D': 3, 'E': 5},
|
||||
4: {'A': 3, 'B': 3, 'C': 1, 'D': 5, 'E': 4},
|
||||
5: {'A': 1, 'B': 5, 'C': 5, 'D': 2, 'E': 1}
|
||||
}
|
||||
return rating_data
|
||||
|
||||
# 加载数据
|
||||
rating_data = loadData()
|
||||
# 建立模型
|
||||
basicsvd = BiasSVD(rating_data, F=10)
|
||||
# 参数训练
|
||||
basicsvd.train()
|
||||
# 预测用户1对物品E的评分
|
||||
for item in ['E']:
|
||||
print(item, basicsvd.predict(1, item))
|
||||
|
||||
# 预测结果：E 3.685084274454321
|
||||
```
|
||||
# 课后思考
|
||||
|
||||
1. 矩阵分解算法后续有哪些改进呢?针对这些改进，是为了解决什么的问题呢？请大家自行探索RSVD，消除用户和物品打分偏差等。
|
||||
|
||||
2. 矩阵分解的优缺点分析
|
||||
|
||||
* 优点：
|
||||
* 泛化能力强： 一定程度上解决了稀疏问题
|
||||
* 空间复杂度低： 由于用户和物品都用隐向量的形式存放， 少了用户和物品相似度矩阵， 空间复杂度由$n^2$降到了$(n+m)*f$
|
||||
* 更好的扩展性和灵活性：矩阵分解的最终产物是用户和物品隐向量， 这个深度学习的embedding思想不谋而合， 因此矩阵分解的结果非常便于与其他特征进行组合和拼接， 并可以与深度学习无缝结合。
|
||||
|
||||
+ 缺点：
|
||||
+ 矩阵分解算法依然是只用到了评分矩阵， 没有考虑到用户特征， 物品特征和上下文特征， 这使得矩阵分解丧失了利用很多有效信息的机会。
|
||||
+ 同时在缺乏用户历史行为的时候， 无法进行有效的推荐。
|
||||
+ 为了解决这个问题， **逻辑回归模型及后续的因子分解机模型**， 凭借其天然的融合不同特征的能力， 逐渐在推荐系统领域得到了更广泛的应用。
|
||||
|
||||
# 参考资料
|
||||
|
||||
* 王喆 - 《深度学习推荐系统》
|
||||
* 项亮 - 《推荐系统实战》
|
||||
* [奇异值分解(SVD)的原理详解及推导](https://blog.csdn.net/wuzhongqiang/article/details/108168238)
|
||||
* [Matrix factorization techniques for recommender systems论文](https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=5197422&tag=1)
|
||||
* [隐语义模型(LFM)和矩阵分解(MF)](https://blog.csdn.net/wuzhongqiang/article/details/108173885)
|
||||
344
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.1/usercf.md
Normal file
344
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.1/usercf.md
Normal file
@@ -0,0 +1,344 @@
|
||||
# 协同过滤算法
|
||||
|
||||
## 基本思想
|
||||
|
||||
协同过滤（Collaborative Filtering）推荐算法是最经典、最常用的推荐算法。基本思想是：
|
||||
|
||||
+ 根据用户之前的喜好以及其他兴趣相近的用户的选择来给用户推荐物品。
|
||||
|
||||
+ 基于对用户历史行为数据的挖掘发现用户的喜好偏向， 并预测用户可能喜好的产品进行推荐。
|
||||
+ 一般是仅仅基于用户的行为数据（评价、购买、下载等）, 而不依赖于项的任何附加信息（物品自身特征）或者用户的任何附加信息（年龄， 性别等）。
|
||||
+ 目前应用比较广泛的协同过滤算法是基于邻域的方法，主要有：
|
||||
+ 基于用户的协同过滤算法（UserCF）：给用户推荐和他兴趣相似的其他用户喜欢的产品。
|
||||
+ 基于物品的协同过滤算法（ItemCF）：给用户推荐和他之前喜欢的物品相似的物品。
|
||||
|
||||
不管是 UserCF 还是 ItemCF 算法， 重点是计算用户之间（或物品之间）的相似度。
|
||||
|
||||
## 相似性度量方法
|
||||
|
||||
1. **杰卡德（Jaccard）相似系数**
|
||||
|
||||
`Jaccard` 系数是衡量两个集合的相似度一种指标，计算公式如下：
|
||||
$$
|
||||
sim_{uv}=\frac{|N(u) \cap N(v)|}{|N(u)| \cup|N(v)|}
|
||||
$$
|
||||
|
||||
+ 其中 $N(u)$，$N(v)$ 分别表示用户 $u$ 和用户 $v$ 交互物品的集合。
|
||||
|
||||
+ 对于用户 $u$ 和 $v$ ，该公式反映了两个交互物品交集的数量占这两个用户交互物品并集的数量的比例。
|
||||
|
||||
由于杰卡德相似系数一般无法反映具体用户的评分喜好信息，所以常用来评估用户是否会对某物品进行打分， 而不是预估用户会对某物品打多少分。
|
||||
|
||||
2. **余弦相似度**
|
||||
余弦相似度衡量了两个向量的夹角，夹角越小越相似。余弦相似度的计算如下，其与杰卡德（Jaccard）相似系数只是在分母上存在差异：
|
||||
$$
|
||||
sim_{uv}=\frac{|N(u) \cap N(v)|}{\sqrt{|N(u)|\cdot|N(v)|}}
|
||||
$$
|
||||
从向量的角度进行描述，令矩阵 $A$ 为用户-物品交互矩阵，矩阵的行表示用户，列表示物品。
|
||||
|
||||
+ 设用户和物品数量分别为 $m,n$，交互矩阵$A$就是一个 $m$ 行 $n$ 列的矩阵。
|
||||
|
||||
+ 矩阵中的元素均为 $0/1$。若用户 $i$ 对物品 $j$ 存在交互，那么 $A_{i,j}=1$，否则为 $0$ 。
|
||||
|
||||
+ 那么，用户之间的相似度可以表示为：
|
||||
$$
|
||||
sim_{uv} = cos(u,v) =\frac{u\cdot v}{|u|\cdot |v|}
|
||||
$$
|
||||
|
||||
+ 向量 $u,v$ 在形式都是 one-hot 类型，$u\cdot v$ 表示向量点积。
|
||||
|
||||
上述用户-物品交互矩阵在现实中是十分稀疏的，为了节省内存，交互矩阵会采用字典进行存储。在 `sklearn` 中，余弦相似度的实现：
|
||||
|
||||
```python
|
||||
from sklearn.metrics.pairwise import cosine_similarity
|
||||
|
||||
i = [1, 0, 0, 0]
|
||||
j = [1, 0, 1, 0]
|
||||
cosine_similarity([i, j])
|
||||
```
|
||||
|
||||
3. **皮尔逊相关系数**
|
||||
|
||||
在用户之间的余弦相似度计算时，将用户向量的内积展开为各元素乘积和：
|
||||
$$
|
||||
sim_{uv} = \frac{\sum_i r_{ui}*r_{vi}}{\sqrt{\sum_i r_{ui}^2}\sqrt{\sum_i r_{vi}^2}}
|
||||
$$
|
||||
+ 其中，$r_{ui},r_{vi}$ 分别表示用户 $u$ 和用户 $v$ 对物品 $i$ 是否有交互(或具体评分值)。
|
||||
|
||||
皮尔逊相关系数与余弦相似度的计算公式非常的类似，如下：
|
||||
$$
|
||||
sim(u,v)=\frac{\sum_{i\in I}(r_{ui}-\bar r_u)(r_{vi}-\bar r_v)}{\sqrt{\sum_{i\in I }(r_{ui}-\bar r_u)^2}\sqrt{\sum_{i\in I }(r_{vi}-\bar r_v)^2}}
|
||||
$$
|
||||
+ 其中，$r_{ui},r_{vi}$ 分别表示用户 $u$ 和用户 $v$ 对物品 $i$ 是否有交互(或具体评分值)；
|
||||
+ $\bar r_u, \bar r_v$ 分别表示用户 $u$ 和用户 $v$ 交互的所有物品交互数量或者评分的平均值；
|
||||
|
||||
相较于余弦相似度，皮尔逊相关系数通过使用用户的平均分对各独立评分进行修正，减小了用户评分偏置的影响。在`scipy`中，皮尔逊相关系数的实现：
|
||||
|
||||
```python
|
||||
from scipy.stats import pearsonr
|
||||
|
||||
i = [1, 0, 0, 0]
|
||||
j = [1, 0.5, 0.5, 0]
|
||||
pearsonr(i, j)
|
||||
```
|
||||
|
||||
**适用场景**
|
||||
|
||||
+ $Jaccard$ 相似度表示两个集合的交集元素个数在并集中所占的比例 ，所以适用于隐式反馈数据（0-1）。
|
||||
+ 余弦相似度在度量文本相似度、用户相似度、物品相似度的时候都较为常用。
|
||||
+ 皮尔逊相关度，实际上也是一种余弦相似度。不过先对向量做了中心化，范围在 $-1$ 到 $1$。
|
||||
+ 相关度量的是两个变量的变化趋势是否一致，两个随机变量是不是同增同减。
|
||||
+ 不适合用作计算布尔值向量（0-1）之间相关度。
|
||||
|
||||
# 基于用户的协同过滤
|
||||
|
||||
## 基本思想
|
||||
|
||||
基于用户的协同过滤（UserCF）：
|
||||
|
||||
+ 例如，我们要对用户 $A$ 进行物品推荐，可以先找到和他有相似兴趣的其他用户。
|
||||
+ 然后，将共同兴趣用户喜欢的，但用户 $A$ 未交互过的物品推荐给 $A$。
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20210629232540289.png" alt="image-20210629232540289" style="zoom: 80%;" />
|
||||
|
||||
## 计算过程
|
||||
|
||||
以下图为例，给用户推荐物品的过程可以形象化为一个猜测用户对物品进行打分的任务，表格里面是5个用户对于5件物品的一个打分情况，就可以理解为用户对物品的喜欢程度。
|
||||
|
||||
|
||||
|
||||
UserCF算法的两个步骤：
|
||||
|
||||
+ 首先，根据前面的这些打分情况(或者说已有的用户向量）计算一下 Alice 和用户1， 2， 3， 4的相似程度， 找出与 Alice 最相似的 n 个用户。
|
||||
|
||||
+ 根据这 n 个用户对物品 5 的评分情况和与 Alice 的相似程度会猜测出 Alice 对物品5的评分。如果评分比较高的话， 就把物品5推荐给用户 Alice， 否则不推荐。
|
||||
|
||||
**具体过程：**
|
||||
|
||||
1. 计算用户之间的相似度
|
||||
|
||||
+ 根据 1.2 节的几种方法， 我们可以计算出各用户之间的相似程度。对于用户 Alice，选取出与其最相近的 $N$ 个用户。
|
||||
|
||||
2. 计算用户对新物品的评分预测
|
||||
|
||||
+ 常用的方式之一：利用目标用户与相似用户之间的相似度以及相似用户对物品的评分，来预测目标用户对候选物品的评分估计：
|
||||
$$
|
||||
R_{\mathrm{u}, \mathrm{p}}=\frac{\sum_{\mathrm{s} \in S}\left(w_{\mathrm{u}, \mathrm{s}} \cdot R_{\mathrm{s}, \mathrm{p}}\right)}{\sum_{\mathrm{s} \in S} w_{\mathrm{u}, \mathrm{s}}}
|
||||
$$
|
||||
|
||||
+ 其中，权重 $w_{u,s}$ 是用户 $u$ 和用户 $s$ 的相似度， $R_{s,p}$ 是用户 $s$ 对物品 $p$ 的评分。
|
||||
|
||||
+ 另一种方式：考虑到用户评分的偏置，即有的用户喜欢打高分， 有的用户喜欢打低分的情况。公式如下：
|
||||
$$
|
||||
R_{\mathrm{u}, \mathrm{p}}=\bar{R}_{u} + \frac{\sum_{\mathrm{s} \in S}\left(w_{\mathrm{u}, \mathrm{s}} \cdot \left(R_{s, p}-\bar{R}_{s}\right)\right)}{\sum_{\mathrm{s} \in S} w_{\mathrm{u}, \mathrm{s}}}
|
||||
$$
|
||||
|
||||
+ 其中，$\bar{R}_{s}$ 表示用户 $s$ 对物品的历史平均评分。
|
||||
|
||||
3. 对用户进行物品推荐
|
||||
|
||||
+ 在获得用户 $u$ 对不同物品的评价预测后， 最终的推荐列表根据预测评分进行排序得到。
|
||||
|
||||
**手动计算：**
|
||||
|
||||
根据上面的问题， 下面手动计算 Alice 对物品 5 的得分：
|
||||
|
||||
|
||||
1. 计算 Alice 与其他用户的相似度（基于皮尔逊相关系数）
|
||||
|
||||
+ 手动计算 Alice 与用户 1 之间的相似度：
|
||||
|
||||
>用户向量 $\text {Alice}:(5,3,4,4) , \text{user1}:(3,1,2,3) , \text {user2}:( 4,3,4,3) , \text {user3}:(3,3,1,5) , \text {user4}:(1,5,5,2) $
|
||||
>
|
||||
>+ 计算Alice与user1的余弦相似性:
|
||||
>$$
|
||||
>\operatorname{sim}(\text { Alice, user1 })=\cos (\text { Alice, user } 1)=\frac{15+3+8+12}{\operatorname{sqrt}(25+9+16+16) * \operatorname{sqrt}(9+1+4+9)}=0.975
|
||||
>$$
|
||||
>
|
||||
>+ 计算Alice与user1皮尔逊相关系数:
|
||||
> + $Alice\_ave =4 \quad user1\_ave =2.25 $
|
||||
> + 向量减去均值: $\text {Alice}:(1,-1, 0,0) \quad \text { user1 }:(0.75,-1.25,-0.25,0.75)$
|
||||
>
|
||||
>+ 计算这俩新向量的余弦相似度和上面计算过程一致, 结果是 0.852 。
|
||||
>
|
||||
|
||||
+ 基于 sklearn 计算所有用户之间的皮尔逊相关系数。可以看出，与 Alice 相似度最高的用户为用户1和用户2。
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/JavaWJkjP2fHH27Rajrj.png!thumbnail" alt="图片" style="zoom:80%;" />
|
||||
|
||||
2. **根据相似度用户计算 Alice对物品5的最终得分**
|
||||
用户1对物品5的评分是3， 用户2对物品5的打分是5， 那么根据上面的计算公式， 可以计算出 Alice 对物品5的最终得分是
|
||||
$$
|
||||
P_{Alice, 物品5}=\bar{R}_{Alice}+\frac{\sum_{k=1}^{2}\left(w_{Alice,user k}\left(R_{userk, 物品5}-\bar{R}_{userk}\right)\right)}{\sum_{k=1}^{2} w_{Alice, userk}}=4+\frac{0.85*(3-2.4)+0.7*(5-3.8)}{0.85+0.7}=4.87
|
||||
$$
|
||||
|
||||
+ 同样方式，可以计算用户 Alice 对其他物品的评分预测。
|
||||
|
||||
3. **根据用户评分对用户进行推荐**
|
||||
|
||||
+ 根据 Alice 的打分对物品排个序从大到小：$$物品1>物品5>物品3=物品4>物品2$$。
|
||||
+ 如果要向 Alice 推荐2款产品的话， 我们就可以推荐物品 1 和物品 5 给 Alice。
|
||||
|
||||
至此， 基于用户的协同过滤算法原理介绍完毕。
|
||||
|
||||
## UserCF编程实现
|
||||
|
||||
1. 建立实验使用的数据表：
|
||||
|
||||
```python
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
|
||||
|
||||
def loadData():
|
||||
users = {'Alice': {'A': 5, 'B': 3, 'C': 4, 'D': 4},
|
||||
'user1': {'A': 3, 'B': 1, 'C': 2, 'D': 3, 'E': 3},
|
||||
'user2': {'A': 4, 'B': 3, 'C': 4, 'D': 3, 'E': 5},
|
||||
'user3': {'A': 3, 'B': 3, 'C': 1, 'D': 5, 'E': 4},
|
||||
'user4': {'A': 1, 'B': 5, 'C': 5, 'D': 2, 'E': 1}
|
||||
}
|
||||
return users
|
||||
```
|
||||
|
||||
+ 这里使用字典来建立用户-物品的交互表。
|
||||
+ 字典`users`的键表示不同用户的名字，值为一个评分字典，评分字典的键值对表示某物品被当前用户的评分。
|
||||
+ 由于现实场景中，用户对物品的评分比较稀疏。如果直接使用矩阵进行存储，会存在大量空缺值，故此处使用了字典。
|
||||
|
||||
2. 计算用户相似性矩阵
|
||||
|
||||
+ 由于训练数据中共包含 5 个用户，所以这里的用户相似度矩阵的维度也为 $5 \times 5$。
|
||||
|
||||
```python
|
||||
user_data = loadData()
|
||||
similarity_matrix = pd.DataFrame(
|
||||
np.identity(len(user_data)),
|
||||
index=user_data.keys(),
|
||||
columns=user_data.keys(),
|
||||
)
|
||||
|
||||
# 遍历每条用户-物品评分数据
|
||||
for u1, items1 in user_data.items():
|
||||
for u2, items2 in user_data.items():
|
||||
if u1 == u2:
|
||||
continue
|
||||
vec1, vec2 = [], []
|
||||
for item, rating1 in items1.items():
|
||||
rating2 = items2.get(item, -1)
|
||||
if rating2 == -1:
|
||||
continue
|
||||
vec1.append(rating1)
|
||||
vec2.append(rating2)
|
||||
# 计算不同用户之间的皮尔逊相关系数
|
||||
similarity_matrix[u1][u2] = np.corrcoef(vec1, vec2)[0][1]
|
||||
|
||||
print(similarity_matrix)
|
||||
```
|
||||
|
||||
```python
|
||||
1 2 3 4 5
|
||||
1 1.000000 0.852803 0.707107 0.000000 -0.792118
|
||||
2 0.852803 1.000000 0.467707 0.489956 -0.900149
|
||||
3 0.707107 0.467707 1.000000 -0.161165 -0.466569
|
||||
4 0.000000 0.489956 -0.161165 1.000000 -0.641503
|
||||
5 -0.792118 -0.900149 -0.466569 -0.641503 1.000000
|
||||
```
|
||||
|
||||
3. 计算与 Alice 最相似的 `num` 个用户
|
||||
|
||||
```python
|
||||
target_user = ' Alice '
|
||||
num = 2
|
||||
# 由于最相似的用户为自己，去除本身
|
||||
sim_users = similarity_matrix[target_user].sort_values(ascending=False)[1:num+1].index.tolist()
|
||||
print(f'与用户{target_user}最相似的{num}个用户为：{sim_users}')
|
||||
```
|
||||
|
||||
```python
|
||||
与用户 Alice 最相似的2个用户为：['user1', 'user2']
|
||||
```
|
||||
|
||||
4. 预测用户 Alice 对物品 `E` 的评分
|
||||
|
||||
```python
|
||||
weighted_scores = 0.
|
||||
corr_values_sum = 0.
|
||||
|
||||
target_item = 'E'
|
||||
# 基于皮尔逊相关系数预测用户评分
|
||||
for user in sim_users:
|
||||
corr_value = similarity_matrix[target_user][user]
|
||||
user_mean_rating = np.mean(list(user_data[user].values()))
|
||||
|
||||
weighted_scores += corr_value * (user_data[user][target_item] - user_mean_rating)
|
||||
corr_values_sum += corr_value
|
||||
|
||||
target_user_mean_rating = np.mean(list(user_data[target_user].values()))
|
||||
target_item_pred = target_user_mean_rating + weighted_scores / corr_values_sum
|
||||
print(f'用户{target_user}对物品{target_item}的预测评分为：{target_item_pred}')
|
||||
```
|
||||
|
||||
```python
|
||||
用户 Alice 对物品E的预测评分为：4.871979899370592
|
||||
```
|
||||
|
||||
## UserCF优缺点
|
||||
|
||||
User-based算法存在两个重大问题：
|
||||
|
||||
|
||||
1. 数据稀疏性
|
||||
+ 一个大型的电子商务推荐系统一般有非常多的物品，用户可能买的其中不到1%的物品，不同用户之间买的物品重叠性较低，导致算法无法找到一个用户的邻居，即偏好相似的用户。
|
||||
+ 这导致UserCF不适用于那些正反馈获取较困难的应用场景(如酒店预订， 大件物品购买等低频应用)。
|
||||
|
||||
1. 算法扩展性
|
||||
+ 基于用户的协同过滤需要维护用户相似度矩阵以便快速的找出 $TopN$ 相似用户， 该矩阵的存储开销非常大，存储空间随着用户数量的增加而增加。
|
||||
+ 故不适合用户数据量大的情况使用。
|
||||
|
||||
由于UserCF技术上的两点缺陷， 导致很多电商平台并没有采用这种算法， 而是采用了ItemCF算法实现最初的推荐系统。
|
||||
|
||||
|
||||
|
||||
# 算法评估
|
||||
|
||||
由于UserCF和ItemCF结果评估部分是共性知识点， 所以在这里统一标识。
|
||||
|
||||
## 召回率
|
||||
|
||||
对用户 $u$ 推荐 $N$ 个物品记为 $R(u)$, 令用户 $u$ 在测试集上喜欢的物品集合为$T(u)$， 那么召回率定义为：
|
||||
$$
|
||||
\operatorname{Recall}=\frac{\sum_{u}|R(u) \cap T(u)|}{\sum_{u}|T(u)|}
|
||||
$$
|
||||
+ 含义：在模型召回预测的物品中，预测准确的物品占用户实际喜欢的物品的比例。
|
||||
|
||||
## 精确率
|
||||
精确率定义为：
|
||||
$$
|
||||
\operatorname{Precision}=\frac{\sum_{u} \mid R(u) \cap T(u)|}{\sum_{u}|R(u)|}
|
||||
$$
|
||||
+ 含义：推荐的物品中，对用户准确推荐的物品占总物品的比例。
|
||||
+ 如要确保召回率高，一般是推荐更多的物品，期望推荐的物品中会涵盖用户喜爱的物品。而实际中，推荐的物品中用户实际喜爱的物品占少数，推荐的精确率就会很低。故同时要确保高召回率和精确率往往是矛盾的，所以实际中需要在二者之间进行权衡。
|
||||
|
||||
## 覆盖率
|
||||
覆盖率反映了推荐算法发掘长尾的能力， 覆盖率越高， 说明推荐算法越能将长尾中的物品推荐给用户。
|
||||
$$
|
||||
\text { Coverage }=\frac{\left|\bigcup_{u \in U} R(u)\right|}{|I|}
|
||||
$$
|
||||
|
||||
+ 含义：推荐系统能够推荐出来的物品占总物品集合的比例。
|
||||
+ 其中 $|I|$ 表示所有物品的个数；
|
||||
+ 系统的用户集合为$U$;
|
||||
+ 推荐系统给每个用户推荐一个长度为 $N$ 的物品列表$R(u)$.
|
||||
|
||||
+ 覆盖率表示最终的推荐列表中包含多大比例的物品。如果所有物品都被给推荐给至少一个用户， 那么覆盖率是100%。
|
||||
|
||||
## 新颖度
|
||||
用推荐列表中物品的平均流行度度量推荐结果的新颖度。 如果推荐出的物品都很热门， 说明推荐的新颖度较低。 由于物品的流行度分布呈长尾分布， 所以为了流行度的平均值更加稳定， 在计算平均流行度时对每个物品的流行度取对数。
|
||||
|
||||
- O’scar Celma 在博士论文 "[Music Recommendation and Discovery in the Long Tail](http://mtg.upf.edu/static/media/PhD_ocelma.pdf) " 中研究了新颖度的评测。
|
||||
|
||||
|
||||
|
||||
# 参考资料
|
||||
|
||||
* [基于用户的协同过滤来构建推荐系统：https://mp.weixin.qq.com/s/ZtnaQrVIpVOPJpqMdLWOcw](https://mp.weixin.qq.com/s/ZtnaQrVIpVOPJpqMdLWOcw)
|
||||
* B站黑马推荐系统实战课程
|
||||
332
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.2/Airbnb.md
Normal file
332
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.2/Airbnb.md
Normal file
@@ -0,0 +1,332 @@
|
||||
# 前言
|
||||
这是 Airbnb 于2018年发表的一篇论文，主要介绍了 Airbnb 在 Embedding 技术上的应用，并获得了 KDD 2018 的 Best Paper。Airbnb 是全球最大的短租平台，包含了数百万种不同的房源。这篇论文介绍了 Airbnb 如何使用 Embedding 来实现相似房源推荐以及实时个性化搜索。在本文中，Airbnb 在用户和房源的 Embedding 上的生成都是基于谷歌的 Word2Vec 模型，<u>故阅读本文要求大家了解 Word2Vec 模型，特别是 Skip-Gram 模型**（重点*）**</u>。
|
||||
本文将从以下几个方面来介绍该论文：
|
||||
|
||||
- 了解 Airbnb 是如何利用 Word2Vec 技术生成房源和用户的Embedding，并做出了哪些改进。
|
||||
- 了解 Airbnb 是如何利用 Embedding 解决房源冷启动问题。
|
||||
- 了解 Airbnb 是如何衡量生成的 Embedding 的有效性。
|
||||
- 了解 Airbnb 是如何利用用户和房源 Embedding 做召回和搜索排序。
|
||||
|
||||
考虑到本文的目的是为了让大家快速了解 Airbnb 在 Embedding 技术上的应用，故不会完全翻译原论文。如需进一步了解，建议阅读原论文或文末的参考链接。原论文链接：https://dl.acm.org/doi/pdf/10.1145/3219819.3219885
|
||||
|
||||
# Airbnb 的业务背景
|
||||
在介绍 Airbnb 在 Embedding 技术上的方法前，先了解 Airbnb 的业务背景。
|
||||
|
||||
- Airbnb 平台包含数百万种不同的房源，用户可以通过**浏览搜索结果页面**来寻找想要的房源。Airbnb 技术团队通过复杂的机器学习模型，并使用上百种信号对搜索结果中的房源进行排序。
|
||||
- 当用户在查看某一个房源时，接下来的有两种方式继续搜索：
|
||||
- 返回搜索结果页，继续查看其他搜索结果。
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片1653049527431-0b09af70-bda0-4a30-8082-6aa69548213a.png" alt="img" style="zoom:50%;" />
|
||||
|
||||
- 在当前房源的详情页下，「相似房源」板块（你可能还喜欢）所推荐的房源。
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片1653049385995-7a775df1-a36f-4795-9e79-8e577bcf2097.png" alt="img" style="zoom:50%;" />
|
||||
|
||||
- Airbnb 平台 99% 的房源预订来自于搜索排序和相似房源推荐。
|
||||
# Embedding 方法
|
||||
Airbnb 描述了两种 Embedding 的构建方法，分别为：
|
||||
|
||||
- 用于描述短期实时性的个性化特征 Embedding：**listing Embeddings**
|
||||
- **listing 表示房源的意思，<u>它将贯穿全文，请务必了解</u>。**
|
||||
- 用于描述长期的个性化特征 Embedding：**user-type & listing type Embeddings**
|
||||
## Listing Embeddings
|
||||
Listing Embeddings 是基于用户的点击 session 学习得到的，用于表示房源的短期实时性特征。给定数据集 $ \mathcal{S} $ ，其中包含了 $ N $ 个用户的 $ S $ 个点击 session（序列）。
|
||||
|
||||
- 每个 session $ s=\left(l_{1}, \ldots, l_{M}\right) \in \mathcal{S} $ ，包含了 $ M $ 个被用户点击过的 listing ids 。
|
||||
- 对于用户连续两次点击，若时间间隔超过了30分钟，则启动新的 session。
|
||||
|
||||
在拿到多个用户点击的 session 后，可以基于 Word2Vec 的 Skip-Gram 模型来学习不同 listing 的 Embedding 表示。最大化目标函数 $ \mathcal{L} $ ：
|
||||
$$
|
||||
\mathcal{L}=\sum_{s \in \mathcal{S}} \sum_{l_{i} \in s}\left(\sum_{-m \geq j \leq m, i \neq 0} \log \mathbb{P}\left(l_{i+j} \mid l_{i}\right)\right)
|
||||
$$
|
||||
概率 $ \mathbb{P}\left(l_{i+j} \mid l_{i}\right) $ 是基于 soft-max 函数的表达式。表示在一个 session 中，已知中心 listing $ l_i $ 来预测上下文 listing $ l_{i+j} $ 的概率：
|
||||
$$
|
||||
\mathbb{P}\left(l_{i+j} \mid l_{i}\right)=\frac{\exp \left(\mathbf{v}_{l_{i}}^{\top} \mathbf{v}_{l_{i+j}}^{\prime}\right)}{\sum_{l=1}^{|\mathcal{V}|} \exp \left(\mathbf{v}_{l_{i}}^{\top} \mathbf{v}_{l}^{\prime}\right)}
|
||||
$$
|
||||
|
||||
- 其中， $ \mathbf{v}_{l_{i}} $ 表示 listing $ l_i $ 的 Embedding 向量， $ |\mathcal{V}| $ 表示全部的物料库的数量。
|
||||
|
||||
考虑到物料库 $ \mathcal{V} $ 过大，模型中参数更新的时间成本和 $ |\mathcal{V}| $ 成正比。为了降低计算复杂度，要进行负采样。负采样后，优化的目标函数如下：
|
||||
$$
|
||||
\underset{\theta}{\operatorname{argmax}} \sum_{(l, c) \in \mathcal{D}_{p}} \log \frac{1}{1+e^{-\mathbf{v}_{c}^{\prime^{\prime}} \mathbf{v}_{l}}}+\sum_{(l, c) \in \mathcal{D}_{n}} \log \frac{1}{1+e^{\mathbf{v}_{c}^{\prime} \mathbf{v}_{l}}}
|
||||
$$
|
||||
至此，对 Skip-Gram 模型和 NEG 了解的同学肯定很熟悉，上述方法和 Word2Vec 思想基本一致。
|
||||
下面，将进一步介绍 Airbnb 是如何改进 Listing Embedding 的学习以及其他方面的应用。
|
||||
**（1）正负样本集构建的改进**
|
||||
|
||||
- 使用 booked listing 作为全局上下文
|
||||
- booked listing 表示用户在 session 中最终预定的房源，一般只会出现在结束的 session 中。
|
||||
- Airbnb 将最终预定的房源，始终作为滑窗的上下文，即全局上下文。如下图：
|
||||
- 如图，对于当前滑动窗口的 central listing，实线箭头表示context listings，虚线（指向booked listing）表示 global context listing。
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片1653053823336-0564b2da-c993-46aa-9b22-f5cbb784dae2.png" alt="img" style="zoom:50%;" />
|
||||
|
||||
- booked listing 作为全局正样本，故优化的目标函数更新为：
|
||||
|
||||
$$
|
||||
\underset{\theta}{\operatorname{argmax}} \sum_{(l, c) \in \mathcal{D}_{p}} \log \frac{1}{1+e^{-\mathbf{v}_{c}^{\prime^{\prime}} \mathbf{v}_{l}}}+\sum_{(l, c) \in \mathcal{D}_{n}} \log \frac{1}{1+e^{\mathbf{v}_{c}^{\prime} \mathbf{v}_{l}}} +
|
||||
\log \frac{1}{1+e^{-\mathbf{v}_{c}^{\prime} \mathbf{v}_{l_b}}}
|
||||
$$
|
||||
|
||||
- 优化负样本的选择
|
||||
- 用户通过在线网站预定房间时，通常只会在同一个 market （将要停留区域）内进行搜索。
|
||||
|
||||
- 对于用户点击过的样本集 $ \mathcal{D}_{p} $ （正样本集）而言，它们大概率位于同一片区域。考虑到负样本集 $ \mathcal{D}_{n} $ 是随机抽取的，大概率来源不同的区域。
|
||||
|
||||
- Airbnb 发现这种样本的不平衡，在学习同一片区域房源的 Embedding 时会得到次优解。
|
||||
|
||||
- 解决办法也很简单，对于每个滑窗中的中心 lisitng，其负样本的选择新增了与其位于同一个 market 的 listing。至此，优化函数更新如下：
|
||||
$$
|
||||
\underset{\theta}{\operatorname{argmax}} \sum_{(l, c) \in \mathcal{D}_{p}} \log \frac{1}{1+e^{-\mathbf{v}_{c}^{\prime^{\prime}} \mathbf{v}_{l}}}+\sum_{(l, c) \in \mathcal{D}_{n}} \log \frac{1}{1+e^{\mathbf{v}_{c}^{\prime} \mathbf{v}_{l}}} +\log \frac{1}{1+e^{-\mathbf{v}_{c}^{\prime} \mathbf{v}_{l_b}}} +
|
||||
\sum_{(l, m_n ) \in \mathcal{D}_{m_n}} \log \frac{1}{1+e^{\mathbf{v}_{m_n}^{\prime} \mathbf{v}_{l}}}
|
||||
$$
|
||||
|
||||
+ $ \mathcal{D}_{m_n} $ 表示与滑窗中的中心 listing 位于同一区域的负样本集。
|
||||
|
||||
**（2）Listing Embedding 的冷启动**
|
||||
|
||||
- Airbnb 每天都有新的 listings 产生，而这些 listings 却没有 Embedding 向量表征。
|
||||
- Airbnb 建议利用其他 listing 的现有的 Embedding 来为新的 listing 创建 Embedding。
|
||||
- 在新的 listing 被创建后，房主需要提供如位置、价格、类型等在内的信息。
|
||||
- 然后利用房主提供的房源信息，为其查找3个相似的 listing，并将它们 Embedding 的均值作为新 listing 的 Embedding表示。
|
||||
- 这里的相似，包含了位置最近（10英里半径内），房源类型相似，价格区间相近。
|
||||
- 通过该手段，Airbnb 可以解决 98% 以上的新 listing 的 Embedding 冷启动问题。
|
||||
|
||||
**（3）Listing Embedding 的评估**
|
||||
经过上述的两点对 Embedding 的改进后，为了评估改进后 listing Embedding 的效果。
|
||||
|
||||
- Airbnb 使用了800万的点击 session，并将 Embedding 的维度设为32。
|
||||
|
||||
评估方法包括：
|
||||
|
||||
- 评估 Embedding 是否包含 listing 的地理位置相似性。
|
||||
- 理论上，同一区域的房源相似性应该更高，不同区域房源相似性更低。
|
||||
- Airbnb 利用 k-means 聚类，将加利福尼亚州的房源聚成100个集群，来验证类似位置的房源是否聚集在一起。
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片1653056809526-15401069-6fff-40d8-ac5e-35871d3f254a.png" alt="img" style="zoom:50%;" />
|
||||
|
||||
- 评估不同类型、价格区间的房源之间的相似性。
|
||||
- 简而言之，我们希望类型相同、价格区间一致的房源它们之间的相似度更高。
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片1653056981037-18edee91-493a-4d5b-b066-57f0b200032d.png" alt="img" style="zoom:50%;" />
|
||||
|
||||
- 评估房源的隐式特征
|
||||
- Airbnb 在训练房源（listing）的 Embedding时，并没有用到房源的图像信息。
|
||||
- 对于一些隐式信息，例如架构、风格、观感等是无法直接学习。
|
||||
- 为了验证基于 Word2Vec 学习到的 Embedding是否隐含了它们在外观等隐式信息上的相似性，Airbnb 内部开发了一款内部相似性探索工具。
|
||||
- 大致原理就是，利用训练好的 Embedding 进行 K 近邻相似度检索。
|
||||
- 如下，与查询房源在 Embedding 相似性高的其他房源，它们之间的外观风格也很相似。
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片1653057336798-fd8451cb-84b6-40fb-8733-1e3d08a39793.png" alt="img" />
|
||||
|
||||
## User-type & Listing-type Embedding
|
||||
|
||||
前面提到的 Listing Embedding，它是基于用户的点击 sessions 学习得到的。
|
||||
|
||||
- 同一个 session 内的点击时间间隔低于30分钟，所以**它们更适合短期，session 内的个性化需求**。
|
||||
- 在用户搜索 session 期间，该方法有利于向用户展示与点击过的 listing 更相似的其他 listings 。
|
||||
|
||||
Airbnb 除了挖掘 Listing 的短期兴趣特征表示外，还对 User 和 Listing 的长期兴趣特征表示进行了探索。长期兴趣的探索是有利于 Airbnb 的业务发展。例如，用户当前在洛杉矶进行搜索，并且过去在纽约和伦敦预定过其他房源。那么，向用户推荐与之前预定过的 listing 相似的 listings 是更合适的。
|
||||
|
||||
- 长期兴趣的探索是基于 booking session（用户的历史预定序列）。
|
||||
- 与前面 Listing Embedding 的学习类似，Airbnb 希望借助了 Skip-Gram 模型学习不同房源的 Embedding 表示。
|
||||
|
||||
但是，面临着如下的挑战：
|
||||
|
||||
- booking sessions $ \mathcal{S}_{b} $ 数据量的大小远远小于 click sessions $ \mathcal{S} $ ，因为预定本身就是一件低频率事件。
|
||||
- 许多用户过去只预定了单个数量的房源，无法从长度为1的 session 中学习 Embedding
|
||||
- 对于任何实体，要基于 context 学习到有意义的 Embedding，该实体至少在数据中出现5-10次。
|
||||
- 但平台上大多数 listing_ids 被预定的次数低于5-10次。
|
||||
- 用户连续两次预定的时间间隔可能较长，在此期间用户的行为（如价格敏感点）偏好可能会发生改变（由于职业的变化）。
|
||||
|
||||
为了解决该问题，Airbnb 提出了基于 booking session 来学习用户和房源的 Type Embedding。给定一个 booking sessions 集合 $ \mathcal{S}_{b} $ ，其中包含了 $ M $ 个用户的 booking session：
|
||||
|
||||
- 每个 booking session 表示为： $ s_{b}=\left(l_{b 1}, \ldots, l_{b M}\right) $
|
||||
- 这里 $ l_{b1} $ 表示 listing_id，学习到 Embedding 记作 $ \mathbf{v}_{l_{i d}} $
|
||||
|
||||
**（1）什么是Type Embedding ？**
|
||||
在介绍 Type Embedding 之前，回顾一下 Listing Embedding：
|
||||
|
||||
- 在 Listing Embedding 的学习中，只学习房源的 Embedding 表示，未学习用户的 Embedding。
|
||||
- 对于 Listing Embedding，与相应的 Lisitng ID 是一一对应的， 每个 Listing 它们的 Embedding 表示是唯一的。
|
||||
|
||||
对于 Type Embedding ，有如下的区别：
|
||||
|
||||
- 对于不同的 Listing，它们的 Type Embedding **可能是相同的**（User 同样如此）。
|
||||
- Type Embedding 包含了 User-type Embedding 和 Listing-type Embedding。
|
||||
|
||||
为了更直接快速地了解什么是 Listing-type 和 User-type，举个简单的例子：
|
||||
|
||||
- 小王，是一名西藏人，性别男，今年21岁，就读于中国山东的蓝翔技校的挖掘机专业。
|
||||
- 通常，对于不同的用户（如小王），给定一个 ID 编码，然后学习相应的 User Embedding。
|
||||
- 但前面说了，用户数据过于稀疏，学习到的 User Embedding 特征表达能力不好。
|
||||
- 另一种方式：利用小王身上的用户标签，先组合出他的 User-type，然后学习 Embedding 表示。
|
||||
- 小王的 User-type：西藏人_男_学生_21岁_位置中国山东_南翔技校_挖掘机专业。
|
||||
- 组合得到的 User-type 本质上可视为一个 Category 特征，然后学习其对应的 Embedding 表示。
|
||||
|
||||
下表给出了原文中，Listing-type 和 User-type 包含的属性及属性的值：
|
||||
|
||||
- 所有的属性，都基于一定的规则进行了分桶（buckets）。例如21岁，被分桶到 20-30 岁的区间。
|
||||
- 对于首次预定的用户，他的属性为 buckets 的前5行，因为预定之前没有历史预定相关的信息。
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片1653125260611-7d33731b-9167-4fcc-b83b-0a2407ea89ca.png" alt="img" style="zoom: 67%;" />
|
||||
|
||||
看到过前面那个简单的例子后，现在可以看一个原文的 Listing-type 的例子：
|
||||
|
||||
- 一个来自 US 的 Entire Home listing（lt1），它是一个二人间（c2），1 床（b1），一个卧室（bd2），1 个浴室（bt2），每晚平均价格为 60.8 美元（pn3），每晚每个客人的平均价格为 29.3 美元（pg3），5 个评价（r3），所有均 5 星好评（5s4），100% 的新客接受率（nu3）。
|
||||
- 因此该 listing 根据上表规则可以映射为：Listing-type = US_lt1_pn3_pg3_r3_5s4_c2_b1_bd2_bt2_nu3。
|
||||
|
||||
**（2）Type Embedding 的好处**
|
||||
前面在介绍 Type Embedding 和 Listing Embedding 的区别时，提到过不同 User 或 Listing 他们的 Type 可能相同。
|
||||
|
||||
- 故 User-type 和 Listing-type 在一定程度上可以缓解数据稀疏性的问题。
|
||||
- 对于 user 和 listing 而言，他们的属性可能会随着时间的推移而变化。
|
||||
- 故它们的 Embedding 在时间上也具备了动态变化属性。
|
||||
|
||||
**（3）Type Embedding 的训练过程**
|
||||
Type Embedding 的学习同样是基于 Skip-Gram 模型，但是有两点需要注意：
|
||||
|
||||
- 联合训练 User-type Embedding 和 Listing-type Embedding
|
||||
- 如下图（a），在 booking session 中，每个元素代表的是 （User-type, Listing-type）组合。
|
||||
- 为了学习在相同向量空间中的 User-type 和 Listing-type 的 Embeddings，Airbnb 的做法是将 User-type 插入到 booking sessions 中。
|
||||
- 形成一个（User-type, Listing-type）组成的元组序列，这样就可以让 User-type 和 Listing-type 的在 session 中的相对位置保持一致了。
|
||||
|
||||
- User-type 的目标函数：
|
||||
$$
|
||||
\underset{\theta}{\operatorname{argmax}} \sum_{\left(u_{t}, c\right) \in \mathcal{D}_{b o o k}} \log \frac{1}{1+e^{-\mathbf{v}_{c}^{\prime} \mathbf{v}_{u_{t}}}}+\sum_{\left(u_{t}, c\right) \in \mathcal{D}_{n e g}} \log \frac{1}{1+e^{\mathbf{v}_{c}^{\prime} \mathbf{v}_{u_{t}}}}
|
||||
$$
|
||||
|
||||
+ $ \mathcal{D}_{\text {book }} $ 中的 $ u_t $ （中心词）表示 User-type， $ c $ （上下文）表示用户最近的预定过的 Listing-type。 $ \mathcal{D}_{\text {neg}} $ 中的 $ c $ 表示 negative Listing-type。
|
||||
+ $ u_t $ 表示 User-type 的 Embedding， $ \mathbf{v}_{c}^{\prime} $ 表示 Listing-type 的Embedding。
|
||||
|
||||
- Listing-type 的目标函数：
|
||||
$$
|
||||
\begin{aligned}
|
||||
\underset{\theta}{\operatorname{argmax}} & \sum_{\left(l_{t}, c\right) \in \mathcal{D}_{b o o k}} \log \frac{1}{1+\exp ^{-\mathrm{v}_{c}^{\prime} \mathbf{v}_{l_{t}}}}+\sum_{\left(l_{t}, c\right) \in \mathcal{D}_{n e g}} \log \frac{1}{1+\exp ^{\mathrm{v}_{c}^{\prime} \mathbf{v}_{l_{t}}}} \\
|
||||
\end{aligned}
|
||||
$$
|
||||
|
||||
+ 同理，不过窗口中的中心词为 Listing-type， 上下文为 User-type。
|
||||
|
||||
- Explicit Negatives for Rejections
|
||||
- 用户预定房源以后，还要等待房源主人的确认，主人可能接受或者拒绝客人的预定。
|
||||
- 拒接的原因可能包括，客人星级评定不佳，资料不完整等。
|
||||
|
||||
- 前面学习到的 User-type Embedding 包含了客人的兴趣偏好，Listing-type Embedding 包含了房源的属性特征。
|
||||
- 但是，用户的 Embedding 未包含更容易被哪类房源主人拒绝的潜语义信息。
|
||||
- 房源的 Embedding 未包含主人对哪类客人的拒绝偏好。
|
||||
|
||||
- 为了提高用户预定房源以后，被主人接受的概率。同时，降低房源主人拒绝客人的概率。Airbnb 在训练 User-type 和 Listing-type 的 Embedding时，将用户预定后却被拒绝的样本加入负样本集中（如下图b）。
|
||||
- 更新后，Listing-type 的目标函数：
|
||||
$$
|
||||
\begin{aligned}
|
||||
\underset{\theta}{\operatorname{argmax}} & \sum_{\left(u_{t}, c\right) \in \mathcal{D}_{b o o k}} \log \frac{1}{1+\exp ^{-\mathbf{v}_{c}^{\prime} \mathbf{v}_{u_{t}}}}+\sum_{\left(u_{t}, c\right) \in \mathcal{D}_{n e g}} \log \frac{1}{1+\exp ^{\mathbf{v}_{c}^{\prime} \mathbf{v}_{u_{t}}}} \\
|
||||
&+\sum_{\left(u_{t}, l_{t}\right) \in \mathcal{D}_{\text {reject }}} \log \frac{1}{1+\exp ^{\mathrm{v}_{{l_{t}}}^{\prime} \mathrm{v}_{u_{t}}}}
|
||||
\end{aligned}
|
||||
$$
|
||||
|
||||
- 更新后，User-type 的目标函数：
|
||||
$$
|
||||
\begin{aligned}
|
||||
\underset{\theta}{\operatorname{argmax}} & \sum_{\left(l_{t}, c\right) \in \mathcal{D}_{b o o k}} \log \frac{1}{1+\exp ^{-\mathrm{v}_{c}^{\prime} \mathbf{v}_{l_{t}}}}+\sum_{\left(l_{t}, c\right) \in \mathcal{D}_{n e g}} \log \frac{1}{1+\exp ^{\mathrm{v}_{c}^{\prime} \mathbf{v}_{l_{t}}}} \\
|
||||
&+\sum_{\left(l_{t}, u_{t}\right) \in \mathcal{D}_{\text {reject }}} \log \frac{1}{1+\exp ^{\mathrm{v}^{\prime}_{u_{t}} \mathrm{v}_{l_{t}}}}
|
||||
\end{aligned}
|
||||
$$
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片1653131985447-e033cb39-235b-4f46-9634-3b7faec284be.png" alt="img" style="zoom:50%;" />
|
||||
|
||||
# 实验部分
|
||||
|
||||
前面介绍了两种 Embedding 的生成方法，分别为 Listing Embedding 和 User-type & Listing-type Embedding。本节的实验部分，将会介绍它们是如何被使用的。回顾 Airbnb 的业务背景，当用户查看一个房源时，他们有两种方式继续搜索：返回搜索结果页，或者查看房源详情页的「相似房源」。
|
||||
## 相似房源检索
|
||||
在给定学习到的 Listing Embedding，通过计算其向量 $ v_l $ 和来自同一区域的所有 Listing 的向量 $ v_j $ 之间的余弦相似度，可以找到给定房源 $ l $ 的相似房源。
|
||||
|
||||
- 这些相似房源可在同一日期被预定（如果入住-离开时间已确定）。
|
||||
- 相似度最高的 $ K $ 个房源被检索为相似房源。
|
||||
- 计算是在线执行的，并使用我们的分片架构并行进行，其中部分 Embedding 存储在每个搜索机器上。
|
||||
|
||||
A/B 测试显示，基于 Embedding 的解决方案使「相似房源」点击率增加了21％，最终通过「相似房源」产生的预订增加了 4.9％。
|
||||
|
||||
## 实时个性化搜索排名
|
||||
Airbnb 的搜索排名的大致流程为：
|
||||
|
||||
- 给定查询 $ q $ ，返回 $ K $ 条搜索结果。
|
||||
- 基于排序模型 GBDT，对预测结果进行排序。
|
||||
- 将排序后的结果展示给用户。
|
||||
|
||||
**（1）Query Embedding**
|
||||
原文中似乎并没有详细介绍 Airbnb 的搜索技术，在参考的博客中对他们的 Query Embedding 技术进行了描述。如下：
|
||||
|
||||
> Airbnb 对搜索的 Query 也进行了 Embedding，和普通搜索引擎的 Embedding 不太相同的是，这里的 Embedding 不是用自然语言中的语料库去训练的，而是用 Search Session 作为关系训练数据，训练方式更类似于 Item2Vec，Airbnb 中 Queue Embedding 的一个很重要的作用是捕获用户模糊查询与相关目的地的关联，这样做的好处是可以使搜索结果不再仅仅是简单地进行关键字匹配，而是通过更深层次的语义和关系来找到关联信息。比如下图所示的使用 Query Embedding 之前和之后的两个示例（Airbnb 非常人性化地在搜索栏的添加了自动补全，通过算法去 “猜想” 用户的真实目的，大大提高了用户的检索体验）
|
||||
|
||||
**（2）特征构建**
|
||||
对于各查询，给定的训练数据形式为： $ D_s = \left(\mathbf{x}_{i}, y_{i}\right), i=1 \ldots K $ ，其中 $ K $ 表示查询返回的房源数量。
|
||||
|
||||
- $ \mathbf{x}_{i} $ 表示第 $ i $ 个房源结果的 vector containing features：
|
||||
- 由 listing features，user features，query features 以及 cross-features 组成。
|
||||
- $ y_{i} \in\{0,0.01,0.25,1,-0.4\} $ 表示第 $ i $ 个结果的标签。
|
||||
- $ y_i=1 $ 表示用户预定了房源，...， $ y_i=-0.4 $ 表示房主拒绝了用户。
|
||||
|
||||
下面，介绍 Airbnb 是如何利用前面的两种种 Embedding 进行特征构建的。
|
||||
|
||||
- 如果用一句话来概括，这些基于 Embedding 的构建特征均为余弦相似度。
|
||||
- 新构建的特征均为样本 $ \mathbf{x}_{i} $ 特征的一部分。
|
||||
|
||||
构建的特征如下表所示：
|
||||
|
||||
- 表中的 Embedding Features 包含了8种类型，前6种类型的特征计算方式相同。
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片1653139981920-a100085b-007b-4a9c-9edf-74297e9115ae.png" alt="img" style="zoom:50%;" />
|
||||
|
||||
**① 基于 Listing Embedding Features 的特征构建**
|
||||
|
||||
- Airbnb 保留了用户过去两周6种不同类型的历史行为，如下图：
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片1653140202230-1f49e1dd-5c8c-4445-bd0b-9a17788a7b3f.png" alt="img" style="zoom:50%;" />
|
||||
|
||||
- 对于每个行为，还要将其按照 market （地域）进行划分。以 $ H_c $ 为例：
|
||||
|
||||
- 假如 $ H_c $ 包含了 New YorK 和 Los Angeles 两个 market 的点击记录，则划分为 $ H_c(NY) $ 和 $ H_c(LA) $ 。
|
||||
|
||||
- 计算候选房源和不同行为之间的相似度。
|
||||
- 上述6种行为对应的相似度特征计算方式是相同的，以 $ H_c $ 为例：
|
||||
$$
|
||||
\operatorname{EmbClickSim}\left(l_{i}, H_{c}\right)=\max _{m \in M} \cos \left(\mathbf{v}_{l_{i}}, \sum_{l_{h} \in m, l_{h} \in H_{c}} \mathbf{v}_{l_{h}}\right)
|
||||
$$
|
||||
|
||||
- 其中， $ M $ 表示 market 的集合。第二项实际上为 Centroid Embedding（Embedding 的均值）。
|
||||
|
||||
- 除此之外，Airbnb 还计算了候选房源的 Embedding 与 latest long click 的 Embedding 之间的余弦相似度。
|
||||
$$
|
||||
\operatorname{EmbLastLongClickSim }\left(l_{i}, H_{l c}\right)=\cos \left(\mathbf{v}_{l_{i}}, \mathbf{v}_{l_{\text {last }}}\right)
|
||||
$$
|
||||
|
||||
**② 基于 User-type & Listing-type Embedding Features 的特征构建**
|
||||
|
||||
- 对于候选房源 $ l_i $ ，先查到其对应的 Listing-type $ l_t $ ，再找到用户的 User-type $ u_t $ 。
|
||||
|
||||
- 最后，计算 $ u_t $ 与 $ l_t $ 对应的 Embedding 之间的余弦相似度：
|
||||
$$
|
||||
\text { UserTypeListingTypeSim }\left(u_{t}, l_{t}\right)=\cos \left(\mathbf{v}_{u_{t}}, \mathbf{v}_{l_{t}}\right)
|
||||
$$
|
||||
|
||||
为了验证上述特征的构建是否有效，Airbnb 还做了特征重要性排序，如下表：
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片1653142188111-1975bcc4-22a2-45cf-bff0-2783ecb00a0c.png" alt="img" style="zoom:50%;" />
|
||||
|
||||
**（3)模型**
|
||||
特征构建完成后，开始对模型进行训练。
|
||||
|
||||
- Airbnb 在搜索排名中使用的是 GBDT 模型，该模型是一个回归模型。
|
||||
- 模型的训练数据包括数据集 $ \mathcal{D} $ 和 search labels 。
|
||||
|
||||
最后，利用 GBDT 模型来预测线上各搜索房源的在线分数。得到预测分数后，将按照降序的方式展现给用户。
|
||||
# 参考链接
|
||||
|
||||
+ [Embedding 在大厂推荐场景中的工程化实践 - 卢明冬的博客 (lumingdong.cn)](https://lumingdong.cn/engineering-practice-of-embedding-in-recommendation-scenario.html#Airbnb)
|
||||
|
||||
+ [KDD'2018 Best Paper-Embedding技术在Airbnb实时搜索排序中的应用 (qq.com)](https://mp.weixin.qq.com/s/f9IshxX29sWg9NhSa7CaNg)
|
||||
|
||||
+ [再评Airbnb的经典Embedding论文 - 知乎 (zhihu.com)](https://zhuanlan.zhihu.com/p/162163054)
|
||||
|
||||
+ [Airbnb爱彼迎房源排序中的嵌入(Embedding)技术 - 知乎 (zhihu.com)](https://zhuanlan.zhihu.com/p/43295545)
|
||||
629
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.2/DSSM.md
Normal file
629
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.2/DSSM.md
Normal file
@@ -0,0 +1,629 @@
|
||||
# 双塔召回模型
|
||||
|
||||
---
|
||||
|
||||
双塔模型在推荐领域中是一个十分经典的模型，无论是在召回还是粗排阶段，都会是首选。这主要是得益于双塔模型结构，使得能够在线预估时满足低延时的要求。但也是因为其模型结构的问题，使得无法考虑到user和item特之间的特征交叉，使得影响模型最终效果，因此很多工作尝试调整经典双塔模型结构，在保持在线预估低延时的同时，保证双塔两侧之间有效的信息交叉。下面针对于经典双塔模型以及一些改进版本进行介绍。
|
||||
|
||||
|
||||
|
||||
## 经典双塔模型
|
||||
|
||||
DSSM(Deep Structured Semantic Model)是由微软研究院于CIKM在2013年提出的一篇工作，该模型主要用来解决NLP领域语义相似度任务 ，利用深度神经网络将文本表示为低维度的向量，用来提升搜索场景下文档和query匹配的问题。DSSM 模型的原理主要是：通过用户搜索行为中query 和 doc 的日志数据，通过深度学习网络将query和doc映射到到共同维度的语义空间中，通过最大化query和doc语义向量之 间的余弦相似度，从而训练得到隐含语义模型，即 query 侧特征的 embedding 和 doc 侧特征的 embedding，进而可以获取语句的低维 语义向量表达 sentence embedding，可以预测两句话的语义相似度。模型结构如下所示：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://pic4.zhimg.com/v2-7f75cc71f5e959d6efa95289d2f5ac13_r.jpg" style="zoom:45%;"/>
|
||||
</div>
|
||||
|
||||
|
||||
从上图可以看出，该网络结构比较简单，是一个由几层DNN组成网络，我们将要搜索文本(Query)和要匹配的文本(Document)的 embedding 输入到网络，网络输出为 128 维的向量，然后通过向量之间计算余弦相似度来计算向量之间距离，可以看作每一个 query 和 document 之间相似分数，然后在做 softmax。
|
||||
|
||||
|
||||
|
||||
而在推荐系统中，最为关键的问题是如何做好用户与item的匹配问题，因此对于推荐系统中DSSM模型的则是为 user 和 item 分别构建独立的子网络塔式结构，利用user和item的曝光或点击日期进行训练，最终得到user侧的embedding和item侧的embedding。因此在推荐系统中，常见的模型结构如下所示：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://cdn.jsdelivr.net/gh/swallown1/blogimages@main/images/image-20220522103456450.png" style="zoom:60%;"/>
|
||||
</div>
|
||||
|
||||
从模型结构上来看，主要包括两个部分：user侧塔和item侧塔，对于每个塔分别是一个DNN结构。通过两侧的特征输入，通过DNN模块到user和item的embedding，然后计算两者之间的相似度(常用內积或者余弦值，下面会说这两种方式的联系和区别)，因此对于user和item两侧最终得到的embedding维度需要保持一致，即最后一层全连接层隐藏单元个数相同。
|
||||
|
||||
|
||||
|
||||
在召回模型中，将这种检索行为视为多类分类问题，类似于YouTubeDNN模型。将物料库中所有的item视为一个类别，因此损失函数需要计算每个类的概率值：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://cdn.jsdelivr.net/gh/swallown1/blogimages@main/images/image-20220522110742879.png" style="zoom:60%;"/>
|
||||
</div>
|
||||
|
||||
其中$s(x,y)$表示两个向量的相似度，$P(y|x;\theta)$表示预测类别的概率，$M$表示物料库所有的item。但是在实际场景中，由于物料库中的item数量巨大，在计算上式时会十分的耗时，因此会采样一定的数量的负样本来近似计算，后面针对负样本的采样做一些简单介绍。
|
||||
|
||||
|
||||
|
||||
以上就是推荐系统中经典的双塔模型，之所以在实际应用中非常常见，是因为**在海量的候选数据进行召回的场景下，速度很快，效果说不上极端好，但一般而言效果也够用了**。之所以双塔模型在服务时速度很快，是因为模型结构简单(两侧没有特征交叉)，但这也带来了问题，双塔的结构无法考虑两侧特征之间的交互信息，**在一定程度上牺牲掉模型的部分精准性**。例如在精排模型中，来自user侧和item侧的特征会在第一层NLP层就可以做细粒度的特征交互，而对于双塔模型，user侧和item侧的特征只会在最后的內积计算时发生，这就导致很多有用的信息在经过DNN结构时就已经被其他特征所模糊了，因此双塔结构由于其结构问题先天就会存在这样的问题。下面针对这个问题来看看一下现有模型的解决思路。
|
||||
|
||||
|
||||
|
||||
## SENet双塔模型
|
||||
|
||||
SENet由Momenta在2017年提出，当时是一种应用于图像处理的新型网络结构。后来张俊林大佬将SENet引入了精排模型[FiBiNET](https://arxiv.org/abs/1905.09433)中，其作用是为了将大量长尾的低频特征抛弃，弱化不靠谱低频特征embedding的负面影响，强化高频特征的重要作用。那SENet结构到底是怎么样的呢，为什么可以起到特征筛选的作用？
|
||||
|
||||
<div align=center>
|
||||
<img src="https://camo.githubusercontent.com/ccf54fc4fcac46667d451f22368e31cf86855bc8bfbff40b7675d524bc899ecf/68747470733a2f2f696d672d626c6f672e6373646e696d672e636e2f32303231303730333136313830373133392e706e673f782d6f73732d70726f636573733d696d6167652f77617465726d61726b2c747970655f5a6d46755a33706f5a57356e6147567064476b2c736861646f775f31302c746578745f6148523063484d364c7939696247396e4c6d4e7a5a473475626d56304c336431656d6876626d6478615746755a773d3d2c73697a655f312c636f6c6f725f4646464646462c745f3730237069635f63656e746572" style="zoom:80%;"/>
|
||||
</div>
|
||||
|
||||
从上图可以看出SENET主要分为三个步骤Squeeze, Excitation, Re-weight：
|
||||
|
||||
- Squeeze阶段：我们对每个特征的Embedding向量进行数据压缩与信息汇总，即在Embedding维度计算均值：
|
||||
|
||||
$$z_i = F_{sq}(e_i) = \frac{1}{k} \sum_{t=1}^k e_i^{(t)}$$
|
||||
|
||||
其中k表示Embedding的维度，Squeeze阶段是将每个特征的Squeeze转换成单一的数值。
|
||||
|
||||
- Excitation阶段：这阶段是根据上一阶段得到的向量进行缩放，即将上阶段的得到的 $1 \times f$ 的向量$Z$先压缩成 $1 \times \frac{f}{r}$ 长度，然后在放回到 $1 \times f$ 的维度，其中$r$表示压缩的程度。这个过程的具体操作就是经过两层DNN。
|
||||
|
||||
$$A = F_{ex}(Z) = \sigma_2(W_2\sigma_1(W_1Z)) $$
|
||||
|
||||
该过程可以理解为：对于当前所有输入的特征，通过相互发生关联，来动态地判断哪些特征重要，哪些特征不重要，而这体现在Excitation阶段的输出结果 $A$，其反应每个特征对应的重要性权重。
|
||||
|
||||
- Re-weight阶段：是将Excitation阶段得到的每个特征对应的权重 $A$ 再乘回到特征对应的Embedding里，就完成了对特征重要性的加权操作。
|
||||
|
||||
$$V=F_{ReWeight }(A,E)=[a_1 \cdot e_1,⋯,a_f \cdot e_f]=[v_1,⋯,v_f]$$
|
||||
|
||||
以上简单的介绍了一下SENet结构，可以发现这种结构可以通过对特征embedding先压缩，再交互，再选择，进而实现特征选择的效果。
|
||||
|
||||
|
||||
|
||||
此外张俊林大佬还将SENet应用于双塔模型中[(SENet双塔模型：在推荐领域召回粗排的应用及其它)](https://zhuanlan.zhihu.com/p/358779957)，模型结构如下所示：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://cdn.jsdelivr.net/gh/swallown1/blogimages@main/images/image-20220522152508824.png" style="zoom:70%;"/>
|
||||
</div>
|
||||
|
||||
从上图可以发现，具体地是将双塔中的user塔和Item侧塔的特征输入部分加上一个SENet模块，通过SENet网络，动态地学习这些特征的重要性，通过小权重抑制噪音或者无效低频特征，通过大权重放大重要特征影响的目的。
|
||||
|
||||
|
||||
|
||||
之所以SENet双塔模型是有效的呢？张俊林老师的解释是：双塔模型的问题在于User侧特征和Item侧特征交互太晚，在高层交互，会造成细节信息，也就是具体特征信息的损失，影响两侧特征交叉的效果。而SENet模块在最底层就进行了特征的过滤，使得很多无效低频特征即使被过滤掉，这样更多有用的信息被保留到了双塔的最高层，使得两侧的交叉效果很好；同时由于SENet模块选择出更加重要的信息，使得User侧和Item侧特征之间的交互表达方面增强了DNN双塔的能力。
|
||||
|
||||
|
||||
|
||||
因此SENet双塔模型主要是从特征选择的角度，提高了两侧特征交叉的有效性，减少了噪音对有效信息的干扰，进而提高了双塔模型的效果。此外，除了这样的方式，还可以通过增加通道的方式来增强两侧的信息交互。即对于user和item两侧不仅仅使用一个DNN结构，而是可以通过不同结构(如FM，DCN等)来建模user和item的自身特征交叉，例如下图所示：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://cdn.jsdelivr.net/gh/swallown1/blogimages@main/images/v2-9c2f7a30c6cadc47be23d6797f095b61_b.jpg" style="zoom:80%;"/>
|
||||
</div>
|
||||
|
||||
|
||||
这样对于user和item侧会得到多个embedding，类似于多兴趣的概念。通过得到的多个user和item的embedding，然后分别计算余弦值再相加(两侧的Embedding维度需要对齐)，进而增加了双塔两侧的信息交互。而这种方法在腾讯进行过尝试，他们提出的“并联”双塔就是按照这样的思路，感兴趣的可以了解一下。
|
||||
|
||||
|
||||
|
||||
## 多目标的双塔模型
|
||||
|
||||
现如今多任务学习在实际的应用场景也十分的常见，主要是因为实际场景中业务复杂，往往有很多的衡量指标，例如点击，评论，收藏，关注，转发等。在多任务学习中，往往会针对不同的任务使用一个独有的tower，然后优化不同任务损失。那么针对双塔模型应该如何构建多任务学习框架呢？
|
||||
|
||||
<div align=center>
|
||||
<img src="https://cdn.jsdelivr.net/gh/swallown1/blogimages@main/images/image-20220523113206177.png" style="zoom:60%;"/>
|
||||
</div>
|
||||
如上图所示，在user侧和item侧分别通过多个通道(DNN结构)为每个任务得到一个user embedding和item embedding，然后针对不同的目标分别计算user 和 item 的相似度，并计算各个目标的损失，最后的优化目标可以是多个任务损失之和，或者使用多任务学习中的动态损失权重。
|
||||
|
||||
|
||||
|
||||
这种模型结构，可以针对多目标进行联合建模，通过多任务学习的结构，一方面可以利用不同任务之间的信息共享，为一些稀疏特征提供其他任务中的迁移信息，另一方面可以在召回时，直接使用一个模型得到多个目标预测，解决了多个模型维护困难的问题。也就是说，在线上通过这一个模型就可以同时得到多个指标，例如视频场景，一个模型就可以直接得到点赞，品论，转发等目标的预测值，进而通过这些值计算分数获得最终的Top-K召回结果。
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
## 双塔模型的细节
|
||||
|
||||
关于双塔模型，其模型结构相比排序模型来说很简单，没有过于复杂的结构。但除了结构，有一些细节部分容易被忽视，而这些细节部分往往比模型结构更加重要，因此下面主要介绍一下双塔模型中需要主要的一些细节问题。
|
||||
|
||||
|
||||
|
||||
### 归一化与温度系数
|
||||
|
||||
在[Google的双塔召回模型](https://dl.acm.org/doi/pdf/10.1145/3298689.3346996)中，重点介绍了两个trick，将user和item侧输出的embedding进行归一化以及对于內积值除以温度系数，实验证明这两种方式可以取得十分好的效果。那为什么这两种方法会使得模型的效果更好呢？
|
||||
|
||||
- 归一化：对user侧和item侧的输入embedding，进行L2归一化
|
||||
|
||||
$$u(x,\theta) \leftarrow = \frac{u(x,\theta)}{||u(x,\theta)||_2}$$
|
||||
|
||||
$$v(x,\theta) \leftarrow = \frac{v(x,\theta)}{||v(x,\theta)||_2}$$
|
||||
|
||||
- 温度系数：在归一化之后的向量计算內积之后，除以一个固定的超参 $r$ ，论文中命名为温度系数。
|
||||
|
||||
$$s(u,v) = \frac{<u(x,\theta), v(x,\theta)>}{r}$$
|
||||
|
||||
那为什么需要进行上述的两个操作呢？
|
||||
|
||||
- 归一化的操作主要原因是因为向量点积距离是非度量空间，不满足三角不等式，而归一化的操作使得点击行为转化成了欧式距离。
|
||||
|
||||
首先向量点积是向量对应位相乘并求和，即向量內积。而向量內积**不保序**，例如空间上三个点(A=(10,0),B=(0,10),C=(11,0))，利用向量点积计算的距离 dis(A,B) < dis(A,C)，但是在欧式距离下这是错误的。而归一化的操作则会让向量点积转化为欧式距离，例如 $user_{emb}$ 表示归一化user的embedding， $item_{emb}$ 表示归一化 item 的embedding，那么两者之间的欧式距离 $||user_{emb} - item_{emb}||$ 如下， 可以看出归一化的向量点积已转化成了欧式距离。
|
||||
|
||||
$$||user_{emb} - item_{emb}||=\sqrt{||user_{emb}||^2+||item_{emb}||^2-2<user_{emb},item_{emb}>} = \sqrt{2-2<user_{emb},item_{emb}>}$$
|
||||
|
||||
|
||||
|
||||
那没啥非要转为欧式距离呢？这是因为ANN一般是通过计算欧式距离进行检索，这样转化成欧式空间，保证训练和检索一致。
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
### 模型的应用
|
||||
|
||||
在实际的工业应用场景中，分为离线训练和在线服务两个环节。
|
||||
|
||||
- 在离线训练阶段，同过训练数据，训练好模型参数。然后将候选库中所有的item集合离线计算得到对应的embedding，并存储进ANN检索系统，比如faiss。为什么将离线计算item集合，主要是因为item的会相对稳定，不会频繁的变动，而对于用户而言，如果将用户行为作为user侧的输入，那么user的embedding会随着用户行为的发生而不断变化，因此对于user侧的embedding需要实时的计算。
|
||||
- 在线服务阶段，正是因为用户的行为变化需要被即使的反应在用户的embedding中，以更快的反应用户当前的兴趣，即可以实时地体现用户即时兴趣的变化。因此在线服务阶段需要实时的通过拼接用户特征，输入到user侧的DNN当中，进而得到user embedding，在通过user embedding去 faiss中进行ANN检索，召回最相似的K个item embedding。
|
||||
|
||||
可以看到双塔模型结构十分的适合实际的应用场景，在快速服务的同时，还可以更快的反应用户即时兴趣的变化。
|
||||
|
||||
|
||||
|
||||
### 负样本采样
|
||||
|
||||
相比于排序模型而言，召回阶段的模型除了在结构上的不同，在样本选择方面也存在着很大的差异，可以说样本的选择很大程度上会影响召回模型的效果。对于召回模型而言，其负样本并不能和排序模型一样只使用展现未点击样本，因为召回模型在线上面临的数据分布是全部的item，而不仅仅是展现未点击样本。因此在离线训练时，需要让其保证和线上分布尽可能一致，所以在负样本的选择样要尽可能的增加很多未被曝光的item。下面简单的介绍一些常见的采样方法：
|
||||
|
||||
#### 全局随机采样
|
||||
|
||||
全局随机采样指：从全局候选item里面随机抽取一定数量item做为召回模型的负样本。这样的方式实现简单，也可以让模型尽可能的和线上保持一致的分布，尽可能的多的让模型对于全局item有区分的能力。例如YoutubeDNN算法。
|
||||
|
||||
但这样的方式也会存在一定的问题，由于候选的item属于长尾数据，即“八二定律”，也就是说少数热门物料占据了绝大多数的曝光与点击。因此存随机的方式只能让模型在学到粗粒度上差异，对一些尾部item并不友好。
|
||||
|
||||
|
||||
|
||||
#### 全局随机采样 + 热门打压
|
||||
|
||||
针对于全局随机采样的不足，一个直观的方法是针对于item的热度item进行打压，即对于热门的item很多用户可能会点击，需要进行一定程度的欠采样，使得模型更加关注一些非热门的item。 此外在进行负样本采样时，应该对一些热门item进行适当的过采样，这可以尽可能的让模型对于负样本有更加细粒度的区分。例如在word2vec中，负采样方法是根据word的频率，对 negative words进行随机抽样，降 低 negative words 量级。
|
||||
|
||||
之所以热门item做负样本时，要适当过采样，增加负样本难度。因为对于全量的item，模型可以轻易的区分一些和用户兴趣差异性很大的item，难点在于很难区分一些和用户兴趣相似的item。因此在训练模型时，需要适当的增加一些难以区分的负样本来提升模型面对相似item的分区能力。
|
||||
|
||||
|
||||
|
||||
|
||||
#### Hard Negative增强样本
|
||||
|
||||
Hard Negative指的是选取一部分匹配度适中的item，能够增加模型在训练时的难度，提升模型能学习到item之间细粒度上的差异。至于 如何选取在工业界也有很多的解决方案。
|
||||
|
||||
例如Airbnb根据业务逻辑来采样一些hard negative （增加与正样本同城的房间作为负样本，增强了正负样本在地域上的相似性；增加与正样本同城的房间作为负样本，增强了正负样本在地域上的相似性，），详细内容可以查看[原文](https://www.kdd.org/kdd2018/accepted-papers/view/real-time-personalization-using-embeddings-for-search-ranking-at-airbnb)
|
||||
|
||||
例如百度和facebook依靠模型自己来挖掘Hard Negative，都是用上一版本的召回模型筛选出"没那么相似"的<user,item>对，作为额外负样本，用于训练下一版本召回模型。 详细可以查看[Mobius](http://research.baidu.com/Public/uploads/5d12eca098d40.pdf) 和 [EBR](https://arxiv.org/pdf/2006.11632.pdf)
|
||||
|
||||
|
||||
|
||||
#### Batch内随机选择负采样
|
||||
|
||||
基于batch的负采样方法是将batch内选择除了正样本之外的其它Item，做为负样本，其本质就是利用其他样本的正样本随机采样作为自己的负样本。这样的方法可以作为负样本的选择方式，特别是在如今分布式训练以及增量训练的场景中是一个非常值得一试的方法。但这种方法也存在他的问题，基于batch的负采样方法受batch的影响很大，当batch的分布与整体的分布差异很大时就会出现问题，同时batch内负采样也会受到热门item的影响，需要考虑打压热门item的问题。至于解决的办法，Google的双塔召回模型中给出了答案，想了解的同学可以去学习一下。
|
||||
|
||||
|
||||
|
||||
总的来说负样本的采样方法，不光是双塔模型应该重视的工作，而是所有召回模型都应该仔细考虑的方法。
|
||||
|
||||
|
||||
|
||||
## 代码实现
|
||||
|
||||
下面使用一点资讯提供的数据，实践一下DSSM召回模型。该模型的实现主要参考：DeepCtr和DeepMatch模块。
|
||||
|
||||
### 模型训练数据
|
||||
|
||||
1、数据预处理
|
||||
用户侧主要包含一些用户画像属性（用户性别，年龄，所在省市，使用设备及系统）；新闻侧主要包括新闻的创建时间，题目，所属 一级、二级类别，题片个数以及关键词。下面主要是对着两部分数据的简单处理：
|
||||
|
||||
```python
|
||||
def proccess(file):
|
||||
if file=="user_info_data_5w.csv":
|
||||
data = pd.read_csv(file_path + file, sep="\t",index_col=0)
|
||||
data["age"] = data["age"].map(lambda x: get_pro_age(x))
|
||||
data["gender"] = data["gender"].map(lambda x: get_pro_age(x))
|
||||
|
||||
data["province"]=data["province"].fillna(method='ffill')
|
||||
data["city"]=data["city"].fillna(method='ffill')
|
||||
|
||||
data["device"] = data["device"].fillna(method='ffill')
|
||||
data["os"] = data["os"].fillna(method='ffill')
|
||||
return data
|
||||
|
||||
elif file=="doc_info.txt":
|
||||
data = pd.read_csv(file_path + file, sep="\t")
|
||||
data.columns = ["article_id", "title", "ctime", "img_num","cate","sub_cate", "key_words"]
|
||||
select_column = ["article_id", "title_len", "ctime", "img_num","cate","sub_cate", "key_words"]
|
||||
|
||||
# 去除时间为nan的新闻以及除脏数据
|
||||
data= data[(data["ctime"].notna()) & (data["ctime"] != 'Android')]
|
||||
data['ctime'] = data['ctime'].astype('str')
|
||||
data['ctime'] = data['ctime'].apply(lambda x: int(x[:10]))
|
||||
data['ctime'] = pd.to_datetime(data['ctime'], unit='s', errors='coerce')
|
||||
|
||||
|
||||
# 这里存在nan字符串和异常数据
|
||||
data["sub_cate"] = data["sub_cate"].astype(str)
|
||||
data["sub_cate"] = data["sub_cate"].apply(lambda x: pro_sub_cate(x))
|
||||
data["img_num"] = data["img_num"].astype(str)
|
||||
data["img_num"] = data["img_num"].apply(photoNums)
|
||||
data["title_len"] = data["title"].apply(lambda x: len(x) if isinstance(x, str) else 0)
|
||||
data["cate"] = data["cate"].fillna('其他')
|
||||
|
||||
return data[select_column]
|
||||
```
|
||||
|
||||
2、构造训练样本
|
||||
该部分主要是根据用户的交互日志中前6天的数据作为训练集，第7天的数据作为测试集，来构造模型的训练测试样本。
|
||||
|
||||
```python
|
||||
def dealsample(file, doc_data, user_data, s_data_str = "2021-06-24 00:00:00", e_data_str="2021-06-30 23:59:59", neg_num=5):
|
||||
# 先处理时间问题
|
||||
data = pd.read_csv(file_path + file, sep="\t",index_col=0)
|
||||
data['expo_time'] = data['expo_time'].astype('str')
|
||||
data['expo_time'] = data['expo_time'].apply(lambda x: int(x[:10]))
|
||||
data['expo_time'] = pd.to_datetime(data['expo_time'], unit='s', errors='coerce')
|
||||
|
||||
s_date = datetime.datetime.strptime(s_data_str,"%Y-%m-%d %H:%M:%S")
|
||||
e_date = datetime.datetime.strptime(e_data_str,"%Y-%m-%d %H:%M:%S") + datetime.timedelta(days=-1)
|
||||
t_date = datetime.datetime.strptime(e_data_str,"%Y-%m-%d %H:%M:%S")
|
||||
|
||||
# 选取训练和测试所需的数据
|
||||
all_data_tmp = data[(data["expo_time"]>=s_date) & (data["expo_time"]<=t_date)]
|
||||
|
||||
# 处理训练数据集 防止穿越样本
|
||||
# 1. merge 新闻信息，得到曝光时间和新闻创建时间； inner join 去除doc_data之外的新闻
|
||||
all_data_tmp = all_data_tmp.join(doc_data.set_index("article_id"),on="article_id",how='inner')
|
||||
|
||||
# 发现还存在 ctime大于expo_time的交互存在 去除这部分错误数据
|
||||
all_data_tmp = all_data_tmp[(all_data_tmp["ctime"]<=all_data_tmp["expo_time"])]
|
||||
|
||||
# 2. 去除与新闻的创建时间在测试数据时间内的交互 ()
|
||||
train_data = all_data_tmp[(all_data_tmp["expo_time"]>=s_date) & (all_data_tmp["expo_time"]<=e_date)]
|
||||
train_data = train_data[(train_data["ctime"]<=e_date)]
|
||||
|
||||
print("有效的样本数：",train_data["expo_time"].count())
|
||||
|
||||
# 负采样
|
||||
if os.path.exists(file_path + "neg_sample.pkl") and os.path.getsize(file_path + "neg_sample.pkl"):
|
||||
neg_samples = pd.read_pickle(file_path + "neg_sample.pkl")
|
||||
# train_neg_samples.insert(loc=2, column="click", value=[0] * train_neg_samples["user_id"].count())
|
||||
else:
|
||||
# 进行负采样的时候对于样本进行限制，只对一定时间范围之内的样本进行负采样
|
||||
doc_data_tmp = doc_data[(doc_data["ctime"]>=datetime.datetime.strptime("2021-06-01 00:00:00","%Y-%m-%d %H:%M:%S"))]
|
||||
neg_samples = negSample_like_word2vec(train_data, doc_data_tmp[["article_id"]].values, user_data[["user_id"]].values, neg_num=neg_num)
|
||||
neg_samples = pd.DataFrame(neg_samples, columns= ["user_id","article_id","click"])
|
||||
neg_samples.to_pickle(file_path + "neg_sample.pkl")
|
||||
|
||||
train_pos_samples = train_data[train_data["click"] == 1][["user_id","article_id", "expo_time", "click"]] # 取正样本
|
||||
|
||||
neg_samples_df = train_data[train_data["click"] == 0][["user_id","article_id", "click"]]
|
||||
train_neg_samples = pd.concat([neg_samples_df.sample(n=train_pos_samples["click"].count()) ,neg_samples],axis=0) # 取负样本
|
||||
|
||||
print("训练集正样本数：",train_pos_samples["click"].count())
|
||||
print("训练集负样本数：",train_neg_samples["click"].count())
|
||||
|
||||
train_data_df = pd.concat([train_neg_samples,train_pos_samples],axis=0)
|
||||
train_data_df = train_data_df.sample(frac=1) # shuffle
|
||||
|
||||
print("训练集总样本数：",train_data_df["click"].count())
|
||||
|
||||
test_data_df = all_data_tmp[(all_data_tmp["expo_time"]>e_date) & (all_data_tmp["expo_time"]<=t_date)][["user_id","article_id", "expo_time", "click"]]
|
||||
|
||||
print("测试集总样本数：",test_data_df["click"].count())
|
||||
print("测试集总样本数：",test_data_df["click"].count())
|
||||
|
||||
all_data_df = pd.concat([train_data_df, test_data_df],axis=0)
|
||||
|
||||
print("总样本数：",all_data_df["click"].count())
|
||||
|
||||
return all_data_df
|
||||
```
|
||||
|
||||
3、负样本采样
|
||||
该部分主要采用基于item的展现次数对全局item进行负采样。
|
||||
|
||||
```python
|
||||
def negSample_like_word2vec(train_data, all_items, all_users, neg_num=10):
|
||||
"""
|
||||
为所有item计算一个采样概率，根据概率为每个用户采样neg_num个负样本，返回所有负样本对
|
||||
1. 统计所有item在交互中的出现频次
|
||||
2. 根据频次进行排序，并计算item采样概率（频次出现越多，采样概率越低，打压热门item）
|
||||
3. 根据采样概率，利用多线程为每个用户采样 neg_num 个负样本
|
||||
"""
|
||||
pos_samples = train_data[train_data["click"] == 1][["user_id","article_id"]]
|
||||
|
||||
pos_samples_dic = {}
|
||||
for idx,u in enumerate(pos_samples["user_id"].unique().tolist()):
|
||||
pos_list = list(pos_samples[pos_samples["user_id"] == u]["article_id"].unique().tolist())
|
||||
if len(pos_list) >= 30: # 30是拍的 需要数据统计的支持确定
|
||||
pos_samples_dic[u] = pos_list[30:]
|
||||
else:
|
||||
pos_samples_dic[u] = pos_list
|
||||
|
||||
# 统计出现频次
|
||||
article_counts = train_data["article_id"].value_counts()
|
||||
df_article_counts = pd.DataFrame(article_counts)
|
||||
dic_article_counts = dict(zip(df_article_counts.index.values.tolist(),df_article_counts.article_id.tolist()))
|
||||
|
||||
for item in all_items:
|
||||
if item[0] not in dic_article_counts.keys():
|
||||
dic_article_counts[item[0]] = 0
|
||||
|
||||
# 根据频次排序, 并计算每个item的采样概率
|
||||
tmp = sorted(list(dic_article_counts.items()), key=lambda x:x[1], reverse=True) # 降序
|
||||
n_articles = len(tmp)
|
||||
article_prob = {}
|
||||
for idx, item in enumerate(tmp):
|
||||
article_prob[item[0]] = cal_pos(idx, n_articles)
|
||||
|
||||
# 为每个用户进行负采样
|
||||
article_id_list = [a[0] for a in article_prob.items()]
|
||||
article_pro_list = [a[1] for a in article_prob.items()]
|
||||
pos_sample_users = list(pos_samples_dic.keys())
|
||||
|
||||
all_users_list = [u[0] for u in all_users]
|
||||
|
||||
print("start negative sampling !!!!!!")
|
||||
pool = multiprocessing.Pool(core_size)
|
||||
res = pool.map(SampleOneProb((pos_sample_users,article_id_list,article_pro_list,pos_samples_dic,neg_num)), tqdm(all_users_list))
|
||||
pool.close()
|
||||
pool.join()
|
||||
|
||||
neg_sample_dic = {}
|
||||
for idx, u in tqdm(enumerate(all_users_list)):
|
||||
neg_sample_dic[u] = res[idx]
|
||||
|
||||
return [[k,i,0] for k,v in neg_sample_dic.items() for i in v]
|
||||
```
|
||||
|
||||
### DSSM 模型
|
||||
|
||||
1、模型构建
|
||||
|
||||
模型构建部分主要是将输入的user 特征以及 item 特征处理完之后分别送入两侧的DNN结构。
|
||||
|
||||
```python
|
||||
def DSSM(user_feature_columns, item_feature_columns, dnn_units=[64, 32],
|
||||
temp=10, task='binary'):
|
||||
# 构建所有特征的Input层和Embedding层
|
||||
feature_encode = FeatureEncoder(user_feature_columns + item_feature_columns)
|
||||
feature_input_layers_list = list(feature_encode.feature_input_layer_dict.values())
|
||||
|
||||
# 特征处理
|
||||
user_dnn_input, item_dnn_input = process_feature(user_feature_columns,\
|
||||
item_feature_columns, feature_encode)
|
||||
|
||||
# 构建模型的核心层
|
||||
if len(user_dnn_input) >= 2:
|
||||
user_dnn_input = Concatenate(axis=1)(user_dnn_input)
|
||||
else:
|
||||
user_dnn_input = user_dnn_input[0]
|
||||
if len(item_dnn_input) >= 2:
|
||||
item_dnn_input = Concatenate(axis=1)(item_dnn_input)
|
||||
else:
|
||||
item_dnn_input = item_dnn_input[0]
|
||||
user_dnn_input = Flatten()(user_dnn_input)
|
||||
item_dnn_input = Flatten()(item_dnn_input)
|
||||
user_dnn_out = DNN(dnn_units)(user_dnn_input)
|
||||
item_dnn_out = DNN(dnn_units)(item_dnn_input)
|
||||
|
||||
|
||||
# 计算相似度
|
||||
scores = CosinSimilarity(temp)([user_dnn_out, item_dnn_out]) # (B,1)
|
||||
# 确定拟合目标
|
||||
output = PredictLayer()(scores)
|
||||
# 根据输入输出构建模型
|
||||
model = Model(feature_input_layers_list, output)
|
||||
return model
|
||||
```
|
||||
|
||||
2、CosinSimilarity相似度计算
|
||||
|
||||
在余弦相似度计算，主要是注意使用归一化以及温度系数的技巧。
|
||||
|
||||
```python
|
||||
def call(self, inputs, **kwargs):
|
||||
"""inputs 是一个列表"""
|
||||
query, candidate = inputs
|
||||
# 计算两个向量的二范数
|
||||
query_norm = tf.norm(query, axis=self.axis) # (B, 1)
|
||||
candidate_norm = tf.norm(candidate, axis=self.axis)
|
||||
# 计算向量点击，即內积操作
|
||||
scores = tf.reduce_sum(tf.multiply(query, candidate), axis=-1)#(B,1)
|
||||
# 相似度除以二范数, 防止除零
|
||||
scores = tf.divide(scores, query_norm * candidate_norm + 1e-8)
|
||||
# 对score的范围限制到(-1, 1)之间
|
||||
scores = tf.clip_by_value(scores, -1, 1)
|
||||
# 乘以温度系数
|
||||
score = scores * self.temperature
|
||||
return score
|
||||
```
|
||||
|
||||
|
||||
|
||||
### 模型训练
|
||||
|
||||
1、稀疏特征编码
|
||||
该部分主要是针对于用户侧和新闻侧的稀疏特征进行编码，并将训练样本join上两侧的特征。
|
||||
|
||||
```python
|
||||
# 数据和测试数据
|
||||
data, user_data, doc_data = get_all_data()
|
||||
|
||||
# 1.Label Encoding for sparse features,and process sequence features with `gen_date_set` and `gen_model_input`
|
||||
feature_max_idx = {}
|
||||
feature_encoder = {}
|
||||
|
||||
user_sparse_features = ["user_id", "device", "os", "province", "city", "age", "gender"]
|
||||
for feature in user_sparse_features:
|
||||
lbe = LabelEncoder()
|
||||
user_data[feature] = lbe.fit_transform(user_data[feature]) + 1
|
||||
feature_max_idx[feature] = user_data[feature].max() + 1
|
||||
feature_encoder[feature] = lbe
|
||||
|
||||
|
||||
doc_sparse_features = ["article_id", "cate", "sub_cate"]
|
||||
doc_dense_features = ["title_len", "img_num"]
|
||||
|
||||
for feature in doc_sparse_features:
|
||||
lbe = LabelEncoder()
|
||||
if feature in ["cate","sub_cate"]:
|
||||
# 这里面会出现一些float的数据，导致无法编码
|
||||
doc_data[feature] = lbe.fit_transform(doc_data[feature].astype(str)) + 1
|
||||
else:
|
||||
doc_data[feature] = lbe.fit_transform(doc_data[feature]) + 1
|
||||
feature_max_idx[feature] = doc_data[feature].max() + 1
|
||||
feature_encoder[feature] = lbe
|
||||
|
||||
data["article_id"] = feature_encoder["article_id"].transform(data["article_id"].tolist())
|
||||
data["user_id"] = feature_encoder["user_id"].transform(data["user_id"].tolist())
|
||||
|
||||
|
||||
# join 用户侧和新闻侧的特征
|
||||
data = data.join(user_data.set_index("user_id"), on="user_id", how="inner")
|
||||
data = data.join(doc_data.set_index("article_id"), on="article_id", how="inner")
|
||||
|
||||
sparse_features = user_sparse_features + doc_sparse_features
|
||||
dense_features = doc_dense_features
|
||||
|
||||
features = sparse_features + dense_features
|
||||
|
||||
mms = MinMaxScaler(feature_range=(0, 1))
|
||||
data[dense_features] = mms.fit_transform(data[dense_features])
|
||||
```
|
||||
|
||||
2、配置特征以及模型训练
|
||||
构建模型所需的输入特征，同时构建DSSM模型及训练。
|
||||
|
||||
```python
|
||||
embedding_dim = 8
|
||||
user_feature_columns = [SparseFeat('user_id', feature_max_idx['user_id'], embedding_dim),
|
||||
SparseFeat("gender", feature_max_idx['gender'], embedding_dim),
|
||||
SparseFeat("age", feature_max_idx['age'], embedding_dim),
|
||||
SparseFeat("device", feature_max_idx['device'], embedding_dim),
|
||||
SparseFeat("os", feature_max_idx['os'], embedding_dim),
|
||||
SparseFeat("province", feature_max_idx['province'], embedding_dim),
|
||||
SparseFeat("city", feature_max_idx['city'], embedding_dim), ]
|
||||
|
||||
item_feature_columns = [SparseFeat('article_id', feature_max_idx['article_id'], embedding_dim),
|
||||
DenseFeat('img_num', 1),
|
||||
DenseFeat('title_len', 1),
|
||||
SparseFeat('cate', feature_max_idx['cate'], embedding_dim),
|
||||
SparseFeat('sub_cate', feature_max_idx['sub_cate'], embedding_dim)]
|
||||
|
||||
model = DSSM(user_feature_columns, item_feature_columns,
|
||||
user_dnn_hidden_units=(32, 16, embedding_dim), item_dnn_hidden_units=(32, 16, embedding_dim)) # FM(user_feature_columns,item_feature_columns)
|
||||
|
||||
model.compile(optimizer="adagrad", loss = "binary_crossentropy", metrics=[tf.keras.metrics.Recall(), tf.keras.metrics.Precision()] ) #
|
||||
|
||||
history = model.fit(train_model_input, train_label, batch_size=256, epochs=4, verbose=1, validation_split=0.2, )
|
||||
```
|
||||
|
||||
3、生成embedding用于召回
|
||||
利用训练过的模型获取所有item的embeddings，同时获取所有测试集的user embedding，保存之后用于之后的召回工作。
|
||||
|
||||
```python
|
||||
all_item_model_input = {"article_id": item_profile['article_id'].values,
|
||||
"img_num": item_profile['img_num'].values,
|
||||
"title_len": item_profile['title_len'].values,
|
||||
"cate": item_profile['cate'].values,
|
||||
"sub_cate": item_profile['sub_cate'].values,}
|
||||
|
||||
user_embedding_model = Model(inputs=model.user_input, outputs=model.user_embedding)
|
||||
item_embedding_model = Model(inputs=model.item_input, outputs=model.item_embedding)
|
||||
|
||||
user_embs = user_embedding_model.predict(test_user_model_input, batch_size=2 ** 12)
|
||||
item_embs = item_embedding_model.predict(all_item_model_input, batch_size=2 ** 12)
|
||||
|
||||
user_idx_2_rawid, doc_idx_2_rawid = {}, {}
|
||||
|
||||
for i in range(len(user_embs)):
|
||||
user_idx_2_rawid[i] = test_user_model_input["user_id"][i]
|
||||
|
||||
for i in range(len(item_embs)):
|
||||
doc_idx_2_rawid[i] = all_item_model_input["article_id"][i]
|
||||
|
||||
# 保存一份
|
||||
pickle.dump((user_embs, user_idx_2_rawid, feature_encoder["user_id"]), open(file_path + 'user_embs.pkl', 'wb'))
|
||||
pickle.dump((item_embs, doc_idx_2_rawid, feature_encoder["article_id"]), open(file_path + 'item_embs.pkl', 'wb'))
|
||||
```
|
||||
|
||||
|
||||
### ANN召回
|
||||
|
||||
1、为测试集用户召回
|
||||
通过annoy tree为所有的item构建索引，并通过测试集中所有的user embedding为每个用户召回一定数量的item。
|
||||
|
||||
```python
|
||||
def get_DSSM_recall_res(user_embs, doc_embs, user_idx_2_rawid, doc_idx_2_rawid, topk):
|
||||
"""近邻检索，这里用annoy tree"""
|
||||
# 把doc_embs构建成索引树
|
||||
f = user_embs.shape[1]
|
||||
t = AnnoyIndex(f, 'angular')
|
||||
for i, v in enumerate(doc_embs):
|
||||
t.add_item(i, v)
|
||||
t.build(10)
|
||||
|
||||
# 每个用户向量， 返回最近的TopK个item
|
||||
user_recall_items_dict = collections.defaultdict(dict)
|
||||
for i, u in enumerate(user_embs):
|
||||
recall_doc_scores = t.get_nns_by_vector(u, topk, include_distances=True)
|
||||
# recall_doc_scores是(([doc_idx], [scores]))， 这里需要转成原始doc的id
|
||||
raw_doc_scores = list(recall_doc_scores)
|
||||
raw_doc_scores[0] = [doc_idx_2_rawid[i] for i in raw_doc_scores[0]]
|
||||
# 转换成实际用户id
|
||||
user_recall_items_dict[user_idx_2_rawid[i]] = dict(zip(*raw_doc_scores))
|
||||
|
||||
# 默认是分数从小到大排的序， 这里要从大到小
|
||||
user_recall_items_dict = {k: sorted(v.items(), key=lambda x: x[1], reverse=True) for k, v in user_recall_items_dict.items()}
|
||||
|
||||
pickle.dump(user_recall_items_dict, open(file_path + 'DSSM_u2i_dict.pkl', 'wb'))
|
||||
|
||||
return user_recall_items_dict
|
||||
```
|
||||
|
||||
2、测试召回结果
|
||||
为测试集用户的召回结果进行测试。
|
||||
|
||||
```python
|
||||
user_recall_items_dict = get_DSSM_recall_res(user_embs, item_embs, user_idx_2_rawid, doc_idx_2_rawid, topk=TOP_NUM)
|
||||
|
||||
test_true_items = {line[0]:line[1] for line in test_set}
|
||||
|
||||
s = []
|
||||
precision = []
|
||||
for i, uid in tqdm(enumerate(list(user_recall_items_dict.keys()))):
|
||||
# try:
|
||||
pred = [x for x, _ in user_recall_items_dict[uid]]
|
||||
filter_item = None
|
||||
recall_score = recall_N(test_true_items[uid], pred, N=TOP_NUM)
|
||||
s.append(recall_score)
|
||||
precision_score = precision_N(test_true_items[uid], pred, N=TOP_NUM)
|
||||
precision.append(precision_score)
|
||||
print("recall", np.mean(s))
|
||||
print("precision", np.mean(precision))
|
||||
```
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
## 参考
|
||||
|
||||
- [负样本为王：评Facebook的向量化召回算法](https://zhuanlan.zhihu.com/p/165064102)
|
||||
|
||||
- [多目标DSSM召回实战](https://mp.weixin.qq.com/s/aorZ43WozKrD2AudR6AnOg)
|
||||
|
||||
- [召回模型中的负样本构造](https://zhuanlan.zhihu.com/p/358450850)
|
||||
|
||||
- [Youtube双塔模型](https://dl.acm.org/doi/10.1145/3298689.3346996)
|
||||
|
||||
- [张俊林：SENet双塔模型：在推荐领域召回粗排的应用及其它](https://zhuanlan.zhihu.com/p/358779957)
|
||||
|
||||
- [双塔召回模型的前世今生（上篇）](https://zhuanlan.zhihu.com/p/430503952)
|
||||
|
||||
- [双塔召回模型的前世今生（下篇）](https://zhuanlan.zhihu.com/p/441597009)
|
||||
|
||||
- [Learning Deep Structured Semantic Models for Web Search using Clickthrough Data](https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/cikm2013_DSSM_fullversion.pdf)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
124
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.2/FM.md
Normal file
124
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.2/FM.md
Normal file
@@ -0,0 +1,124 @@
|
||||
# FM 模型结构
|
||||
|
||||
FM 模型用于排序时，模型的公式定义如下：
|
||||
$$
|
||||
\hat{y}(\mathbf{x}):=w_{0}+\sum_{i=1}^{n} w_{i} x_{i}+\sum_{i=1}^{n} \sum_{j=i+1}^{n}\left\langle\mathbf{v}_{i}, \mathbf{v}_{j}\right\rangle x_{i} x_{j}
|
||||
$$
|
||||
+ 其中，$i$ 表示特征的序号，$n$ 表示特征的数量；$x_i \in \mathbb{R}$ 表示第 $i$ 个特征的值。
|
||||
+ $v_i,v_j \in \mathbb{R}^{k} $ 分别表示特征 $x_i,x_j$ 对应的隐语义向量（Embedding向量）， $\left\langle\mathbf{v}_{i}, \mathbf{v}_{j}\right\rangle:=\sum_{f=1}^{k} v_{i, f} \cdot v_{j, f}$ 。
|
||||
+ $w_0,w_i\in \mathbb{R}$ 均表示需要学习的参数。
|
||||
|
||||
**FM 的一阶特征交互**
|
||||
|
||||
在 FM 的表达式中，前两项为特征的一阶交互项。将其拆分为用户特征和物品特征的一阶特征交互项，如下：
|
||||
$$
|
||||
\begin{aligned}
|
||||
& w_{0}+\sum_{i=1}^{n} w_{i} x_{i} \\
|
||||
&= w_{0} + \sum_{t \in I}w_{t} x_{t} + \sum_{u\in U}w_{u} x_{u} \\
|
||||
\end{aligned}
|
||||
$$
|
||||
|
||||
+ 其中，$U$ 表示用户相关特征集合，$I$ 表示物品相关特征集合。
|
||||
|
||||
**FM 的二阶特征交互**
|
||||
|
||||
观察 FM 的二阶特征交互项，可知其计算复杂度为 $O\left(k n^{2}\right)$ 。为了降低计算复杂度，按照如下公式进行变换。
|
||||
$$
|
||||
\begin{aligned}
|
||||
& \sum_{i=1}^{n} \sum_{j=i+1}^{n}\left\langle\mathbf{v}_{i}, \mathbf{v}_{j}\right\rangle x_{i} x_{j} \\
|
||||
=& \frac{1}{2} \sum_{i=1}^{n} \sum_{j=1}^{n}\left\langle\mathbf{v}_{i}, \mathbf{v}_{j}\right\rangle x_{i} x_{j}-\frac{1}{2} \sum_{i=1}^{n}\left\langle\mathbf{v}_{i}, \mathbf{v}_{i}\right\rangle x_{i} x_{i} \\
|
||||
=& \frac{1}{2}\left(\sum_{i=1}^{n} \sum_{j=1}^{n} \sum_{f=1}^{k} v_{i, f} v_{j, f} x_{i} x_{j}-\sum_{i=1}^{n} \sum_{f=1}^{k} v_{i, f} v_{i, f} x_{i} x_{i}\right) \\
|
||||
=& \frac{1}{2} \sum_{f=1}^{k}\left(\left(\sum_{i=1}^{n} v_{i, f} x_{i}\right)^{}\left(\sum_{j=1}^{n} v_{j, f} x_{j}\right)-\sum_{i=1}^{n} v_{i, f}^{2} x_{i}^{2}\right) \\
|
||||
=& \frac{1}{2} \sum_{f=1}^{k}\left(\left(\sum_{i=1}^{n} v_{i, f} x_{i}\right)^{2}-\sum_{i=1}^{n} v_{i, f}^{2} x_{i}^{2}\right)
|
||||
\end{aligned}
|
||||
$$
|
||||
+ 公式变换后，计算复杂度由 $O\left(k n^{2}\right)$ 降到 $O\left(k n\right)$。
|
||||
|
||||
由于本文章需要将 FM 模型用在召回，故将二阶特征交互项拆分为用户和物品项。有：
|
||||
$$
|
||||
\begin{aligned}
|
||||
& \frac{1}{2} \sum_{f=1}^{k}\left(\left(\sum_{i=1}^{n} v_{i, f} x_{i}\right)^{2}-\sum_{i=1}^{n} v_{i, f}^{2} x_{i}^{2}\right) \\
|
||||
=& \frac{1}{2} \sum_{f=1}^{k}\left(\left(\sum_{u \in U} v_{u, f} x_{u} + \sum_{t \in I} v_{t, f} x_{t}\right)^{2}-\sum_{u \in U} v_{u, f}^{2} x_{u}^{2} - \sum_{t\in I} v_{t, f}^{2} x_{t}^{2}\right) \\
|
||||
=& \frac{1}{2} \sum_{f=1}^{k}\left(\left(\sum_{u \in U} v_{u, f} x_{u}\right)^{2} + \left(\sum_{t \in I} v_{t, f} x_{t}\right)^{2} + 2{\sum_{u \in U} v_{u, f} x_{u}}{\sum_{t \in I} v_{t, f} x_{t}} - \sum_{u \in U} v_{u, f}^{2} x_{u}^{2} - \sum_{t \in I} v_{t, f}^{2} x_{t}^{2}\right)
|
||||
\end{aligned}
|
||||
$$
|
||||
|
||||
+ 其中，$U$ 表示用户相关特征集合，$I$ 表示物品相关特征集合。
|
||||
|
||||
|
||||
|
||||
# FM 用于召回
|
||||
|
||||
基于 FM 召回，我们可以将 $\hat{y}(\mathbf{x}):=w_{0}+\sum_{i=1}^{n} w_{i} x_{i}+\sum_{i=1}^{n} \sum_{j=i+1}^{n}\left\langle\mathbf{v}_{i}, \mathbf{v}_{j}\right\rangle x_{i} x_{j}$ 作为用户和物品之间的匹配分。
|
||||
|
||||
+ 在上一小节中，对于 FM 的一阶、二阶特征交互项，已将其拆分为用户项和物品项。
|
||||
+ 对于同一用户，即便其与不同物品进行交互，但用户特征内部之间的一阶、二阶交互项得分都是相同的。
|
||||
+ 这就意味着，在比较用户与不同物品之间的匹配分时，只需要比较：（1）物品内部之间的特征交互得分；（2）用户和物品之间的特征交互得分。
|
||||
|
||||
**FM 的一阶特征交互**
|
||||
|
||||
+ 将全局偏置和用户一阶特征交互项进行丢弃，有：
|
||||
$$
|
||||
FM_{一阶} = \sum_{t \in I} w_{t} x_{t}
|
||||
$$
|
||||
|
||||
**FM 的二阶特征交互**
|
||||
|
||||
+ 将用户特征内部的特征交互项进行丢弃，有：
|
||||
$$
|
||||
\begin{aligned}
|
||||
& FM_{二阶} = \frac{1}{2} \sum_{f=1}^{k}\left(\left(\sum_{t \in I} v_{t, f} x_{t}\right)^{2} + 2{\sum_{u \in U} v_{u, f} x_{u}}{\sum_{t \in I} v_{t, f} x_{t}} - \sum_{t \in I} v_{t, f}^{2} x_{t}^{2}\right) \\
|
||||
&= \frac{1}{2} \sum_{f=1}^{k}\left(\left(\sum_{t \in I} v_{t, f} x_{t}\right)^{2} - \sum_{t \in I} v_{t, f}^{2} x_{t}^{2}\right) + \sum_{f=1}^{k}\left( {\sum_{u \in U} v_{u, f} x_{u}}{\sum_{t \in I} v_{t, f} x_{t}} \right)
|
||||
|
||||
|
||||
\end{aligned}
|
||||
$$
|
||||
|
||||
合并 FM 的一阶、二阶特征交互项，得到基于 FM 召回的匹配分计算公式：
|
||||
$$
|
||||
\text{MatchScore}_{FM} = \sum_{t \in I} w_{t} x_{t} + \frac{1}{2} \sum_{f=1}^{k}\left(\left(\sum_{t \in I} v_{t, f} x_{t}\right)^{2} - \sum_{t \in I} v_{t, f}^{2} x_{t}^{2}\right) + \sum_{f=1}^{k}\left( {\sum_{u \in U} v_{u, f} x_{u}}{\sum_{t \in I} v_{t, f} x_{t}} \right)
|
||||
$$
|
||||
在基于向量的召回模型中，为了 ANN（近似最近邻算法） 或 Faiss 加速查找与用户兴趣度匹配的物品。基于向量的召回模型，一般最后都会得到用户和物品的特征向量表示，然后通过向量之间的内积或者余弦相似度表示用户对物品的兴趣程度。
|
||||
|
||||
基于 FM 模型的召回算法，也是向量召回算法的一种。所以下面，将 $\text{MatchScore}_{FM}$ 化简为用户向量和物品向量的内积形式，如下：
|
||||
$$
|
||||
\text{MatchScore}_{FM} = V_{item} V_{user}^T
|
||||
$$
|
||||
|
||||
+ 用户向量：
|
||||
$$
|
||||
V_{user} = [1; \quad {\sum_{u \in U} v_{u} x_{u}}]
|
||||
$$
|
||||
|
||||
+ 用户向量由两项表达式拼接得到。
|
||||
+ 第一项为常数 $1$，第二项是将用户相关的特征向量进行 sum pooling 。
|
||||
|
||||
+ 物品向量：
|
||||
$$
|
||||
V_{item} = [\sum_{t \in I} w_{t} x_{t} + \frac{1}{2} \sum_{f=1}^{k}\left(\left(\sum_{t \in I} v_{t, f} x_{t}\right)^{2} - \sum_{t \in I} v_{t, f}^{2} x_{t}^{2}\right); \quad
|
||||
{\sum_{t \in I} v_{t} x_{t}} ]
|
||||
$$
|
||||
|
||||
+ 第一项表示物品相关特征向量的一阶、二阶特征交互。
|
||||
+ 第二项是将物品相关的特征向量进行 sum pooling 。
|
||||
|
||||
|
||||
|
||||
# 思考题
|
||||
|
||||
1. 为什么不直接将 FM 中学习到的 User Embedding： ${\sum_{u \in U} v_{u} x_{u}}$ 和 Item Embedding： $\sum_{t \in I} v_{t} x_{t}$ 的内积做召回呢？
|
||||
|
||||
答：这样做，也不是不行，但是效果不是特别好。**因为用户喜欢的，未必一定是与自身最匹配的，也包括一些自身性质极佳的item（e.g.,热门item）**，所以，**非常有必要将"所有Item特征一阶权重之和"和“所有Item特征隐向量两两点积之和”考虑进去**，但是也还必须写成点积的形式。
|
||||
|
||||
|
||||
|
||||
# 代码实战
|
||||
|
||||
正在完善...
|
||||
|
||||
|
||||
|
||||
# 参考链接
|
||||
|
||||
+ [paper.dvi (ntu.edu.tw)](https://www.csie.ntu.edu.tw/~b97053/paper/Rendle2010FM.pdf)
|
||||
+ [FM：推荐算法中的瑞士军刀 - 知乎 (zhihu.com)](https://zhuanlan.zhihu.com/p/343174108)
|
||||
589
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.2/YoutubeDNN.md
Normal file
589
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.2/YoutubeDNN.md
Normal file
@@ -0,0 +1,589 @@
|
||||
## 写在前面
|
||||
YouTubeDNN模型是2016年的一篇文章，虽然离着现在有些久远， 但这篇文章无疑是工业界论文的典范， 完全是从工业界的角度去思考如何去做好一个推荐系统，并且处处是YouTube工程师留给我们的宝贵经验， 由于这两天用到了这个模型，今天也正好重温了下这篇文章，所以借着这个机会也整理出来吧， 王喆老师都称这篇文章是"神文"， 可见其不一般处。
|
||||
|
||||
今天读完之后， 给我的最大感觉，首先是从工程的角度去剖析了整个推荐系统，讲到了推荐系统中最重要的两大模块: 召回和排序， 这篇论文对初学者非常友好，之前的论文模型是看不到这么全面的系统的，总有一种管中规豹的感觉，看不到全局，容易着相。 其次就是这篇文章给出了很多优化推荐系统中的工程性经验， 不管是召回还是排序上，都有很多的套路或者trick，比如召回方面的"example age", "负采样"，"非对称消费，防止泄露"，排序方面的特征工程，加权逻辑回归等， 这些东西至今也都非常的实用，所以这也是这篇文章厉害的地方。
|
||||
|
||||
本篇文章依然是以paper为主线， 先剖析paper里面的每个细节，当然我这里也参考了其他大佬写的文章，王喆老师的几篇文章写的都很好，链接我也放在了下面，建议也看看。然后就是如何用YouTubeDNN模型，代码复现部分，由于时间比较短，自己先不复现了，调deepmatch的包跑起来，然后在新闻推荐数据集上进行了一些实验， 尝试了论文里面讲述的一些方法，这里主要是把deepmatch的YouTubeDNN模型怎么使用，以及我整个实验过程的所思所想给整理下， 因为这个模型结构本质上并不是很复杂(三四层的全连接网络)，就不自己在实现一遍啦， 一些工程经验或者思想，我觉得才是这篇文章的精华部分。
|
||||
|
||||
|
||||
## 引言与推荐系统的漏斗范式
|
||||
### 引言部分
|
||||
本篇论文是工程性论文(之前的DIN也是偏工程实践的论文)， 行文风格上以实际应用为主， 我们知道YouTube是全球性的视频网站， 所以这篇文章主要讲述了YouTube视频推荐系统的基本架构以及细节，以及各种处理tricks。
|
||||
|
||||
在Introduction部分， 作者首先说了在工业上的YouTube视频推荐系统主要面临的三大挑战:
|
||||
1. Scale(规模): 视频数量非常庞大，大规模数据下需要分布式学习算法以及高效的线上服务系统，文中体现这一点的是召回模型线下训练的时候，采用了负采样的思路，线上服务的时候，采用了hash映射，然后近邻检索的方式来满足实时性的需求， 这个之前我整理过faiss包和annoy包的使用， 感兴趣的可以看看。 其实，再拔高一层，我们推荐系统的整体架构呈漏斗范式，也是为了保证能从大规模情景下实时推荐。
|
||||
2. Freshness(新鲜度): YouTube上的视频是一个动态的， 用户实时上传，且实时访问， 那么这时候， 最新的视频往往就容易博得用户的眼球， 用户一般都比较喜欢看比较新的视频， 而不管是不是真和用户相关(这个感觉和新闻比较类似呀)， 这时候，就需要模型有建模新上传内容以及用户最新发生的行为能力。 为了让模型学习到用户对新视频有偏好， 后面策略里面加了一个"example age"作为体现。我们说的"探索与利用"中的探索，其实也是对新鲜度的把握。
|
||||
3. Noise(噪声): 由于数据的稀疏和不可见的其他原因， 数据里面的噪声非常之多，这时候，就需要让这个推荐系统变得鲁棒，怎么鲁棒呢？ 这个涉及到召回和排序两块，召回上需要考虑更多实际因素，比如非对称消费特性，高活用户因素，时间因素，序列因素等，并采取了相应的措施， 而排序上做更加细致的特征工程， 尽量的刻画出用户兴趣以及视频的特征 优化训练目标，使用加权的逻辑回归等。而召回和排序模型上，都采用了深度神经网络，通过特征的相互交叉，有了更强大的建模能力， 相比于之前用的MF(矩阵分解)， 建模能力上有了很大的提升， 这些都有助于帮助减少噪声， 使得推荐结果更加准确。
|
||||
|
||||
所以从文章整体逻辑上看， 后面的各个细节，其实都是围绕着挑战展开的，找到当前推荐面临的问题，就得想办法解决问题，所以这篇文章的行文逻辑也是非常清晰的。
|
||||
|
||||
知道了挑战， 那么下面就看看YouTubeDNN的整体推荐系统架构。
|
||||
|
||||
### YouTubeDNN推荐系统架构
|
||||
整个推荐架构图如下， 这个算是比较原始的漏斗结构了:
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/1c5dbd6d6c1646d09998b18d45f869e5.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBATWlyYWNsZTgwNzA=,size_1,color_FFFFFF,t_70,g_se,x_16#pic_center" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
这篇文章之所以写的好， 是给了我们一个看推荐系统的宏观视角， 这个系统主要是两大部分组成: 召回和排序。召回的目的是根据用户部分特征，从海量物品库，快速找到小部分用户潜在感兴趣的物品交给精排，重点强调快，精排主要是融入更多特征，使用复杂模型，来做个性化推荐，强调准。
|
||||
|
||||
而对于这两块的具体描述， 论文里面也给出了解释， 我这里简单基于我目前的理解扩展下主流方法：
|
||||
1. 召回侧
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/5ebcd6f882934b7e9e2ffb9de2aee29d.png#pic_center" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
召回侧模型的输入一般是用户的点击历史， 因为我们认为这些历史能更好的代表用户的兴趣， 另外还有一些人口统计学特征，比如性别，年龄，地域等， 都可以作为召回侧模型的输入。 而最终模型的输出，就是与该用户相关的一个候选视频集合， 量级的话一般是几百。
|
||||
<br>召回侧， 目前根据我的理解，大致上有两大类召回方式，一类是策略规则，一类是监督模型+embedding，其中策略规则，往往和真实场景有关，比如热度，历史重定向等等，不同的场景会有不同的召回方式，这种属于"特异性"知识。
|
||||
<br>后面的模型+embedding思路是一种"普适"方法，我上面图里面梳理出了目前给用户和物品打embedding的主流方法， 这些方法大致成几个系列，比如FM系列(FM,FFM等)， 用户行为序列，基于图和知识图谱系列，经典双塔系列等，这些方法看似很多很复杂，其实本质上还是给用户或者是物品打embedding而已，只不过考虑的角度方式不同。 这里的YouTubeDNN召回模型，也是这里的一种方式而已。
|
||||
2. 精排侧
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/08953c0e8a00476f90bd9e206d4a02c6.png#pic_center" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
召回那边对于每个用户， 给出了几百个比较相关的候选视频， 把几百万的规模降到了几百， 当然，召回那边利用的特征信息有限，并不能很好的刻画用户和视频特点，所以， 在精排侧，主要是想利用更多的用户，视频特征，刻画特点更加准确些，从这几百个里面选出几个或者十几个推荐给用户。 而涉及到准， 主要的发力点一般有三个：特征工程， 模型设计以及训练方法。 这三个发力点文章几乎都有所涉及， 除了模式设计有点审时度势之外，特征工程以及训练方法的处理上非常漂亮，具体的后面再整理。<br>
|
||||
精排侧，这一块的大致发展趋势，从ctr预估到多目标， 而模型演化上，从人工特征工程到特征工程自动化。主要是三大块， CTR预估主要分为了传统的LR，FM大家族，以及后面自动特征交叉的DNN家族，而多目标优化，目前是很多大公司的研究现状，更是未来的一大发展趋势，如何能让模型在各个目标上面的学习都能"游刃有余"是一件非常具有挑战的事情，毕竟不同的目标可能会互相冲突，互相影响，所以这里的研究热点又可以拆分成网络结构演化以及loss设计优化等， 而网络结构演化中，又可以再一次细分。 当然这每个模型或者技术几乎都有对应paper，我们依然可以通过读paper的方式，把这些关键技术学习到。
|
||||
|
||||
这两阶段的方法， 就能保证我们从大规模视频库中实时推荐， 又能保证个性化，吸引用户。 当然，随着时间的发展， 可能数据量非常非常大了， 此时召回结果规模精排依然无法处理，所以现在一般还会在召回和精排之间，加一个粗排进一步筛选作为过渡， 而随着场景越来越复杂， 精排产生的结果也不是直接给到用户，而是会再后面加一个重排后处理下，这篇paper里面其实也简单的提了下这种思想，在排序那块会整理到。 所以如今的漏斗， 也变得长了些。
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/aeae52971a1345a98b310890ea81be53.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBATWlyYWNsZTgwNzA=,size_1,color_FFFFFF,t_70,g_se,x_16#pic_center" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
论文里面还提到了对模型的评估方面， 线下评估的时候，主要是采用一些常用的评估指标(精确率，召回率， 排序损失或者auc这种)， 但是最终看算法和模型的有效性， 是通过A/B实验， 在A/B实验中会观察用户真实行为，比如点击率， 观看时长， 留存率这种， 这些才是我们终极目标， 而有时候， A/B实验的结果和线下我们用的这些指标并不总是相关， 这也是推荐系统这个场景的复杂性。 我们往往也会用一些策略，比如修改模型的优化目标，损失函数这种， 让线下的这个目标尽量的和A/B衡量的这种指标相关性大一些。 当然，这块又是属于业务场景问题了，不在整理范畴之中。 但2016年，竟然就提出了这种方式， 所以我觉得，作为小白的我们， 想了解工业上的推荐系统， 这篇paper是不二之选。
|
||||
|
||||
OK， 从宏观的大视角看完了漏斗型的推荐架构，我们就详细看看YouTube视频推荐架构里面召回和排序模块的模型到底长啥样子？ 为啥要设计成这个样子？ 为了应对实际中出现的挑战，又有哪些策略？
|
||||
|
||||
## YouTubeDNN的召回模型细节剖析
|
||||
上面说过， 召回模型的目的是在大量YouTube视频中检索出数百个和用户相关的视频来。
|
||||
|
||||
这个问题，我们可以看成一个多分类的问题，即用户在某一个时刻点击了某个视频， 可以建模成输入一个用户向量， 从海量视频中预测出被点击的那个视频的概率。
|
||||
|
||||
换成比较准确的数学语言描述， 在时刻$t$下， 用户$U$在背景$C$下对每个视频$i$的观看行为建模成下面的公式：
|
||||
$$
|
||||
P\left(w_{t}=i \mid U, C\right)=\frac{e^{v_{i} u}}{\sum_{j \in V} e^{v_{j} u}}
|
||||
$$
|
||||
这里的$u$表示用户向量， 这里的$v$表示视频向量， 两者的维度都是$N$， 召回模型的任务，就是通过用户的历史点击和山下文特征， 去学习最终的用户表示向量$u$以及视频$i$的表示向量$v_i$， 不过这俩还有个区别是$v_i$本身就是模型参数， 而$u$是神经网络的输出(函数输出)，是输入与模型参数的计算结果。
|
||||
>解释下这个公式， 为啥要写成这个样子，其实是word2vec那边借鉴过来的，$e^{ (v_{i} u)}$表示的是当前用户向量$u$与当前视频$v_i$的相似程度，$e$只是放大这个相似程度而已， 不用管。 为啥这个就能表示相似程度呢？ 因为两个向量的点积运算的含义就是可以衡量两个向量的相似程度， 两个向量越相似， 点积就会越大。 所以这个应该解释明白了。 再看分母$\sum_{j \in V} e^{v_{j} u}$, 这个显然是用户向量$u$与所有视频$v$的一个相似程度求和。 那么两者一除， 依然是代表了用户$u$与输出的视频$v_i$的相似程度，只不过归一化到了0-1之间， 毕竟我们知道概率是0-1之间的， 这就是为啥这个概率是右边形式的原因。 因为右边公式表示了用户$u$与输出的视频$v_i$的相似程度， 并且这个相似程度已经归一化到了0-1之间， 我们给定$u$希望输出$v_i$的概率越大，因为这样，当前的视频$v_i$和当前用户$u$更加相关，正好对应着点击行为不是吗？
|
||||
|
||||
那么，这个召回模型到底长啥样子呢？
|
||||
### 召回模型结构
|
||||
召回模型的结构如下:
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/724ff38c1d6448399edb658b1b27e18e.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBATWlyYWNsZTgwNzA=,size_1,color_FFFFFF,t_70,g_se,x_16#pic_center" alt="在这里插入图片描述" style="zoom:70%;" />
|
||||
</div>
|
||||
|
||||
这个模型结构呢，相比之前的模型， 比较简单，就是一个DNN。
|
||||
|
||||
它的输入主要是用户侧的特征，包括用户观看的历史video序列， 用户搜索的历史tokens， 然后就是用户的人文特征，比如地理位置， 性别，年龄这些。 这些特征处理上，和之前那些模型的也比较类似，
|
||||
* 用户历史序列，历史搜索tokens这种序列性的特征: 一般长这样`[item_id5, item_id2, item_id3, ...]`， 这种id特征是高维稀疏，首先会通过一个embedding层，转成低维稠密的embedding特征，即历史序列里面的每个id都会对应一个embedding向量， 这样历史序列就变成了多个embedding向量的形式， 这些向量一般会进行融合，常见的是average pooling，即每一维求平均得到一个最终向量来表示用户的历史兴趣或搜索兴趣。
|
||||
>这里值的一提的是这里的embedding向量得到的方式， 论文中作者这里说是通过word2vec方法计算的， 关于word2vec，这里就不过多解释，也就是每个item事先通过w2v方式算好了的embedding，直接作为了输入，然后进行pooling融合。<br><br>除了这种算好embedding方式之外，还可以过embedding层，跟上面的DNN一起训练，这些都是常规操作，之前整理的精排模型里面大都是用这种方式。
|
||||
|
||||
论文里面使用了用户最近的50次观看历史，用户最近50次搜索历史token， embedding维度是256维， 采用的average pooling。 当然，这里还可以把item的类别信息也隐射到embedding， 与前面的concat起来。
|
||||
* 用户人文特征， 这种特征处理方式就是离散型的依然是labelEncoder，然后embedding转成低维稠密， 而连续型特征，一般是先归一化操作，然后直接输入，当然有的也通过分桶，转成离散特征，这里不过多整理，特征工程做的事情了。 当然，这里还有一波操作值得注意，就是连续型特征除了用了$x$本身，还用了$x^2$，$logx$这种， 可以加入更多非线性，增加模型表达能力。<br>
|
||||
这些特征对新用户的推荐会比较有帮助，常见的用户的地理位置， 设备， 性别，年龄等。
|
||||
* 这里一个比较特色的特征是example age，这个特征后面需要单独整理。
|
||||
|
||||
这些特征处理好了之后，拼接起来，就成了一个非常长的向量，然后就是过DNN，这里用了一个三层的DNN， 得到了输出， 这个输出也是向量。
|
||||
|
||||
Ok，到这里平淡无奇， 前向传播也大致上快说完了， 还差最后一步。 最后这一步，就是做多分类问题，然后求损失，这就是training那边做的事情。 但是在详细说这个之前， 我想先简单回忆下word2vec里面的skip-gram Model， 这个模型，如果回忆起来，这里理解起来就非常的简单了。
|
||||
|
||||
这里只需要看一张图即可， 这个来自cs231N公开课PPT， 我之前整理w2v的时候用到的，这里的思想其实也是从w2v那边过来的。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20200624193409649.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="在这里插入图片描述" style="zoom:70%;" />
|
||||
</div>
|
||||
|
||||
skip-gram的原理咱这里就不整理了， 这里就只看这张图，这其实就是w2v训练的一种方式，当然是最原始的。 word2vec的核心思想呢？ 就是共现频率高的词相关性越大，所以skip-gram采用中心词预测上下文词的方式去训练词向量，模型的输入是中心词，做样本采用滑动窗口的形式，和这里序列其实差不多，窗口滑动一次就能得到一个序列[word1, word2, ...wordn]， 而这个序列里面呢？ 就会有中心词(比如中间那个)， 两边向量的是上下文词。 如果我们输入中心词之后，模型能预测上下文词的概率大，那说明这个模型就能解决词相关性问题了。
|
||||
>一开始， 我们的中心单词$w_t$就是one-hot的表示形式，也就是在词典中的位置，这里的形状是$V \times1$， $V$表示词库里面有$V$个单词， 这里的$W$长上面那样， 是一个$d\times V$的矩阵， $d$表示的是词嵌入的维度， 那么用$W*w_t$（矩阵乘法）就会得到中心词的词向量表示$v_c$， 大小是$d\times1$。这个就是中心词的embedding向量。 其实就是中心词过了一个embedding层得到了它的embedding向量。
|
||||
><br>然后就是$v_c$和上下文矩阵$W'$相乘， 这里的$W'$是$V\times d$的一个矩阵， 每一行代表每个单词作为上下文的时候的词向量表示， 也就是$u_w$， 每一列是词嵌入的维度。 这样通过$W'*v_c$就会得到一个$V\times 1$的向量，这个表示的就是中心单词$w_t$与每个单词的相似程度。
|
||||
><br>最后，我们通过softmax操作把这个相似程度转成概率， 选择概率最大的index输出。
|
||||
|
||||
这就是这个模型的前向传播过程。
|
||||
|
||||
有了这个过程， 再理解YouTubeDNN顶部就非常容易了， 我单独截出来:
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/98811e09226f42a2be981b0aa3449ab3.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBATWlyYWNsZTgwNzA=,size_1,color_FFFFFF,t_70,g_se,x_16#pic_center" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
只看这里的这个过程， 其实就是上面skip-gram过程， 不一样的是右边这个中心词向量$v_c$是直接过了一个embedding层得到的，而左边这个用户向量$u$是用户的各种特征先拼接成一个大的向量，然后过了一个DNN降维。 训练方式上，这两个也是一模一样的，无非就是左边的召回模型，多了几层全连接而已。
|
||||
> 这样，也就很容易的理解，模型训练好了之后，用户向量和item向量到底在哪里取了吧。
|
||||
> * 用户向量，其实就是全连接的DNN网络的输出向量，其实即使没有全连接，原始的用户各个特征拼接起来的那个长向量也能用，不过维度可能太大了，所以DNN在这里的作用一个是特征交叉，另一个还有降维的功效。
|
||||
> * item向量: 这个其实和skip-gram那个一样，每个item其实是用两个embedding向量的，比如skip-gram那里就有一个作为中心词时候的embedding矩阵$W$和作为上下文词时候的embedding矩阵$W'$， 一般取的时候会取前面那个$W$作为每个词的词向量。 这里其实一个道理，只不过这里最前面那个item向量矩阵，是通过了w2v的方式训练好了直接作为的输入，如果不事先计算好，对应的是embedding层得到的那个矩阵。 后面的item向量矩阵，就是这里得到用户向量之后，后面进行softmax之前的这个矩阵， **YouTubeDNN最终是从这个矩阵里面拿item向量**。
|
||||
|
||||
这就是知识串联的魅力，其实熟悉了word2vec， 这个召回模型理解非常简单。
|
||||
|
||||
这其实就是这个模型训练阶段最原始的剖析，实际训练的时候，依然是采用了优化方法， 这个和word2vec也是一样，采用了负采样的方式(当然实现细节上有区别)，因为视频的数量太大，每次做多分类，最终那个概率分母上的加和就非常可怕了，所以就把多分类问题转成了多个二分类的问题。 也就是不用全部的视频，而是随机选择出了一些没点的视频， 标记为0， 点了的视频标记为1， 这样就成了二分类的问题。 关于负样本采样原理， 我之前也整理了[一篇博客](https://blog.csdn.net/wuzhongqiang/article/details/106979179?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522164310239216780274177509%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=164310239216780274177509&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_ecpm_v1~rank_v31_ecpm-1-106979179.nonecase&utm_term=word2vec&spm=1018.2226.3001.4450)
|
||||
>负类基于样本分布抽取而来。负采样是针对类别数很多情况下的常用方法。当然，负样本的选择也是有讲究的，详细的看[这篇文章](https://www.zhihu.com/question/334844408/answer/2299283878), 我后面实验主要用了下面两种
|
||||
>* 展示数据随机选择负例
|
||||
>* 随机负例与热门打压
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/6fe56d71de8a4d769a583f27a3ce9f40.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBATWlyYWNsZTgwNzA=,size_1,color_FFFFFF,t_70,g_se,x_16#pic_center" alt="在这里插入图片描述" style="zoom:70%;" />
|
||||
</div>
|
||||
|
||||
这样整个召回模型训练部分的"基本操作"就基本整理完了。关于细节部分，后面代码里面会描述下， 但是在训练召回模型过程中，还有一些经验性的知识也非常重要。 下面重点整理一下。
|
||||
|
||||
### 训练数据的选取和生成
|
||||
模型训练的时候， 为了计算更加高效，采用了负采样的方法， 但正负样本的选取，以及训练样本的来源， 还有一些注意事项。
|
||||
|
||||
首先，训练样本来源于全部的YouTube观看记录，而不仅仅是被推荐的观看记录
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/faf8a8abf7b54b779287acadc015b6a0.png#pic_center" alt="在这里插入图片描述" style="zoom:70%;" />
|
||||
</div>
|
||||
|
||||
否则对于新视频会难以被曝光，会使最终推荐结果有偏；同时系统也会采集用户从其他渠道观看的视频，从而可以快速应用到协同过滤中；
|
||||
|
||||
其次， 是训练数据来源于用户的隐式数据， 且**用户看完了的视频作为正样本**， 注意这里是看完了， 有一定的时长限制， 而不是仅仅曝光点击，有可能有误点的。 而负样本，是从视频库里面随机选取，或者在曝光过的里面随机选取用户没看过的作为负样本。
|
||||
|
||||
==这里的一个经验==是**训练数据中对于每个用户选取相同的样本数， 保证用户在损失函数等权重**， 因为这样可以减少高度活跃用户对于loss的影响。可以改进线上A/B测试的效果。
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/35386af8fd064de3a87cb418b008e444.png#pic_center" alt="在这里插入图片描述" style="zoom:70%;" />
|
||||
</div>
|
||||
|
||||
这里的==另一个经验==是**避免让模型知道不该知道的信息**
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/0765134e1ca445c693058aaaaf20ae74.png#pic_center" alt="在这里插入图片描述" style="zoom:70%;" />
|
||||
</div>
|
||||
|
||||
这里作者举了一个例子是如果模型知道用户最后的行为是搜索了"Taylor Swift"， 那么模型可能会倾向于推荐搜索页面搜"Taylor Swift"时搜索的视频， 这个不是推荐模型期望的行为。 解法方法是**扔掉时序信息**， 历史搜索tokens随机打乱， 使用无序的搜索tokens来表示搜索queryies(average pooling)。
|
||||
>基于这个例子就把时序信息扔掉理由挺勉强的，解决这种特殊场景的信息泄露会有更针对性的方法，比如把搜索query与搜索结果行为绑定让它们不可分。 感觉时序信息还是挺重要的， 有专门针对时序信息建模的研究。
|
||||
|
||||
在生成样本的时候， 如果我们的用户比较少，行为比较少， 是不足以训练一个较好的召回模型，此时一个用户的历史观看序列，可以采用滑动窗口的形式生成多个训练样本， 比如一个用户的历史观看记录是"abcdef"， 那么采用滑动窗口， 可以是abc预测d, bcd预测e, cde预测f，这样一个用户就能生成3条训练样本。 后面实验里面也是这么做的。 但这时候一定要注意一点，就是**信息泄露**，这个也是和word2vec的cbow不一样的地方。
|
||||
|
||||
论文中上面这种滑动制作样本的方式依据是用户的"asymmetric co-watch probabilities(非对称观看概率)"，即一般情况下，用户开始浏览范围较广， 之后浏览范围逐渐变窄。
|
||||
|
||||
下图中的$w_{tN}$表示当前样本， 原来的做法是它前后的用户行为都可以用来产生特征行为输入(word2vec的CBOW做样本的方法)。 而作者担心这一点会导致信息泄露， 模型**不该知道的信息是未来的用户行为**， 所以作者的做法是只使用更早时间的用户行为来产生特征， 这个也是目前通用的做法。 两种方法的对比如下:
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/049cbeb814f843fd97638ef02d6c5703.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBATWlyYWNsZTgwNzA=,size_2,color_FFFFFF,t_70,g_se,x_16#pic_center" alt="在这里插入图片描述" style="zoom:70%;" />
|
||||
</div>
|
||||
|
||||
(a)是许多协同过滤会采取的方法，利用全局的观看信息作为输入（包括时间节点N前，N后的观看），这种方法忽略了观看序列的不对称性，而本文中采取(b)所示的方法，只把历史信息当作输入，用历史来预测未来
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/4ac0c81e5f4f4276a4ed0e4c6329f458.png#pic_center" alt="在这里插入图片描述" style="zoom:70%;" />
|
||||
</div>
|
||||
|
||||
模型的测试集， 往往也是用户最近一次观看行为， 后面的实验中，把用户最后一次点击放到了测试集里面去。这样可以防止信息穿越。
|
||||
|
||||
数据集的细节和tricks基本上说完， 更细的东西，就得通过代码去解释了。 接下来， 再聊聊作者加入的非常有意思的一个特征，叫做example age。
|
||||
|
||||
### "Example Age"特征
|
||||
这个特征我想单独拿出来说，是因为这个是和场景比较相关的特征，也是作者的经验传授。 我们知道，视频有明显的生命周期，例如刚上传的视频比之后更受欢迎，也就是用户往往喜欢看最新的东西，而不管它是不是和用户相关，所以视频的流行度随着时间的分布是高度非稳态变化的(下面图中的绿色曲线)
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/15dfce743bd2490a8adb21fd3b2b294e.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBATWlyYWNsZTgwNzA=,size_1,color_FFFFFF,t_70,g_se,x_16#pic_center" alt="在这里插入图片描述" style="zoom:70%;" />
|
||||
</div>
|
||||
|
||||
但是我们模型训练的时候，是基于历史数据训练的(历史观看记录的平均)，所以模型对播放某个视频预测值的期望会倾向于其在训练数据时间内的平均播放概率(平均热度)， 上图中蓝色线。但如上面绿色线，实际上该视频在训练数据时间窗口内热度很可能不均匀， 用户本身就喜欢新上传的内容。 所以，为了让模型学习到用户这种对新颖内容的bias， 作者引入了"example age"这个特征来捕捉视频的生命周期。
|
||||
|
||||
"example age"定义为$t_{max}-t$， 其中$t_{max}$是训练数据中所有样本的时间最大值(有的文章说是当前时间，但我总觉得还是选取的训练数据所在时间段的右端点时间比较合适，就比如我用的数据集， 最晚时间是2021年7月的，总不能用现在的时间吧)， 而$t$为当前样本的时间。**线上预测时， 直接把example age全部设为0或一个小的负值，这样就不依赖于各个视频的上传时间了**。
|
||||
>其实这个操作， 现在常用的是位置上的除偏， 比如商品推荐的时候， 用户往往喜欢点击最上面位置的商品或广告， 但这个bias模型依然是不知道， 为了让模型学习到这个东西， 也可以把商品或者广告的位置信息做成一个feature， 训练的时候告诉模型。 而线上推理的那些商品， 这个feature也都用一样的。 异曲同工的意思有没有。<br><br>那么这样的操作为啥会work呢？ example age这个我理解，是有了这个特征， 就可以把某视频的热度分布信息传递给模型了， 比如某个example age时间段该视频播放较多， 而另外的时间段播放较少， 这样模型就能发现用户的这种新颖偏好， 消除热度偏见。<br><br>这个地方看了一些文章写说， 这样做有利于让模型推新热内容， 总感觉不是很通。 我这里理解是类似让模型消除位置偏见那样， 这里消除一种热度偏见。 <br><br>我理解是这样，假设没有这样一个example age特征表示视频新颖信息，或者一个位置特征表示商品的位置信息，那模型训练的样本，可能是用户点击了这个item，就是正样本， 但此时有可能是用户真的喜欢这个item， 也有可能是因为一些bias， 比如用户本身喜欢新颖， 用户本身喜欢点击上面位置的item等， 但模型推理的时候，都会误认为是用户真的喜欢这个item。 所以，为了让模型了解到可能是存在后面这种bias， 我们就把item的新颖信息， item的位置信息等做成特征， 在模型训练的时候就告诉模型，用户点了这个东西可能是它比较新或者位置比较靠上面等，这样模型在训练的时候， 就了解到了这些bias，等到模型在线推理的时候呢， 我们把这些bias特征都弄成一样的，这样每个样品在模型看来，就没有了新颖信息和位置信息bias(一视同仁了)，只能靠着相关性去推理， 这样才能推到用户真正感兴趣的东西吧。<br><br>而有些文章记录的， 能够推荐更热门的视频啥的， 我很大一个疑问就是推理的时候，不是把example age用0表示吗？ 模型应该不知道这些视频哪个新不新吧。 当然，这是我自己的看法，感兴趣的可以帮我解答下呀。
|
||||
|
||||
`example age`这个特征到这里还没完， 原来加入这种时间bias的传统方法是使用`video age`， 即一个video上传到样本生成的这段时间跨度， 这么说可能有些懵， 看个图吧， 原来这是两个东西:
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/10475c194c0044a3a93b01a3193e294f.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBATWlyYWNsZTgwNzA=,size_1,color_FFFFFF,t_70,g_se,x_16#pic_center" alt="在这里插入图片描述" style="zoom:70%;" />
|
||||
</div>
|
||||
|
||||
王喆老师那篇文章里面也谈到了这两种理解， 对于某个视频的不同样本，其实这两种定义是等价的，因为他们的和是一个常数。
|
||||
$$
|
||||
t_{\text {video age }}+t_{\text {example age }}=\text { Const }
|
||||
$$
|
||||
详细证明可以看参考的第三篇文章。但`example age`的定义有下面两点好处:
|
||||
1. 线上预测时`example age`是常数值， 所有item可以设置成统一的， 但如果是`video age`的话，这个根每个视频的上传时间有关， 那这样在计算用户向量的时候，就依赖每个候选item了。 而统一的这个好处就是用户向量只需要计算一次。
|
||||
2. 对不同的视频，对应的`example age`所在范围一致， 只依赖训练数据选取的时间跨度，便于归一化操作。
|
||||
|
||||
### 实验结果
|
||||
这里就简单过下就好， 作者这里主要验证了下DNN的结构对推荐效果的影响，对于DNN的层级，作者尝试了0~4层， 实验结果是**层数越多越好， 但4层之后提升很有限， 层数越多训练越困难**
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/fd1849a8881444fbb12490bad7598125.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBATWlyYWNsZTgwNzA=,size_1,color_FFFFFF,t_70,g_se,x_16#pic_center" alt="在这里插入图片描述" style="zoom:70%;" />
|
||||
</div>
|
||||
|
||||
作者这里还启发了一个事情， 从"双塔"的角度再看YouTubeDNN召回模型， 这里的DNN个结构，其实就是一个用户塔， 输入用户的特征，最终通过DNN，编码出了用户的embedding向量。
|
||||
|
||||
而得到用户embedding向量到后面做softmax那块，不是说了会经过一个item embedding矩阵吗？ 其实这个矩阵也可以用一个item塔来实现， 和用户embedding计算的方式类似， 首先各个item通过一个物品塔(输入是item 特征， 输出是item embedding)，这样其实也能得到每个item的embedding，然后做多分类或者是二分类等。 所以**YouTubeDNN召回模型本质上还是双塔结构**， 只不过上面图里面值体现了用户塔。 我看deepmatch包里面实现的时候， 用户特征和item特征分开输入的， 感觉应该就是实现了个双塔。源码倒是没看， 等看了之后再确认。
|
||||
|
||||
### 线上服务
|
||||
线上服务的时候， YouTube采用了一种最近邻搜索的方法去完成topK推荐，这其实是工程与学术trade-off的结果， model serving过程中对几百万个候选集一一跑模型显然不现实， 所以通过召回模型得到用户和video的embedding之后， 用最近邻搜索的效率会快很多。
|
||||
|
||||
我们甚至不用把任何model inference的过程搬上服务器，只需要把user embedding和video embedding存到redis或者内存中就好了。like this:
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/86751a834d224ad69220b5040e0e03c9.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBATWlyYWNsZTgwNzA=,size_1,color_FFFFFF,t_70,g_se,x_16#pic_center" alt="在这里插入图片描述" style="zoom:70%;" />
|
||||
</div>
|
||||
|
||||
在线上，可以根据用户兴趣Embedding，采用类似Faiss等高效Embedding检索工具，快速找出和用户兴趣匹配的物品， 高效embedding检索工具， 我目前接触到了两个，一个是Faiss， 一个是annoy， 关于这两个工具的使用， 我也整理了两篇文章:
|
||||
* [annoy(快速近邻向量搜索包)学习小记](https://blog.csdn.net/wuzhongqiang/article/details/122516942?spm=1001.2014.3001.5501)
|
||||
* [Faiss(Facebook开源的高效相似搜索库)学习小记](https://blog.csdn.net/wuzhongqiang/article/details/122516942?spm=1001.2014.3001.5501)
|
||||
|
||||
|
||||
之前写新闻推荐比赛的时候用过Faiss， 这次实验中使用的是annoy工具包。
|
||||
|
||||
另外多整理一点：
|
||||
>我们做线上召回的时候， 其实可以有两种:
|
||||
>1. item_2_item: 因为我们有了所有item的embedding了， 那么就可以进行物品与物品之间相似度计算，每个物品得到近似的K个， 这时候，就和协同过滤原理一样， 之间通过用户观看过的历史item，就能进行相似召回了， 工程实现上，一般会每个item建立一个相似度倒排表
|
||||
>2. user_2_item: 将item用faiss或者annoy组织成index，然后用user embedding去查相近item
|
||||
|
||||
## 基于Deepmatch包YouTubeDNN的使用方法
|
||||
由于时间原因， 我这里并没有自己写代码复现YouTubeDNN模型，这个结构也比较简单， 几层的DNN，自己再写一遍剖析架构也没有啥意思， 所以就采用浅梦大佬写的deepmatch包， 直接用到了自己的数据集上做了实验。 关于Deepmatch源码， 还是看[deepmatch项目](https://github.com/shenweichen/DeepMatch)， 这里主要是整理下YouTubeDNN如何用。
|
||||
|
||||
项目里面其实给出了如何使用YouTubeDNN，采用的是movielens数据集， 见[这里](https://github.com/shenweichen/DeepMatch/blob/master/examples/run_youtubednn.py)
|
||||
|
||||
我这里就基于我做实验用的新闻推荐数据集， 把代码的主要逻辑过一遍。
|
||||
|
||||
### 数据集
|
||||
实验用的数据集是新闻推荐的一个数据集，是做func-rec项目时候一个伙伴分享的，来自于某个推荐比赛，因为这个数据集是来自工业上的真实数据，所以使用起来比之前用的movielens数据集可尝试的东西多一些，并且原数据有8个多G，总共3个文件: 用户画像，文章画像， 点击日志，用户数量100多万，6000多万次点击， 文章规模是几百，数据量也比较丰富，所以后面就打算采用这个统一的数据集， 重新做实验，对比目前GitHub上的各个模型。关于数据集每个文件详细描述，后面会更新到GitHub项目。
|
||||
|
||||
这里只整理我目前的使用过程， 由于有8个多G的数据，我这边没法直接跑，所以对数据进行了采样， 采样方法写成了一个jupyter文件。 主要包括：
|
||||
1. 分块读取数据， 无法一下子读入内存
|
||||
2. 对于每块数据，基于一些筛选规则进行记录的删除，比如只用了后7天的数据， 删除了一些文章不在物料池的数据， 删除不合法的点击记录(曝光时间大于文章上传时间)， 删除没有历史点击的用户，删除观看时间低于3s的视频， 删除历史点击序列太短和太长的用户记录
|
||||
3. 删除完之后重新保存一份新数据集，大约3个G，然后再从这里面随机采样了20000用户进行了后面实验
|
||||
|
||||
通过上面的一波操作， 我的小本子就能跑起来了，当然可能数据比较少，最终训练的YouTubeDNN效果并不是很好。详细看后面GitHub的: `点击日志数据集初步处理与采样.ipynb`
|
||||
|
||||
### 简单数据预处理
|
||||
这个也是写成了一个笔记本， 主要是看了下采样后的数据，序列长度分布等，由于上面做了一些规整化，这里有毛病的数据不是太多，并没有太多处理， 但是用户数据里面的年龄，性别源数据是给出了多种可能， 每个可能有概率值，我这里选出了概率最大的那个，然后简单填充了缺失。
|
||||
|
||||
最后把能用到的用户画像和文章画像统一拼接到了点击日志数据，又保存了一份。 作为YouTubeDNN模型的使用数据， 其他模型我也打算使用这份数据了。
|
||||
|
||||
详见`EDA与数据预处理.ipynb`
|
||||
|
||||
### YouTubeDNN召回
|
||||
这里就需要解释下一些代码了， 首先拿到采样的数据集，我们先划分下训练集和测试集:
|
||||
* 测试集: 每个用户的最后一次点击记录
|
||||
* 训练集: 每个用户除最后一次点击的所有点击记录
|
||||
|
||||
这个具体代码就不在这里写了。
|
||||
|
||||
```python
|
||||
user_click_hist_df, user_click_last_df = get_hist_and_last_click(click_df)
|
||||
```
|
||||
|
||||
这么划分的依据，就是保证不能发生数据穿越，拿最后的测试，不能让模型看到。
|
||||
|
||||
接下来，就是YouTubeDNN模型的召回，从构造数据集 -> 训练模型 -> 产生召回结果，我写到了一个函数里面去。
|
||||
|
||||
```cpp
|
||||
def youtubednn_recall(data, topk=200, embedding_dim=8, his_seq_maxlen=50, negsample=0,
|
||||
batch_size=64, epochs=1, verbose=1, validation_split=0.0):
|
||||
"""通过YouTubeDNN模型，计算用户向量和文章向量
|
||||
param: data: 用户日志数据
|
||||
topk: 对于每个用户，召回多少篇文章
|
||||
"""
|
||||
user_id_raw = data[['user_id']].drop_duplicates('user_id')
|
||||
doc_id_raw = data[['article_id']].drop_duplicates('article_id')
|
||||
|
||||
# 类别数据编码
|
||||
base_features = ['user_id', 'article_id', 'city', 'age', 'gender']
|
||||
feature_max_idx = {}
|
||||
for f in base_features:
|
||||
lbe = LabelEncoder()
|
||||
data[f] = lbe.fit_transform(data[f])
|
||||
feature_max_idx[f] = data[f].max() + 1
|
||||
|
||||
# 构建用户id词典和doc的id词典，方便从用户idx找到原始的id
|
||||
user_id_enc = data[['user_id']].drop_duplicates('user_id')
|
||||
doc_id_enc = data[['article_id']].drop_duplicates('article_id')
|
||||
user_idx_2_rawid = dict(zip(user_id_enc['user_id'], user_id_raw['user_id']))
|
||||
doc_idx_2_rawid = dict(zip(doc_id_enc['article_id'], doc_id_raw['article_id']))
|
||||
|
||||
# 保存下每篇文章的被点击数量， 方便后面高热文章的打压
|
||||
doc_clicked_count_df = data.groupby('article_id')['click'].apply(lambda x: x.count()).reset_index()
|
||||
doc_clicked_count_dict = dict(zip(doc_clicked_count_df['article_id'], doc_clicked_count_df['click']))
|
||||
|
||||
train_set, test_set = gen_data_set(data, doc_clicked_count_dict, negsample, control_users=True)
|
||||
|
||||
# 构造youtubeDNN模型的输入
|
||||
train_model_input, train_label = gen_model_input(train_set, his_seq_maxlen)
|
||||
test_model_input, test_label = gen_model_input(test_set, his_seq_maxlen)
|
||||
|
||||
# 构建模型并完成训练
|
||||
model = train_youtube_model(train_model_input, train_label, embedding_dim, feature_max_idx, his_seq_maxlen, batch_size, epochs, verbose, validation_split)
|
||||
|
||||
# 获得用户embedding和doc的embedding， 并进行保存
|
||||
user_embs, doc_embs = get_embeddings(model, test_model_input, user_idx_2_rawid, doc_idx_2_rawid)
|
||||
|
||||
# 对每个用户，拿到召回结果并返回回来
|
||||
user_recall_doc_dict = get_youtube_recall_res(user_embs, doc_embs, user_idx_2_rawid, doc_idx_2_rawid, topk)
|
||||
|
||||
return user_recall_doc_dict
|
||||
```
|
||||
这里面说一下主要逻辑，主要是下面几步:
|
||||
1. 用户id和文章id我们要先建立索引-原始id的字典，因为我们模型里面是要把id转成embedding，模型的表示形式会是{索引: embedding}的形式， 如果我们想得到原始id，必须先建立起映射来
|
||||
2. 把类别特征进行label Encoder， 模型输入需要， embedding层需要，这是构建词典常规操作， 这里要记录下每个特征特征值的个数，建词典索引的时候用到，得知道词典大小
|
||||
3. 保存了下每篇文章被点击数量， 方便后面对高热文章实施打压
|
||||
4. 构建数据集
|
||||
|
||||
```python
|
||||
rain_set, test_set = gen_data_set(data, doc_clicked_count_dict, negsample, control_users=True)
|
||||
```
|
||||
这个需要解释下， 虽然我们上面有了一个训练集，但是这个东西是不能直接作为模型输入的， 第一个原因是正样本太少，样本数量不足，我们得需要滑动窗口，每个用户再滑动构造一些，第二个是不满足deepmatch实现的模型输入格式，所以gen_data_set这个函数，是用deepmatch YouTubeDNN的第一个范式，基本上得按照这个来，只不过我加了一些策略上的尝试:
|
||||
```python
|
||||
def gen_data_set(click_data, doc_clicked_count_dict, negsample, control_users=False):
|
||||
"""构造youtubeDNN的数据集"""
|
||||
# 按照曝光时间排序
|
||||
click_data.sort_values("expo_time", inplace=True)
|
||||
item_ids = click_data['article_id'].unique()
|
||||
|
||||
train_set, test_set = [], []
|
||||
for user_id, hist_click in tqdm(click_data.groupby('user_id')):
|
||||
# 这里按照expo_date分开，每一天用滑动窗口滑，可能相关性更高些,另外，这样序列不会太长，因为eda发现有点击1111个的
|
||||
#for expo_date, hist_click in hist_date_click.groupby('expo_date'):
|
||||
# 用户当天的点击历史id
|
||||
pos_list = hist_click['article_id'].tolist()
|
||||
user_control_flag = True
|
||||
|
||||
if control_users:
|
||||
user_samples_cou = 0
|
||||
|
||||
# 过长的序列截断
|
||||
if len(pos_list) > 50:
|
||||
pos_list = pos_list[-50:]
|
||||
|
||||
if negsample > 0:
|
||||
neg_list = gen_neg_sample_candiate(pos_list, item_ids, doc_clicked_count_dict, negsample, methods='multinomial')
|
||||
|
||||
# 只有1个的也截断 去掉，当然我之前做了处理，这里没有这种情况了
|
||||
if len(pos_list) < 2:
|
||||
continue
|
||||
else:
|
||||
# 序列至少是2
|
||||
for i in range(1, len(pos_list)):
|
||||
hist = pos_list[:i]
|
||||
# 这里采用打压热门item策略，降低高展item成为正样本的概率
|
||||
freq_i = doc_clicked_count_dict[pos_list[i]] / (np.sum(list(doc_clicked_count_dict.values())))
|
||||
p_posi = (np.sqrt(freq_i/0.001)+1)*(0.001/freq_i)
|
||||
|
||||
# p_posi=0.3 表示该item_i成为正样本的概率是0.3，
|
||||
if user_control_flag and i != len(pos_list) - 1:
|
||||
if random.random() > (1-p_posi):
|
||||
row = [user_id, hist[::-1], pos_list[i], hist_click.iloc[0]['city'], hist_click.iloc[0]['age'], hist_click.iloc[0]['gender'], hist_click.iloc[i]['example_age'], 1, len(hist[::-1])]
|
||||
train_set.append(row)
|
||||
|
||||
for negi in range(negsample):
|
||||
row = [user_id, hist[::-1], neg_list[i*negsample+negi], hist_click.iloc[0]['city'], hist_click.iloc[0]['age'], hist_click.iloc[0]['gender'], hist_click.iloc[i]['example_age'], 0, len(hist[::-1])]
|
||||
train_set.append(row)
|
||||
|
||||
if control_users:
|
||||
user_samples_cou += 1
|
||||
# 每个用户序列最长是50， 即每个用户正样本个数最多是50个, 如果每个用户训练样本数量到了30个，训练集不能加这个用户了
|
||||
if user_samples_cou > 30:
|
||||
user_samples_cou = False
|
||||
|
||||
# 整个序列加入到test_set， 注意，这里一定每个用户只有一个最长序列，相当于测试集数目等于用户个数
|
||||
elif i == len(pos_list) - 1:
|
||||
row = [user_id, hist[::-1], pos_list[i], hist_click.iloc[0]['city'], hist_click.iloc[0]['age'], hist_click.iloc[0]['gender'], 0, 0, len(hist[::-1])]
|
||||
test_set.append(row)
|
||||
|
||||
|
||||
random.shuffle(train_set)
|
||||
random.shuffle(test_set)
|
||||
|
||||
return train_set, test_set
|
||||
```
|
||||
关键代码逻辑是首先点击数据按照时间戳排序，然后按照用户分组，对于每个用户的历史点击， 采用滑动窗口的形式，边滑动边构造样本， 第一个注意的地方，是每滑动一次生成一条正样本的时候， 要加入一定比例的负样本进去， 第二个注意最后一整条序列要放到test_set里面。<br><br>我这里面加入的一些策略，负样本候选集生成我单独写成一个函数，因为尝试了随机采样和打压热门item采样两种方式， 可以通过methods参数选择。 另外一个就是正样本里面也按照热门实现了打压， 减少高热item成为正样本概率，增加高热item成为负样本概率。 还加了一个控制用户样本数量的参数，去保证每个用户生成一样多的样本数量，打压下高活用户。
|
||||
5. 构造模型输入
|
||||
这个也是调包的定式操作，必须按照这个写法来:
|
||||
|
||||
|
||||
```python
|
||||
def gen_model_input(train_set, his_seq_max_len):
|
||||
"""构造模型的输入"""
|
||||
# row: [user_id, hist_list, cur_doc_id, city, age, gender, label, hist_len]
|
||||
train_uid = np.array([row[0] for row in train_set])
|
||||
train_hist_seq = [row[1] for row in train_set]
|
||||
train_iid = np.array([row[2] for row in train_set])
|
||||
train_u_city = np.array([row[3] for row in train_set])
|
||||
train_u_age = np.array([row[4] for row in train_set])
|
||||
train_u_gender = np.array([row[5] for row in train_set])
|
||||
train_u_example_age = np.array([row[6] for row in train_set])
|
||||
train_label = np.array([row[7] for row in train_set])
|
||||
train_hist_len = np.array([row[8] for row in train_set])
|
||||
|
||||
train_seq_pad = pad_sequences(train_hist_seq, maxlen=his_seq_max_len, padding='post', truncating='post', value=0)
|
||||
train_model_input = {
|
||||
"user_id": train_uid,
|
||||
"click_doc_id": train_iid,
|
||||
"hist_doc_ids": train_seq_pad,
|
||||
"hist_len": train_hist_len,
|
||||
"u_city": train_u_city,
|
||||
"u_age": train_u_age,
|
||||
"u_gender": train_u_gender,
|
||||
"u_example_age":train_u_example_age
|
||||
}
|
||||
return train_model_input, train_label
|
||||
```
|
||||
上面构造数据集的时候，是把每个特征加入到了二维数组里面去， 这里得告诉模型，每一个维度是啥特征数据。如果相加特征，首先构造数据集的时候，得把数据加入到数组中， 然后在这个函数里面再指定新加入的特征是啥。 下面的那个词典， 是为了把数据输入和模型的Input层给对应起来，通过字典键进行标识。
|
||||
6. 训练YouTubeDNN
|
||||
这一块也是定式， 在建模型事情，要把特征封装起来，告诉模型哪些是离散特征，哪些是连续特征， 模型要为这些特征建立不同的Input层，处理方式是不一样的
|
||||
|
||||
```python
|
||||
def train_youtube_model(train_model_input, train_label, embedding_dim, feature_max_idx, his_seq_maxlen, batch_size, epochs, verbose, validation_split):
|
||||
"""构建youtubednn并完成训练"""
|
||||
# 特征封装
|
||||
user_feature_columns = [
|
||||
SparseFeat('user_id', feature_max_idx['user_id'], embedding_dim),
|
||||
VarLenSparseFeat(SparseFeat('hist_doc_ids', feature_max_idx['article_id'], embedding_dim,
|
||||
embedding_name="click_doc_id"), his_seq_maxlen, 'mean', 'hist_len'),
|
||||
|
||||
SparseFeat('u_city', feature_max_idx['city'], embedding_dim),
|
||||
SparseFeat('u_age', feature_max_idx['age'], embedding_dim),
|
||||
SparseFeat('u_gender', feature_max_idx['gender'], embedding_dim),
|
||||
DenseFeat('u_example_age', 1,)
|
||||
]
|
||||
doc_feature_columns = [
|
||||
SparseFeat('click_doc_id', feature_max_idx['article_id'], embedding_dim)
|
||||
# 这里后面也可以把文章的类别画像特征加入
|
||||
]
|
||||
|
||||
# 定义模型
|
||||
model = YoutubeDNN(user_feature_columns, doc_feature_columns, num_sampled=5, user_dnn_hidden_units=(64, embedding_dim))
|
||||
|
||||
# 模型编译
|
||||
model.compile(optimizer="adam", loss=sampledsoftmaxloss)
|
||||
|
||||
# 模型训练，这里可以定义验证集的比例，如果设置为0的话就是全量数据直接进行训练
|
||||
history = model.fit(train_model_input, train_label, batch_size=batch_size, epochs=epochs, verbose=verbose, validation_split=validation_split)
|
||||
|
||||
return model
|
||||
```
|
||||
然后就是建模型，编译训练即可。这块就非常简单了，当然模型方面有些参数，可以了解下，另外一个注意点，就是这里用户特征和item特征进行了分开， 这其实和双塔模式很像， 用户特征最后编码成用户向量， item特征最后编码成item向量。
|
||||
7. 获得用户向量和item向量
|
||||
模型训练完之后，就能从模型里面拿用户向量和item向量， 我这里单独写了一个函数:
|
||||
|
||||
```python
|
||||
获取用户embedding和文章embedding
|
||||
def get_embeddings(model, test_model_input, user_idx_2_rawid, doc_idx_2_rawid, save_path='embedding/'):
|
||||
doc_model_input = {'click_doc_id':np.array(list(doc_idx_2_rawid.keys()))}
|
||||
|
||||
user_embedding_model = Model(inputs=model.user_input, outputs=model.user_embedding)
|
||||
doc_embedding_model = Model(inputs=model.item_input, outputs=model.item_embedding)
|
||||
|
||||
# 保存当前的item_embedding 和 user_embedding 排序的时候可能能够用到，但是需要注意保存的时候需要和原始的id对应
|
||||
user_embs = user_embedding_model.predict(test_model_input, batch_size=2 ** 12)
|
||||
doc_embs = doc_embedding_model.predict(doc_model_input, batch_size=2 ** 12)
|
||||
# embedding保存之前归一化一下
|
||||
user_embs = user_embs / np.linalg.norm(user_embs, axis=1, keepdims=True)
|
||||
doc_embs = doc_embs / np.linalg.norm(doc_embs, axis=1, keepdims=True)
|
||||
|
||||
# 将Embedding转换成字典的形式方便查询
|
||||
raw_user_id_emb_dict = {user_idx_2_rawid[k]: \
|
||||
v for k, v in zip(user_idx_2_rawid.keys(), user_embs)}
|
||||
raw_doc_id_emb_dict = {doc_idx_2_rawid[k]: \
|
||||
v for k, v in zip(doc_idx_2_rawid.keys(), doc_embs)}
|
||||
# 将Embedding保存到本地
|
||||
pickle.dump(raw_user_id_emb_dict, open(save_path + 'user_youtube_emb.pkl', 'wb'))
|
||||
pickle.dump(raw_doc_id_emb_dict, open(save_path + 'doc_youtube_emb.pkl', 'wb'))
|
||||
|
||||
# 读取
|
||||
#user_embs_dict = pickle.load(open('embedding/user_youtube_emb.pkl', 'rb'))
|
||||
#doc_embs_dict = pickle.load(open('embedding/doc_youtube_emb.pkl', 'rb'))
|
||||
return user_embs, doc_embs
|
||||
```
|
||||
获取embedding的这两行代码是固定操作， 下面做了一些归一化操作，以及把索引转成了原始id的形式。
|
||||
8. 向量最近邻检索，为每个用户召回相似item
|
||||
|
||||
```python
|
||||
def get_youtube_recall_res(user_embs, doc_embs, user_idx_2_rawid, doc_idx_2_rawid, topk):
|
||||
"""近邻检索，这里用annoy tree"""
|
||||
# 把doc_embs构建成索引树
|
||||
f = user_embs.shape[1]
|
||||
t = AnnoyIndex(f, 'angular')
|
||||
for i, v in enumerate(doc_embs):
|
||||
t.add_item(i, v)
|
||||
t.build(10)
|
||||
# 可以保存该索引树 t.save('annoy.ann')
|
||||
|
||||
# 每个用户向量， 返回最近的TopK个item
|
||||
user_recall_items_dict = collections.defaultdict(dict)
|
||||
for i, u in enumerate(user_embs):
|
||||
recall_doc_scores = t.get_nns_by_vector(u, topk, include_distances=True)
|
||||
# recall_doc_scores是(([doc_idx], [scores]))， 这里需要转成原始doc的id
|
||||
raw_doc_scores = list(recall_doc_scores)
|
||||
raw_doc_scores[0] = [doc_idx_2_rawid[i] for i in raw_doc_scores[0]]
|
||||
# 转换成实际用户id
|
||||
try:
|
||||
user_recall_items_dict[user_idx_2_rawid[i]] = dict(zip(*raw_doc_scores))
|
||||
except:
|
||||
continue
|
||||
|
||||
# 默认是分数从小到大排的序， 这里要从大到小
|
||||
user_recall_items_dict = {k: sorted(v.items(), key=lambda x: x[1], reverse=True) for k, v in user_recall_items_dict.items()}
|
||||
|
||||
# 保存一份
|
||||
pickle.dump(user_recall_items_dict, open('youtube_u2i_dict.pkl', 'wb'))
|
||||
|
||||
return user_recall_items_dict
|
||||
```
|
||||
用了用户embedding和item向量，就可以通过这个函数进行检索， 这块主要是annoy包做近邻检索的固定格式， 检索完毕，为用户生成最相似的200个候选item。
|
||||
|
||||
以上，就是使用YouTubeDNN做召回的整个流程。 效果如下:
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/e904362d28fd4bdbacb5715ff2abaac2.png#pic_center" alt="在这里插入图片描述" style="zoom:70%;" />
|
||||
</div>
|
||||
|
||||
这个字典长这样:
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/840e3abaf30845499f0926c61ba88635.png#pic_center" alt="在这里插入图片描述" style="zoom:70%;" />
|
||||
</div>
|
||||
|
||||
接下来就是评估模型的效果，这里我采用了简单的HR@N计算的， 具体代码看GitHub吧， 结果如下:
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/eb6ccadaa98e46bd87e594ee11e957a7.png#pic_center" alt="在这里插入图片描述" style="zoom:70%;" />
|
||||
</div>
|
||||
|
||||
结果不怎么样啊，唉， 难道是数据量太少了？ 总归是跑起来且能用了。
|
||||
|
||||
详细代码见尾部GitHub链接吧， 硬件设施到位的可以尝试多用一些数据试试看哈哈。
|
||||
|
||||
## YouTubeDNN新闻推荐数据集的实验记录
|
||||
这块就比较简单了，简单的整理下我用上面代码做个的实验，尝试了论文里面的几个点，记录下:
|
||||
1. 负采样方式上，尝试了随机负采样和打压高热item两种方式， 从我的实验结果上来看， 带打压的效果略好一点点
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/7cf27f1b849049f0b4bd98d0ebb7925f.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBATWlyYWNsZTgwNzA=,size_1,color_FFFFFF,t_70,g_se,x_16#pic_center" alt="在这里插入图片描述" style="zoom:70%;" />
|
||||
</div>
|
||||
|
||||
2. 特征上， 尝试原论文给出的example age的方式，做一个样本的年龄特征出来
|
||||
这个年龄样本，我是用的训练集的最大时间减去曝光的时间，然后转成小时间隔算的，而测试集里面的统一用0表示， 但效果好差。 看好多文章说这个时间单位是个坑，不知道是小时，分钟，另外这个特征我只做了简单归一化，感觉应该需要做归一化
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/1ea482f538c94b8bb07a69023b14ca9b.png#pic_center" alt="在这里插入图片描述" style="zoom:70%;" />
|
||||
</div>
|
||||
3. 尝试了控制用户数量，即每个用户的样本数量保持一样，效果比上面略差
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/8653b76d0b434d1088da196ce94bb954.png#pic_center" alt="在这里插入图片描述" style="zoom:70%;" />
|
||||
</div>
|
||||
4. 开始模型评估，我尝试用最后一天的，而不是最后一次点击的， 感觉效果不如最后一次点击作为测试集效果好
|
||||
|
||||
当然，上面实验并没有太大说服力，第一个是我采样的数据量太少，模型本身训练的不怎么样，第二个这些策略相差的并不是很大， 可能有偶然性。
|
||||
|
||||
并且我这边做一次实验，要花费好长时间，探索就先到这里吧， example age那个确实是个迷， 其他的感觉起来， 打压高活效果要比不打压要好。
|
||||
|
||||
另外要记录下学习小tricks:
|
||||
> 跑一次这样的实验，我这边一般会花费两个小时左右的时间， 而这个时间在做实验之前，一定要做规划才能好好的利用起来， 比如，我计划明天上午要开始尝试各种策略做实验， 今天晚上的todo里面，就要记录好， 我会尝试哪些策略，记录一个表， 调整策略，跑模型的时候，我这段空档要干什么事情， todo里面都要记录好，比如我这段空档就是解读这篇paper，写完这篇博客，基本上是所有实验做完，我这篇博客也差不多写完，正好，哈哈<br><br>这个空档利用，一定要提前在todo里面写好，而不是跑模型的时候再想，这个时候往往啥也干不下去，并且还会时不时的看模型跑，或者盯着进度条发呆，那这段时间就有些浪费了呀，即使这段时间不学习，看个久违的电视剧， 久违的书，或者keep下不香吗哈哈， 但得提前规划。<br><br>可能每个人习惯不一样，对于我，是这样哈，所以记录下 ;)
|
||||
|
||||
## 总结
|
||||
|
||||
由于这篇文章里面的工程经验太多啦，我前面介绍的时候，可能涉及到知识的一些扩展补充，把经验整理的比较凌乱，这里再统一整理下， 这些也都是工业界常用的一些经验了:
|
||||
|
||||
召回部分:
|
||||
1. 训练数据的样本来源应该是全部物料， 而不仅仅是被推荐的物料，否则对于新物料难以曝光
|
||||
2. 训练数据中对于每个用户选取相同的样本数， 保证用户在损失函数等权重， 这个虽然不一定非得这么做，但考虑打压高活用户或者是高活item的影响还是必须的
|
||||
3. 序列无序化: 用户的最近一次搜索与搜索之后的播放行为有很强关联，为了避免信息泄露，将搜索行为顺序打乱。
|
||||
4. 训练数据构造: 预测接下来播放而不是用传统cbow中的两侧预测中间的考虑是可以防止信息泄露，并且可以学习到用户的非对称视频消费模式
|
||||
5. 召回模型中，类似word2vec，video 有input embedding和output embedding两组embedding，并不是共享的， input embedding论文里面是用w2v事先训练好的， 其实也可以用embedding层联合训练
|
||||
6. 召回模型的用户embedding来自网络输出， 而video的embedding往往用后面output处的
|
||||
7. 使用 `example age` 特征处理 time bias，这样线上检索时可以预先计算好用户向量
|
||||
|
||||
|
||||
**参考资料**：
|
||||
* [重读Youtube深度学习推荐系统论文](https://zhuanlan.zhihu.com/p/52169807)
|
||||
* [YouTube深度学习推荐系统的十大工程问题](https://zhuanlan.zhihu.com/p/52169807)
|
||||
* [你真的读懂了Youtube DNN推荐论文吗](https://zhuanlan.zhihu.com/p/372238343)
|
||||
* [推荐系统经典论文(二)】YouTube DNN](https://zhuanlan.zhihu.com/p/128597084)
|
||||
* [张俊林-推荐技术发展趋势与召回模型](https://www.icode9.com/content-4-764359.html)
|
||||
* [揭开YouTube深度推荐系统模型Serving之谜](https://zhuanlan.zhihu.com/p/61827629)
|
||||
* [Deep Neural Networks for YouTube Recommendations YouTubeDNN推荐召回与排序](https://www.pianshen.com/article/82351182400/)
|
||||
308
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.2/YoutubeTwoTower.md
Normal file
308
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.2/YoutubeTwoTower.md
Normal file
@@ -0,0 +1,308 @@
|
||||
# 背景介绍
|
||||
|
||||
**文章核心思想**
|
||||
|
||||
+ 在大规模的推荐系统中，利用双塔模型对user-item对的交互关系进行建模，学习 $\{user，context\}$ 向量与 $\{item\}$ 向量.
|
||||
+ 针对大规模流数据，提出in-batch softmax损失函数与流数据频率估计方法(Streaming Frequency Estimation)，可以更好的适应item的多种数据分布。
|
||||
|
||||
**文章主要贡献**
|
||||
|
||||
+ 提出了改进的流数据频率估计方法：针对流数据来估计item出现的频率，利用实验分析估计结果的偏差与方差，模拟实验证明该方法在数据动态变化时的功效
|
||||
|
||||
+ 提出了双塔模型架构：提供了一个针对大规模的检索推荐系统，包括了 in-batch softmax 损失函数与流数据频率估计方法，减少了负采样在每个batch中可能会出现的采样偏差问题。
|
||||
|
||||
# 算法原理
|
||||
|
||||
给定一个查询集 $Query: \left\{x_{i}\right\}_{i=1}^{N}$ 和一个物品集$Item:\left\{y_{j}\right\}_{j=1}^{M}$。
|
||||
|
||||
+ $x_{i} \in X,\quad y_{j} \in \mathcal{Y}$ 是由多种特征（例如：稀疏ID和 Dense 特征）组成的高维混合体。
|
||||
|
||||
+ 推荐的目标是对于给定一个 $query$，检索到一系列 $item$ 子集用于后续排序推荐任务。
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/%E5%9B%BE%E7%89%87image-20220506202824884.png" alt="image-20220506202824884" style="zoom:50%;" />
|
||||
|
||||
## 模型目标
|
||||
|
||||
模型结构如上图所示，论文旨在对用户和物品建立两个不同的模型，将它们投影到相同维度的空间：
|
||||
$$
|
||||
u: X \times \mathbb{R}^{d} \rightarrow \mathbb{R}^{k}, v: y \times \mathbb{R}^{d} \rightarrow \mathbb{R}^{k}
|
||||
$$
|
||||
|
||||
模型的输出为用户与物品向量的内积：
|
||||
|
||||
$$
|
||||
s(x, y)=\langle u(x, \theta), v(y, \theta)\rangle
|
||||
$$
|
||||
|
||||
模型的目标是为了学习参数 $\theta$， 样本集被表示为如下格式 $\{query, item, reward \}$：
|
||||
|
||||
$$
|
||||
\mathcal{T}:=\left\{\left(x_{i}, y_{i}, r_{i}\right)\right\}_{i=1}^{T}
|
||||
$$
|
||||
|
||||
* 在推荐系统中，$r_i$ 可以扩展来捕获用户对不同候选物品的参与度。
|
||||
* 例如，在新闻推荐中 $r_i$ 可以是用户在某篇文章上花费的时间。
|
||||
|
||||
## 模型流程
|
||||
|
||||
1. 给定用户 $x$，基于 softmax 函数从物料库 $M$ 中选中候选物品 $y$ 的概率为：
|
||||
$$
|
||||
\mathcal{P}(y \mid x ; \theta)=\frac{e^{s(x, y)}}{\sum_{j \in[M]} e^{s\left(x, y_{j}\right)}}
|
||||
$$
|
||||
|
||||
* 考虑到相关奖励 $r_i$ ，加权对数似然函数的定义如下：
|
||||
|
||||
$$
|
||||
L_{T}(\theta):=-\frac{1}{T} \sum_{i \in[T]} r_{i} \cdot \log \left(\mathcal{P}\left(y_{i} \mid x_{i} ; \theta\right)\right)
|
||||
$$
|
||||
|
||||
2. 原表达式 $\mathcal{P}(y \mid x ; \theta)$ 中的分母需要遍历物料库中所有的物品，计算成本太高，故对分母中的物品要进行负采样。为了提高负采样的速度，一般是直接从训练样本所在 Batch 中进行负样本选择。于是有：
|
||||
$$
|
||||
\mathcal{P}_{B}\left(y_{i} \mid x_{i} ; \theta\right)=\frac{e^{s\left(x_{i}, y_{i}\right)}}{\sum_{j \in[B]} e^{s\left(x_{i}, y_{j}\right)}}
|
||||
$$
|
||||
|
||||
* 其中，$B$ 表示与样本 $\{x_i,y_j\}$ 同在一个 Batch 的物品集合。
|
||||
* 举例来说，对于用户1，Batch 内其他用户的正样本是用户1的负样本。
|
||||
|
||||
3. 一般而言，负采样分为 Easy Negative Sample 和 Hard Negative Sample。
|
||||
|
||||
+ 这里的 Easy Negative Sample 一般是直接从全局物料库中随机选取的负样本，由于每个用户感兴趣的物品有限，而物料库又往往很大，故即便从物料库中随机选取负样本，也大概率是用户不感兴趣的。
|
||||
|
||||
+ 在真实场景中，热门物品占据了绝大多数的购买点击。而这些热门物品往往只占据物料库物品的少部分，绝大部分物品是冷门物品。
|
||||
|
||||
+ 在物料库中随机选择负样本，往往被选中的是冷门物品。这就会造成马太效应，热门物品更热，冷门物品更冷。
|
||||
+ 一种解决方式时，在对训练样本进行负采样时，提高热门物品被选为负样本的概率，工业界的经验做法是物品被选为负样本的概率正比于物品点击次数的 0.75 次幂。
|
||||
|
||||
+ 前面提到 Batch 内进行负采样，热门物品出现在一个 Batch 的概率正比于它的点击次数。问题是，热门物品被选为负样本的概率过高了（一般正比于点击次数的 0.75 次幂），导致热门物品被过度打压。
|
||||
|
||||
+ 在本文中，为了避免对热门物品进行过度惩罚，进行了纠偏。公式如下：
|
||||
$$
|
||||
s^{c}\left(x_{i}, y_{j}\right)=s\left(x_{i}, y_{j}\right)-\log \left(p_{j}\right)
|
||||
$$
|
||||
|
||||
+ 在内积 $s(x_i,y_j)$ 的基础上，减去了物品 $j$ 的采样概率的对数。
|
||||
|
||||
4. 纠偏后，物品 $y$ 被选中的概率为：
|
||||
$$
|
||||
\mathcal{P}_{B}^{c}\left(y_{i} \mid x_{i} ; \theta\right)=\frac{e^{s^{c}\left(x_{i}, y_{i}\right)}}{e^{s^{c}\left(x_{i}, y_{i}\right)}+\sum_{j \in[B], j \neq i} e^{s^{c}\left(x_{i}, y_{j}\right)}}
|
||||
$$
|
||||
|
||||
+ 此时，batch loss function 的表示式如下：
|
||||
|
||||
$$
|
||||
L_{B}(\theta):=-\frac{1}{B} \sum_{i \in[B]} r_{i} \cdot \log \left(\mathcal{P}_{B}^{c}\left(y_{i} \mid x_{i} ; \theta\right)\right)
|
||||
$$
|
||||
+ 通过 SGD 和学习率，来优化模型参数 $\theta$ ：
|
||||
|
||||
$$
|
||||
\theta \leftarrow \theta-\gamma \cdot \nabla L_{B}(\theta)
|
||||
$$
|
||||
|
||||
5. Normalization and Temperature
|
||||
|
||||
* 最后一层，得到用户和物品的特征 Embedding 表示后，再进行进行 $l2$ 归一化：
|
||||
$$
|
||||
\begin{aligned}
|
||||
u(x, \theta) \leftarrow u(x, \theta) /\|u(x, \theta)\|_{2}
|
||||
\\
|
||||
v(y, \theta) \leftarrow v(y, \theta) /\|v(y, \theta)\|_{2}
|
||||
|
||||
\end{aligned}
|
||||
$$
|
||||
|
||||
+ 本质上，其实就是将用户和物品的向量内积转换为了余弦相似度。
|
||||
|
||||
* 对于内积的结果，再除以温度参数 $\tau$：
|
||||
$$
|
||||
s(x, y)=\langle u(x, \theta), v(y, \theta)\rangle / \tau
|
||||
$$
|
||||
|
||||
+ 论文提到，这样有利于提高预测准确度。
|
||||
+ 从实验结果来看，温度参数 $\tau$ 一般小于 $1$，所以感觉就是放大了内积结果。
|
||||
|
||||
**上述模型训练过程可以归纳为：**
|
||||
|
||||
（1）从实时数据流中采样得到一个 batch 的训练样本。
|
||||
|
||||
（2）基于流频估计法，估算物品 $y_i$ 的采样概率 $p_i$ 。
|
||||
|
||||
（3）计算损失函数 $L_B$ ，再利用 SGD 方法更新参数。
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/%E5%9B%BE%E7%89%87image-20220506211935092.png" alt="image-20220506211935092" style="zoom: 50%;" />
|
||||
|
||||
## 流频估计算法
|
||||
|
||||
考虑一个随机的数据 batch ，每个 batch 中包含一组物品。现在的问题是如何估计一个 batch 中物品 $y$ 的命中概率。具体方法如下：
|
||||
|
||||
+ 利用全局步长，将对物品采样频率 $p$ 转换为 对 $\delta$ 的估计，其中 $\delta$ 表示连续两次采样物品之间的平均步数。
|
||||
+ 例如，某物品平均 50 个步后会被采样到，那么采样频率 $p=1/\delta=0.02$ 。
|
||||
|
||||
**具体的实现方法为：**
|
||||
|
||||
1. 建立两个大小为 $H$ 的数组 $A,B$ 。
|
||||
|
||||
2. 通过哈希函数 $h(\cdot)$ 可以把每个物品映射为 $[H]$ 范围内的整数。
|
||||
|
||||
+ 映射的内容可以是 ID 或者其他的简单特征值。
|
||||
|
||||
+ 对于给定的物品 $y$，哈希后的整数记为 $h(y)$，本质上它表示物品 $y$ 在数组中的序号。
|
||||
|
||||
3. 数组 $A$ 中存放的 $A[h(y)]$ 表示物品 $y$ 上次被采样的时间， 数组 $B$ 中存放的 $B[h(y)]$ 表示物品 $y$ 的全局步长。
|
||||
|
||||
+ 假设在第 $t$ 步时采样到物品 $y$，则 $A[h(y)]$ 和 $B[h(y)]$ 的更新公式为：
|
||||
$$
|
||||
B[h(y)] \leftarrow(1-\alpha) \cdot B[h(y)]+\alpha \cdot(t-A[h(y)])
|
||||
$$
|
||||
|
||||
+ 在$B$ 被更新后，将 $t$ 赋值给 $A[h(y)]$ 。
|
||||
|
||||
4. 对整个batch数据采样后，取数组 $B$ 中 $B[h(y)]$ 的倒数，作为物品 $y$ 的采样频率，即：
|
||||
$$
|
||||
\hat{p}=1 / B[h(y)]
|
||||
$$
|
||||
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/%E5%9B%BE%E7%89%87image-20220506220529932.png" alt="image-20220506220529932" style="zoom:50%;" />
|
||||
|
||||
**从数学理论上证明这种迭代更新的有效性：**
|
||||
|
||||
假设物品 $y$ 被采样到的时间间隔序列为 $\Delta=\left\{\Delta_{1}, \ldots, \Delta_{t}\right\}$ 满足独立同分布，这个随机变量的均值为$\delta=E[\Delta]$。对于每一次采样迭代：$\delta_{i}=(1-\alpha) \delta_{i-1}+\alpha \Delta_{i}$，可以证明时间间隔序列的均值和方差满足：
|
||||
|
||||
$$
|
||||
\begin{aligned}
|
||||
& E\left(\delta_{t}\right)-\delta=(1-\alpha)^{t} \delta_{0}-(1-\alpha)^{t-1} \delta
|
||||
\\ \\
|
||||
& E\left[\left(\delta_{t}-E\left[\delta_{t}\right]\right)^{2}\right] \leq(1-\alpha)^{2 t}\left(\delta_{0}-\delta\right)^{2}+\alpha E\left[\left(\Delta_{1}-\alpha\right)^{2}\right]
|
||||
\end{aligned}
|
||||
$$
|
||||
|
||||
1. **对于均值的证明：**
|
||||
$$
|
||||
\begin{aligned}
|
||||
E\left[\delta_{t}\right] &=(1-\alpha) E\left[\delta_{t-1}\right]+\alpha \delta \\
|
||||
&=(1-\alpha)\left[(1-\alpha) E\left[\delta_{t-2}\right]+\alpha \delta\right]+\alpha \delta \\
|
||||
&=(1-\alpha)^{2} E\left[\delta_{t-2}\right]+\left[(1-\alpha)^{1}+(1-\alpha)^{0}\right] \alpha \delta \\
|
||||
&=(1-\alpha)^{3} E\left[\delta_{t-3}\right]+\left[(1-\alpha)^{2}+(1-\alpha)^{1}+(1-\alpha)^{0}\right] \alpha \delta \\
|
||||
&=\ldots \ldots \\
|
||||
&=(1-\alpha)^{t} \delta_{0}+\left[(1-\alpha)^{t-1}+\ldots+(1-\alpha)^{1}+(1-\alpha)^{0}\right] \alpha \delta \\
|
||||
&=(1-\alpha)^{t} \delta_{0}+\left[1-(1-\alpha)^{t-1}\right] \delta
|
||||
\end{aligned}
|
||||
$$
|
||||
|
||||
+ 根据均值公式可以看出：$t \rightarrow \infty \text { 时， }\left|E\left[\delta_{t}\right]-\delta\right| \rightarrow 0 $ 。
|
||||
+ 即当采样数据足够多的时候，数组 $B$ (每多少步采样一次)趋于真实采样频率。
|
||||
+ 因此递推式合理，且当初始值 $\delta_{0}=\delta /(1-\alpha)$，递推式为无偏估计。
|
||||
|
||||
2. **对于方差的证明：**
|
||||
$$
|
||||
\begin{aligned}
|
||||
E\left[\left(\delta_{t}-E\left[\delta_{t}\right]\right)^{2}\right] &=E\left[\left(\delta_{t}-\delta+\delta-E\left[\delta_{t}\right]\right)^{2}\right] \\
|
||||
&=E\left[\left(\delta_{t}-\delta\right)^{2}\right]+2 E\left[\left(\delta_{t}-\delta\right)\left(\delta-E\left[\delta_{t}\right]\right)\right]+\left(\delta-E\left[\delta_{t}\right]\right)^{2} \\
|
||||
&=E\left[\left(\delta_{t}-\delta\right)^{2}\right]-\left(E\left[\delta_{t}\right]-\delta\right)^{2} \\
|
||||
& \leq E\left[\left(\delta_{t}-\delta\right)^{2}\right]
|
||||
\end{aligned}
|
||||
$$
|
||||
|
||||
+ 对于 $E\left[\left(\delta_{i}-\delta\right)^{2}\right]$：
|
||||
$$
|
||||
\begin{aligned}
|
||||
E\left[\left(\delta_{i}-\delta\right)^{2}\right] &=E\left[\left((1-\alpha) \delta_{i-1}+\alpha \Delta_{i}-\delta\right)^{2}\right] \\
|
||||
&=E\left[\left((1-\alpha) \delta_{i-1}+\alpha \Delta_{i}-(1-\alpha+\alpha) \delta\right)^{2}\right] \\
|
||||
&=E\left[\left((1-\alpha)\left(\delta_{i-1}-\delta\right)+\alpha\left(\Delta_{i}-\delta\right)\right)^{2}\right] \\
|
||||
&=(1-\alpha)^{2} E\left[\left(\delta_{i-1}-\delta\right)^{2}\right]+\alpha^{2} E\left[\Delta_{i}-\delta\right]^{2}+2 \alpha(1-\alpha) E\left[\left(\delta_{i-1}-\delta\right)\left(\Delta_{i}-\delta\right)\right]
|
||||
\end{aligned}
|
||||
$$
|
||||
|
||||
+ 由于 $\delta_{i-1}$ 和 $\Delta_{i}$ 独立，所以上式最后一项为 0，因此：
|
||||
$$
|
||||
E\left[\left(\delta_{i}-\delta\right)^{2}\right]=(1-\alpha)^{2} E\left[\left(\delta_{i-1}-\delta\right)^{2}\right]+\alpha^{2} E\left[\Delta_{i}-\delta\right]^{2}
|
||||
$$
|
||||
|
||||
+ 与均值的推导类似，可得：
|
||||
$$
|
||||
\begin{aligned}
|
||||
E\left[\left(\delta_{t}-\delta\right)^{2}\right] &=(1-\alpha)^{2 t}\left(\delta_{0}-\delta\right)^{2}+\alpha^{2} \frac{1-(1-\alpha)^{2 t-2}}{1-(1-\alpha)^{2}} E\left[\left(\Delta_{1}-\delta\right)^{2}\right] \\
|
||||
& \leq(1-\alpha)^{2 t}\left(\delta_{0}-\delta\right)^{2}+\alpha E\left[\left(\Delta_{1}-\delta\right)^{2}\right]
|
||||
\end{aligned}
|
||||
$$
|
||||
|
||||
+ 由此可证明：
|
||||
$$
|
||||
E\left[\left(\delta_{t}-E\left[\delta_{t}\right]\right)^{2}\right] \leq(1-\alpha)^{2 t}\left(\delta_{0}-\delta\right)^{2}+\alpha E\left[\left(\Delta_{1}-\alpha\right)^{2}\right]
|
||||
$$
|
||||
|
||||
+ 对于方差，上式给了一个估计方差的上界。
|
||||
|
||||
## 多重哈希
|
||||
|
||||
上述流动采样频率估计算法存在的问题：
|
||||
|
||||
+ 对于不同的物品，经过哈希函数映射的整数可能相同，这就会导致哈希碰撞的问题。
|
||||
|
||||
+ 由于哈希碰撞，对导致对物品采样频率过高的估计。
|
||||
|
||||
**解决方法：**
|
||||
|
||||
* 使用 $m$ 个哈希函数，取 $m$ 个估计值中的最大值来表示物品连续两次被采样到之间的步长。
|
||||
|
||||
**具体的算法流程：**
|
||||
|
||||
1. 分别建立 $m$ 个大小为 $H$ 的数组 $\{A\}_{i=1}^{m}$，$\{B\}_{i=1}^{m}$，一组对应的独立哈希函数集合 $\{h\}_{i=1}^{m}$ 。
|
||||
|
||||
2. 通过哈希函数 $h(\cdot)$ 可以把每个物品映射为 $[H]$ 范围内的整数。对于给定的物品 $y$，哈希后的整数记为$h(y)$
|
||||
|
||||
3. 数组 $A_i$ 中存放的 $A_i[h(y)]$ 表示在第 $i$ 个哈希函数中物品 $y$ 上次被采样的时间。数组 $B_i$ 中存放的 $B_i[h(y)]$ 表示在第 $i$ 个哈希函数中物品 $y$ 的全局步长。
|
||||
|
||||
4. 假设在第 $t$ 步采样到物品 $y$，分别对 $m$ 个哈希函数对应的 $A[h(y)]$ 和 $B[h(y)]$ 进行更新：
|
||||
$$
|
||||
\begin{aligned}
|
||||
& B_i[h(y)] \leftarrow(1-\alpha) \cdot B_i[h(y)]+\alpha \cdot(t-A_i[h(y)])\\ \\
|
||||
& A_i[h(y)]\leftarrow t
|
||||
\end{aligned}
|
||||
$$
|
||||
|
||||
5. 对整个 batch 数据采样后，取 $\{B\}_{i=1}^{m}$ 中最大的 $B[h(y)]$ 的倒数，作为物品 $y$ 的采样频率，即：
|
||||
|
||||
$$
|
||||
\hat{p}=1 / \max _{i}\left\{B_{i}[h(y)]\right\}
|
||||
$$
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/%E5%9B%BE%E7%89%87image-20220506223731749.png" alt="image-20220506223731749" style="zoom:50%;" />
|
||||
|
||||
|
||||
|
||||
# YouTube 神经召回模型
|
||||
|
||||
本文构建的 YouTube 神经检索模型由查询和候选网络组成。下图展示了整体的模型架构。
|
||||
|
||||
|
||||
|
||||
在任何时间点，用户正在观看的视频，即种子视频，都会提供有关用户当前兴趣的强烈信号。因此，本文利用了大量种子视频特征以及用户的观看历史记录。候选塔是为了从候选视频特征中学习而构建的。
|
||||
|
||||
* Training Label
|
||||
|
||||
* 视频点击被用作正面标签。对于每次点击，我们都会构建一个 rewards 来反映用户对视频的不同程度的参与。
|
||||
* $r_i$ = 0：观看时间短的点击视频；$r_i$ = 1：表示观看了整个视频。
|
||||
* Video Features
|
||||
|
||||
* YouTube 使用的视频特征包括 categorical 特征和 dense 特征。
|
||||
|
||||
* 例如 categorical 特征有 video id 和 channel id 。
|
||||
* 对于 categorical 特征，都会创建一个嵌入层以将每个分类特征映射到一个 Embedding 向量。
|
||||
* 通常 YouTube 要处理两种类别特征。从原文的意思来看，这两类应该是 one-hot 型和 multi-hot 型。
|
||||
* User Features
|
||||
|
||||
* 使用**用户观看历史记录**来捕捉 seed video 之外的兴趣。将用户最近观看的 k个视频视为一个词袋（BOW)，然后将它们的 Embedding 平均。
|
||||
* 在查询塔中，最后将用户和历史 seed video 的特征进行融合，并送入输入前馈神经网络。
|
||||
* 类别特征的 Embedding 共享
|
||||
|
||||
* 原文：For the same type of IDs, embeddings are shared among the related features. For example, the same set of video id embeddings is used for seed, candidate and users past watches. We did experiment with non-shared embeddings, but did not observe significant model quality improvement.
|
||||
* 大致意思就是，对于相同 ID 的类别，他们之间的 Embedding 是共享的。例如对于 seed video，出现的地方包括用户历史观看，以及作为候选物品，故只要视频的 ID 相同，Embedding也是相同的。如果不共享，也没啥提升。
|
||||
|
||||
# 参考链接
|
||||
|
||||
+ [Sampling-bias-corrected neural modeling for large corpus item recommendations | Proceedings of the 13th ACM Conference on Recommender Systems](https://dl.acm.org/doi/abs/10.1145/3298689.3346996)
|
||||
|
||||
+ [【推荐系统经典论文(九)】谷歌双塔模型 - 知乎 (zhihu.com)](https://zhuanlan.zhihu.com/p/137538147)
|
||||
|
||||
+ [借Youtube论文，谈谈双塔模型的八大精髓问题 - 知乎 (zhihu.com)](https://zhuanlan.zhihu.com/p/369152684)
|
||||
114
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.2/item2vec.md
Normal file
114
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.2/item2vec.md
Normal file
@@ -0,0 +1,114 @@
|
||||
# 前言
|
||||
|
||||
在自然语言处理（NLP）领域，谷歌提出的 Word2Vec 模型是学习词向量表示的重要方法。其中，带有负采样（SGNS，Skip-gram with negative sampling）的 Skip-Gram 神经词向量模型在当时被证明是最先进的方法之一。各位读者需要自行了解 Word2Vec 中的 Skip-Gram 模型，本文只会做简单介绍。
|
||||
|
||||
在论文 Item2Vec：Neural Item Embedding for Collaborative Filtering 中，作者受到 SGNS 的启发，提出了名为 Item2Vec 的方法来生成物品的向量表示，然后将其用于基于物品的协同过滤。
|
||||
|
||||
# 基于负采样的 Skip-Gram 模型
|
||||
|
||||
Skip-Gram 模型的思想很简单：给定一个句子 $(w_i)^K_{i=1}$，然后基于中心词来预测它的上下文。目标函数如下：
|
||||
$$
|
||||
\frac{1}{K} \sum_{i=1}^{K} \sum_{-c \leq j \leq c, j \neq 0} \log p\left(w_{i+j} \mid w_{i}\right)
|
||||
$$
|
||||
|
||||
+ 其中，$c$ 表示上下文的窗口大小；$w_i$ 表示中心词；$w_{i+j}$ 表示上下文。
|
||||
|
||||
+ 表达式中的概率 $p\left(w_{j} \mid w_{i}\right)$ 的公式为：
|
||||
$$
|
||||
p\left(w_{j} \mid w_{i}\right)=\frac{\exp \left(u_{i}^{T} v_{j}\right)}{\sum_{k \in I_{W}} \exp \left(u_{i}^{T} v_{k}^{T}\right)}
|
||||
$$
|
||||
|
||||
+ $u_{i} \in U\left(\subset \mathbb{R}^{m}\right),v_{i} \in V\left(\subset \mathbb{R}^{m}\right)$，分别对应中心和上下文词的 Embedding 特征表示。
|
||||
+ 这里的意思是每个单词有2个特征表示，作为中心词 $u_i$ 和上下文 $v_i$ 时的特征表示不一样。
|
||||
+ $I_{W} \triangleq\{1, \ldots,|W|\}$ ，$|W|$ 表示语料库中词的数量。
|
||||
|
||||
简单来理解一下 Skip-Gram 模型的表达式：
|
||||
|
||||
+ 对于句子中的某个词 $w_i$，当其作为中心词时，希望尽可能准确预测它的上下文。
|
||||
+ 我们可以将其转换为多分类问题：
|
||||
+ 对于中心词 $w_i$ 预测的上下文 $w_j$，其 $label=1$ ；那么，模型对上下文的概率预测 $p\left(w_{j} \mid w_{i}\right)$ 越接近1越好。
|
||||
+ 若要 $p\left(w_{j} \mid w_{i}\right)$ 接近1，对于分母项中的 $k\ne j$，其 $\exp \left(u_{i}^{T} v_{k}^{T}\right)$ 越小越好（等价于将其视为了负样本）。
|
||||
|
||||
|
||||
注意到分母项，由于需要遍历语料库中所有的单词，从而导致计算成本过高。一种解决办法是基于负采样（NEG）的方式来降低计算复杂度：
|
||||
$$
|
||||
p\left(w_{j} \mid w_{i}\right)=\sigma\left(u_{i}^{T} v_{j}\right) \prod_{k=1}^{N} \sigma\left(-u_{i}^{T} v_{k}\right)
|
||||
$$
|
||||
|
||||
+ 其中，$\sigma(x)=1/1+exp(-x)$，$N$ 表示负样本的数量。
|
||||
|
||||
其它细节：
|
||||
|
||||
+ 单词 $w$ 作为负样本时，被采样到的概率：
|
||||
$$
|
||||
\frac{[\operatorname{counter}(w)]^{0.75}}{\sum_{u \in \mathcal{W}}[\operatorname{counter}(u)]^{0.75}}
|
||||
$$
|
||||
|
||||
+ 单词 $w$ 作为中心词时，被丢弃的概率：
|
||||
$$
|
||||
\operatorname{prob}(w)=1-\sqrt{\frac{t}{f(w)}}
|
||||
$$
|
||||
|
||||
|
||||
# Item2Vec模型
|
||||
|
||||
Item2Vec 的原理十分十分简单，它是基于 Skip-Gram 模型的物品向量训练方法。但又存在一些区别，如下：
|
||||
|
||||
+ 词向量的训练是基于句子序列（sequence），但是物品向量的训练是基于物品集合（set）。
|
||||
+ 因此，物品向量的训练丢弃了空间、时间信息。
|
||||
|
||||
Item2Vec 论文假设对于一个集合的物品，它们之间是相似的，与用户购买它们的顺序、时间无关。当然，该假设在其他场景下不一定使用，但是原论文只讨论了该场景下它们实验的有效性。由于忽略了空间信息，原文将共享同一集合的每对物品视为正样本。目标函数如下：
|
||||
$$
|
||||
\frac{1}{K} \sum_{i=1}^{K} \sum_{j \neq i}^{K} \log p\left(w_{j} \mid w_{i}\right)
|
||||
$$
|
||||
|
||||
+ 对于窗口大小 $K$，由设置的决定。
|
||||
|
||||
在 Skip-Gram 模型中，提到过每个单词 $w_i$ 有2个特征表示。在 Item2Vec 中同样如此，论文中是将物品的中心词向量 $u_i$ 作为物品的特征向量。作者还提到了其他两种方式来表示物品向量：
|
||||
|
||||
+ **add**：$u_i + v_i$
|
||||
+ **concat**：$\left[u_{i}^{T} v_{i}^{T}\right]^{T}$
|
||||
|
||||
原文还补充到，这两种方式有时候会有很好的表现。
|
||||
|
||||
# 总结
|
||||
|
||||
+ Item2Vec 的原理很简单，就是基于 Word2Vec 的 Skip-Gram 模型，并且还丢弃了时间、空间信息。
|
||||
+ 基于 Item2Vec 得到物品的向量表示后，物品之间的相似度可由二者之间的余弦相似度计算得到。
|
||||
+ 可以看出，Item2Vec 在计算物品之间相似度时，仍然依赖于不同物品之间的共现。因为，其无法解决物品的冷启动问题。
|
||||
+ 一种解决方法：取出与冷启物品类别相同的非冷启物品，将它们向量的均值作为冷启动物品的向量表示。
|
||||
|
||||
原论文链接：[[1603.04259\] Item2Vec: Neural Item Embedding for Collaborative Filtering (arxiv.org)](https://arxiv.org/abs/1603.04259)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
341
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.2/word2vec.md
Normal file
341
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.2/word2vec.md
Normal file
@@ -0,0 +1,341 @@
|
||||
# 背景和引入
|
||||
在所有的NLP任务中，首先面临的第一个问题是我们该如何表示单词。这种表示将作为inputs输入到特定任务的模型中，如机器翻译，文本分类等典型NLP任务。
|
||||
|
||||
## 同义词表达单词
|
||||
一个很容易想到的解决方案是使用同义词来表示一个单词的意义。
|
||||
比如***WordNet***,一个包含同义词（和有“is a”关系的词）的词库。
|
||||
|
||||
**导包**
|
||||
|
||||
```python
|
||||
!pip install --user -U nltk
|
||||
```
|
||||
|
||||
```python
|
||||
!python -m nltk.downloader popular
|
||||
```
|
||||
|
||||
**如获取"good"的同义词**
|
||||
|
||||
```python
|
||||
from nltk.corpus import wordnet as wn
|
||||
poses = { 'n':'noun', 'v':'verb', 's':'adj (s)', 'a':'adj', 'r':'adv'}
|
||||
for synset in wn.synsets("good"):
|
||||
print("{}: {}".format(poses[synset.pos()],", ".join([l.name() for l in synset.lemmas()])))
|
||||
```
|
||||
|
||||
**如获取与“pandas”有"is a"关系的词**
|
||||
|
||||
```python
|
||||
panda = wn.synset("panda.n.01")
|
||||
hyper = lambda s: s.hypernyms()
|
||||
list(panda.closure(hyper))
|
||||
```
|
||||
|
||||
***WordNet的问题***
|
||||
1. 单词与单词之间缺少些微差异的描述。比如“高效”只在某些语境下是"好"的同义词
|
||||
2. 丢失一些词的新含义。比如“芜湖”，“蚌埠”等词的新含义
|
||||
3. 相对主观
|
||||
4. 需要人手动创建和调整
|
||||
5. 无法准确计算单词的相似性
|
||||
|
||||
## one-hot编码
|
||||
在传统NLP中，人们使用one-hot向量（一个向量只有一个值为1，其余的值为0）来表示单词
|
||||
如：motel = [0 0 0 0 0 0 0 0 0 0 1 0 0 0 0]
|
||||
如：hotel = [0 0 0 0 0 0 0 1 0 0 0 0 0 0 0]
|
||||
one-hot向量的维度是词汇表的大小（如：500，000）
|
||||
注：上面示例词向量的维度为方便展示所以比较小
|
||||
|
||||
|
||||
**one-hot向量表示单词的问题：**
|
||||
1. 这些词向量是***正交向量***，无法通过数学计算（如点积）计算相似性
|
||||
2. 依赖WordNet等同义词库建立相似性效果也不好
|
||||
|
||||
|
||||
## dense word vectors表达单词
|
||||
如果我们可以使用某种方法为每个单词构建一个合适的dense vector，如下图，那么通过点积等数学计算就可以获得单词之间的某种联系
|
||||
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片1.png" />
|
||||
|
||||
|
||||
# Word2vec
|
||||
|
||||
## 语言学基础
|
||||
首先，我们引入一个上世纪五十年代，一个语言学家的研究成果：**“一个单词的意义由它周围的单词决定”**
|
||||
|
||||
“You shall know a word by the company it keeps” (J. R. Firth 1957: 11)
|
||||
|
||||
这是现代NLP中一个最为成功的理念。
|
||||
|
||||
我们先引入上下文context的概念：当单词 w 出现在文本中时，其**上下文context**是出现在w附近的一组单词（在固定大小的窗口内），如下图
|
||||
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片2.png" />
|
||||
|
||||
|
||||
这些上下文单词context words决定了banking的意义
|
||||
|
||||
## Word2vec概述
|
||||
|
||||
Word2vec(Mikolov et al. 2013)是一个用来学习dense word vector的算法：
|
||||
|
||||
1. 我们使用**大量的文本语料库**
|
||||
2. 词汇表中的每个单词都由一个**词向量dense word vector**表示
|
||||
3. 遍历文本中的每个位置 t，都有一个**中心词 c（center） 和上下文词 o（“outside”）**，如图1中的banking
|
||||
4. 在整个语料库上使用数学方法**最大化单词o在单词c周围出现了这一事实**，从而得到单词表中每一个单词的dense vector
|
||||
5. 不断调整词向量dense word vector以达到最好的效果
|
||||
|
||||
|
||||
## Skip-gram(SG)
|
||||
Word2vec包含两个模型，**Skip-gram与CBOW**。下面，我们先讲**Skip-gram**模型，用此模型详细讲解概述中所提到的内容。
|
||||
|
||||
概述中我们提到，我们希望**最大化单词o在单词c周围出现了这一事实**，而我们需要用数学语言表示“单词o在单词c周围出现了”这一事件，如此才能进行词向量的不断调整。
|
||||
|
||||
很自然地，我们需要**使用概率工具描述事件的发生**，我们想到用条件概率$P(o|c)$表示“给定中心词c,它的上下文词o在它周围出现了”
|
||||
|
||||
下图展示了以“into”为中心词，窗口大小为2的情况下它的上下文词。以及相对应的$P(o|c)$
|
||||
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片3.png" />
|
||||
|
||||
|
||||
我们滑动窗口，再以banking为中心词
|
||||
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片4.png" />
|
||||
|
||||
|
||||
那么，如果我们在整个语料库上不断地滑动窗口，我们可以得到所有位置的$P(o|c)$，我们希望在所有位置上**最大化单词o在单词c周围出现了这一事实**，由极大似然法，可得：
|
||||
|
||||
$$
|
||||
max\prod_{c} \prod_{o}P(o|c)
|
||||
$$
|
||||
|
||||
此式还可以依图3写为：
|
||||
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片5.png" />
|
||||
|
||||
|
||||
加log,加负号，缩放大小可得：
|
||||
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片7.png" />
|
||||
|
||||
|
||||
上式即为**skip-gram的损失函数**，最小化损失函数，就可以得到合适的词向量
|
||||
|
||||
|
||||
得到式1后，产生了两个问题：
|
||||
|
||||
1. P(o|c)怎么表示？
|
||||
|
||||
2. 为何最小化损失函数能够得到良好表示的词向量dense word vector？
|
||||
|
||||
|
||||
回答1：我们使用**中心词c和上下文词o的相似性**来计算$P(o|c)$，更具体地，相似性由**词向量的点积**表示：$u_o \cdot v_c$。
|
||||
|
||||
使用词向量的点积表示P(o|c)的原因：1.计算简单 2.出现在一起的词向量意义相关，则希望它们相似
|
||||
|
||||
又P(o|c)是一个概率，所以我们在整个语料库上使用**softmax**将点积的值映射到概率，如图6
|
||||
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片6.png" />
|
||||
|
||||
|
||||
注：注意到上图，中心词词向量为$v_{c}$,而上下文词词向量为$u_{o}$。也就是说每个词会对应两个词向量，**在词w做中心词时，使用$v_{w}$作为词向量，而在它做上下文词时，使用$u_{w}$作为词向量**。这样做的原因是为了求导等操作时计算上的简便。当整个模型训练完成后，我们既可以使用$v_{w}$作为词w的词向量，也可以使用$u_{w}$作为词w的词向量，亦或是将二者平均。在下一部分的模型结构中，我们将更清楚地看到两个词向量究竟在模型的哪个位置。
|
||||
|
||||
|
||||
回答2：由上文所述，$P(o|c)=softmax(u_{o^T} \cdot v_c)$。所以损失函数是关于$u_{o}$和$v_c$的函数，我们通过梯度下降法调整$u_{o}$和$v_c$的值，最小化损失函数，即得到了良好表示的词向量。
|
||||
|
||||
|
||||
## Word2vec模型结构
|
||||
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片8.png" />
|
||||
|
||||
|
||||
如图八所示，这是一个输入为1 X V维的one-hot向量（V为整个词汇表的长度，这个向量只有一个1值，其余为0值表示一个词），单隐藏层（**隐藏层的维度为N，这里是一个超参数，这个参数由我们定义，也就是词向量的维度**），输出为1 X V维的softmax层的模型。
|
||||
|
||||
$W^{I}$为V X N的参数矩阵，$W^{O}$为N X V的参数矩阵。
|
||||
|
||||
模型的输入为1 X V形状的one-hot向量（V为整个词汇表的长度，这个向量只有一个1值，其余为0值表示一个词）。隐藏层的维度为N，这里是一个超参数，这个参数由我们定义，也就是词向量的维度。$W^{I}$为V X N的参数矩阵。
|
||||
|
||||
我们这里，考虑Skip-gram算法，输入为中心词c的one-hot表示
|
||||
|
||||
由输入层到隐藏层，根据矩阵乘法规则，可知，**$W^{I}$的每一行即为词汇表中的每一个单词的词向量v**,1 X V 的 inputs 乘上 V X N 的$W^{I}$，隐藏层即为1 X N维的$v_{c}$。
|
||||
|
||||
而$W^{O}$中的每一列即为词汇表中的每一个单词的词向量u。根据乘法规则，1 X N 的隐藏层乘上N X V的$W^{O}$参数矩阵，得到的1 X V 的输出层的每一个值即为$u_{w^T} \cdot v_c$,加上softmax变化即为$P(w|c)$。
|
||||
|
||||
有V个w,其中的P(o|c)即实际样本中的上下文词的概率，为我们最为关注的值。
|
||||
|
||||
## CBOW
|
||||
|
||||
如上文所述，Skip-gram为给定中心词，预测周围的词，即求P(o|c)，如下图所示：
|
||||
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220424105817437.png" />
|
||||
|
||||
|
||||
而CBOW为给定周围的词，预测中心词，即求P(c|o),如下图所示：
|
||||
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片10.png" />
|
||||
|
||||
|
||||
|
||||
注意：在使用CBOW时，上文所给出的模型结构并没有变，在这里，我们输入多个上下文词o，在隐藏层，**将这多个上下文词经过第一个参数矩阵的计算得到的词向量相加作为隐藏单元的值**。其余均不变，$W^{O}$中的每一列依然为为词汇表中的每一个单词的词向量u。
|
||||
|
||||
# 负采样 Negative Sampling
|
||||
|
||||
## softmax函数带来的问题
|
||||
|
||||
我们再看一眼，通过softmax得到的$P(o|c)$，如图：
|
||||
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220424105958191.png" />
|
||||
|
||||
|
||||
|
||||
可以看到，$P(o|c)$的分母需要在整个单词表上做乘积和exp运算，这无疑是非常消耗计算资源的，Word2vec的作者针对这个问题，做出了改进。
|
||||
|
||||
他提出了两种改进的方法：Hierarchical Softmax和Negative Sampling，因为Negative Sampling更加常见，所以我们下面只介绍Negative Sampling，感兴趣的朋友可以在文章下面的参考资料中学习Hierarchical Softmax。
|
||||
|
||||
## 负采样Negative Sampling
|
||||
|
||||
我们依然以Skip-gram为例（CBOW与之差别不大，感兴趣的朋友们依然可以参阅参考资料）
|
||||
|
||||
我们首先给出负采样的损失函数：
|
||||
|
||||
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片12.png" />
|
||||
|
||||
|
||||
|
||||
其中$\sigma$为sigmoid函数$1/(1+e^{-x})$, $u_{o}$为实际样本中的上下文词的词向量，而$u_{k}$为我们在单词表中随机选出（按一定的规则随机选出，具体可参阅参考资料）的K个单词。
|
||||
|
||||
由函数单调性易知，**$u_{o^T} \cdot v_c$越大，损失函数越小，而$u_{k^T} \cdot v_c$越小**，损失函数越大。这与原始的softmax损失函数优化目标一致，即$maxP(o|c)$，而且避免了在整个词汇表上的计算。
|
||||
|
||||
# 核心代码与核心推导
|
||||
|
||||
## Naive softmax 损失函数
|
||||
|
||||
损失函数关于$v_c$的导数：
|
||||
|
||||
$$
|
||||
\frac{\partial{J_{naive-softmax}(\boldsymbol v_c,o,\boldsymbol U)}}{\partial \boldsymbol v_c} \\=
|
||||
-\frac{\partial{log(P(O=o|C=c))}}{\partial \boldsymbol v_c} \\ =
|
||||
-\frac{\partial{log(exp( \boldsymbol u_o^T\boldsymbol v_c))}}{\partial \boldsymbol v_c} + \frac{\partial{log(\sum_{w=1}^{V}exp(\boldsymbol u_w^T\boldsymbol v_c))}}{\partial \boldsymbol v_c} \\=
|
||||
-\boldsymbol u_o + \sum_{w=1}^{V} \frac{exp(\boldsymbol u_w^T\boldsymbol v_c)}{\sum_{w=1}^{V}exp(\boldsymbol u_w^T\boldsymbol v_c)}\boldsymbol u_w \\=
|
||||
-\boldsymbol u_o+ \sum_{w=1}^{V}P(O=w|C=c)\boldsymbol u_w \\=
|
||||
\boldsymbol U^T(\hat{\boldsymbol y} - \boldsymbol y)
|
||||
$$
|
||||
|
||||
可以看到涉及整个U矩阵的计算，计算量很大，关于$u_w$的导数读者可自行推导
|
||||
|
||||
损失函数及其梯度的求解
|
||||
|
||||
来自：https://github.com/lrs1353281004/CS224n_winter2019_notes_and_assignments
|
||||
|
||||
```python
|
||||
def naiveSoftmaxLossAndGradient(
|
||||
centerWordVec,
|
||||
outsideWordIdx,
|
||||
outsideVectors,
|
||||
dataset
|
||||
):
|
||||
""" Naive Softmax loss & gradient function for word2vec models
|
||||
|
||||
Arguments:
|
||||
centerWordVec -- numpy ndarray, center word's embedding
|
||||
in shape (word vector length, )
|
||||
(v_c in the pdf handout)
|
||||
outsideWordIdx -- integer, the index of the outside word
|
||||
(o of u_o in the pdf handout)
|
||||
outsideVectors -- outside vectors is
|
||||
in shape (num words in vocab, word vector length)
|
||||
for all words in vocab (tranpose of U in the pdf handout)
|
||||
dataset -- needed for negative sampling, unused here.
|
||||
|
||||
Return:
|
||||
loss -- naive softmax loss
|
||||
gradCenterVec -- the gradient with respect to the center word vector
|
||||
in shape (word vector length, )
|
||||
(dJ / dv_c in the pdf handout)
|
||||
gradOutsideVecs -- the gradient with respect to all the outside word vectors
|
||||
in shape (num words in vocab, word vector length)
|
||||
(dJ / dU)
|
||||
"""
|
||||
|
||||
# centerWordVec: (embedding_dim,1)
|
||||
# outsideVectors: (vocab_size,embedding_dim)
|
||||
|
||||
scores = np.matmul(outsideVectors, centerWordVec) # size=(vocab_size, 1)
|
||||
probs = softmax(scores) # size=(vocab, 1)
|
||||
|
||||
loss = -np.log(probs[outsideWordIdx]) # scalar
|
||||
|
||||
dscores = probs.copy() # size=(vocab, 1)
|
||||
dscores[outsideWordIdx] = dscores[outsideWordIdx] - 1 # dscores=y_hat - y
|
||||
gradCenterVec = np.matmul(outsideVectors, dscores) # J关于vc的偏导数公式 size=(vocab_size, 1)
|
||||
gradOutsideVecs = np.outer(dscores, centerWordVec) # J关于u的偏导数公式 size=(vocab_size, embedding_dim)
|
||||
|
||||
return loss, gradCenterVec, gradOutsideVecs
|
||||
```
|
||||
|
||||
## 负采样损失函数
|
||||
|
||||
负采样损失函数关于$v_c$的导数：
|
||||
|
||||
$$
|
||||
\frac{\partial{J_{neg-sample}(\boldsymbol v_c,o,\boldsymbol U)}}{\partial\boldsymbol v_c} \\=
|
||||
\frac{\partial (-log(\sigma (\boldsymbol u_o^T\boldsymbol v_c))-\sum_{k=1}^{K} log(\sigma (-\boldsymbol u_k^T\boldsymbol v_c)))}{\partial \boldsymbol v_c} \\=
|
||||
-\frac{\sigma(\boldsymbol u_o^T\boldsymbol v_c)(1-\sigma(\boldsymbol u_o^T\boldsymbol v_c))}{\sigma(\boldsymbol u_o^T\boldsymbol v_c)}\frac{\partial \boldsymbol u_o^T\boldsymbol v_c}{\partial \boldsymbol v_c} -
|
||||
\sum_{k=1}^{K}\frac{\partial log(\sigma(-\boldsymbol u_k^T\boldsymbol v_c))}{\partial \boldsymbol v_c} \\=
|
||||
-(1-\sigma(\boldsymbol u_o^T\boldsymbol v_c))\boldsymbol u_o+\sum_{k=1}^{K}(1-\sigma(-\boldsymbol u_k^T\boldsymbol v_c))\boldsymbol u_k
|
||||
$$
|
||||
|
||||
可以看到其只与$u_k$和$u_o$有关，避免了在整个单词表上的计算
|
||||
|
||||
负采样方法的损失函数及其导数的求解
|
||||
|
||||
```python
|
||||
def negSamplingLossAndGradient(
|
||||
centerWordVec,
|
||||
outsideWordIdx,
|
||||
outsideVectors,
|
||||
dataset,
|
||||
K=10
|
||||
):
|
||||
|
||||
negSampleWordIndices = getNegativeSamples(outsideWordIdx, dataset, K)
|
||||
indices = [outsideWordIdx] + negSampleWordIndices
|
||||
|
||||
gradCenterVec =np.zeros(centerWordVec.shape) # (embedding_size,1)
|
||||
gradOutsideVecs = np.zeros(outsideVectors.shape) # (vocab_size, embedding_size)
|
||||
loss = 0.0
|
||||
|
||||
u_o = outsideVectors[outsideWordIdx] # size=(embedding_size,1)
|
||||
z = sigmoid(np.dot(u_o, centerWordVec)) # size=(1, )
|
||||
loss -= np.log(z) # 损失函数的第一部分
|
||||
gradCenterVec += u_o * (z - 1) # J关于vc的偏导数的第一部分
|
||||
gradOutsideVecs[outsideWordIdx] = centerWordVec * (z - 1) # J关于u_o的偏导数计算
|
||||
|
||||
for i in range(K):
|
||||
neg_id = indices[1 + i]
|
||||
u_k = outsideVectors[neg_id]
|
||||
z = sigmoid(-np.dot(u_k, centerWordVec))
|
||||
loss -= np.log(z)
|
||||
gradCenterVec += u_k * (1-z)
|
||||
gradOutsideVecs[neg_id] += centerWordVec * (1 - z)
|
||||
|
||||
|
||||
return loss, gradCenterVec, gradOutsideVecs
|
||||
```
|
||||
|
||||
**参考资料**
|
||||
- Mikolov T, Sutskever I, Chen K, et al. Distributed representations of words and phrases and their compositionality[J]. Advances in neural information processing systems, 2013, 26.
|
||||
- https://www.cnblogs.com/peghoty/p/3857839.html
|
||||
- http://web.stanford.edu/class/cs224n/
|
||||
|
||||
399
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.3/EGES.md
Normal file
399
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.3/EGES.md
Normal file
@@ -0,0 +1,399 @@
|
||||
# Billion-scale Commodity Embedding for E-commerce Recommendation in Alibaba
|
||||
|
||||
这篇论文是阿里巴巴在18年发表于KDD的关于召回阶段的工作。该论文提出的方法是在基于图嵌入的方法上，通过引入side information来解决实际问题中的数据稀疏和冷启动问题。
|
||||
|
||||
## 动机
|
||||
|
||||
在电商领域，推荐已经是不可或缺的一部分，旨在为用户的喜好提供有趣的物品，并且成为淘宝和阿里巴巴收入的重要引擎。尽管学术界和产业界的各种推荐方法都取得了成功，如协同过滤、基于内容的方法和基于深度学习的方法，但由于用户和项目的数十亿规模，传统的方法已经不能满足于实际的需求，主要的问题体现在三个方面：
|
||||
|
||||
- 可扩展性：现有的推荐方法无法扩展到在拥有十亿的用户和二十亿商品的淘宝中。
|
||||
- 稀疏性：存在大量的物品与用户的交互行为稀疏。即用户的交互到多集中于以下部分商品，存在大量商品很少被用户交互。
|
||||
- 冷启动：在淘宝中，每分钟会上传很多新的商品，由于这些商品没有用户行为的信息（点击、购买等），无法进行很好的预测。
|
||||
|
||||
针对于这三个方面的问题， 本文设计了一个两阶段的推荐框架：**召回阶段和排序阶段**，这也是推荐领域最常见的模型架构。而本文提及的EGES模型主要是解决了匹配阶段的问题，通过用户行为计算商品间两两的相似性，然后根基相似性选出topK的商品输入到排序阶段。
|
||||
|
||||
为了学习更好的商品向量表示，本文通过用户的行为历史中构造一个item-item 图，然后应用随机游走方法在item-item 图为每个item获取到一个序列，然后通过Skip-Gram的方式为每个item学习embedding(这里的item序列类似于语句，其中每个item类比于句子中每个word)，这种方式被称为图嵌入方法(Graph Embedding)。文中提出三个具体模型来学习更好的物品embedding，更好的服务于召回阶段。
|
||||
|
||||
## 思路
|
||||
|
||||
根据上述所面临的三个问题，本文针对性的提出了三个模型予以解决：Base Graph Embedding（BGE）；Graph Embedding with Side Information（GES）；Enhanced Graph Embedding with Side Information（EGES）。
|
||||
|
||||
考虑可扩展性的问题，图嵌入的随机游走方式可以在物品图上捕获**物品之间高阶相似性**，即Base Graph Embedding（BGE）方法。其不同于CF方法，除了考虑物品的共现，还考虑到了行为的序列信息。
|
||||
|
||||
考虑到稀疏性和冷启物品问题，在图嵌入的基础上，考虑了节点的属性信息。希望具有相似属性的物品可以在空间上相似，即希望通过头部物品，提高属性信息的泛化能力，进而帮助尾部和冷启物品获取更加准确的embedding，即Graph Embedding with Side Information（GES）方法。
|
||||
|
||||
考虑到不同属性信息对于学习embedding的贡献不同，因此在聚合不同的属性信息时，动态的学习不同属性对于学习节点的embedding所参与的重要性权重，即Enhanced Graph Embedding with Side Information（EGES）。
|
||||
|
||||
## 模型结构与原理
|
||||
|
||||
文中所提出的方法是基于经典的图嵌入模型DeepWalk进行改进，其目标是通过物品图G，学习一个映射函数$f:V -> R^d$ ，将图上节点映射成一个embedding。具体的步骤包括两步：1.通过随机游走为图上每个物品生成序列；2.通过Skip-Gram算法学习每个物品的embedding。因此对于该方法优化的目标是，在给定的上下文物品的前提下，最大化物品v的条件概率，即物品v对于一个序列里面的其他物品要尽可能的相似。接下来看一些每个模型具体内容。
|
||||
|
||||
### 构建物品图
|
||||
|
||||
在介绍三个模型之前，我们首先需要构建好item-item图。由于基于CF的方法仅考虑物品之间的共现，忽略了行为的序列信息(即序列中相邻的物品之间的语义信息)，因此item-item图的构建方式如下图所示。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220328133138263.png" style="zoom:80%;"/>
|
||||
</div>
|
||||
|
||||
首先根据用户的session行为序列构建网络结构，即序列中相邻两个item之间在存在边，并且是有向带权图。物品图边上的权重为所有用户行为序列中两个 item 共现的次数，最终构造出来简单的有向有权图。
|
||||
|
||||
值得注意的是，本文通过行为序列中物品的共现来表示其中的**语义信息**，并将这种语义信息理解为**物品之间的相似性**，并将共现频次作为相似性的一个度量值。其次基于用户的历史行为序列数据，一般不太可能取全量的历史序列数据，一方面行为数据量过大，一方面用户的兴趣会随时间发生演变，因此在处理行为序列时会设置了一个窗口来截断历史序列数据，切分出来的序列称为session。
|
||||
|
||||
由于实际中会存在一些现实因素，数据中会有一些噪音，需要特殊处理，主要分为三个方面：
|
||||
|
||||
- 从行为方面考虑，用户在点击后停留的时间少于1秒，可以认为是误点，需要移除。
|
||||
- 从用户方面考虑，淘宝场景中会有一些过度活跃用户。本文对活跃用户的定义是三月内购买商品数超过1000，或者点击数超过3500，就可以认为是一个无效用户，需要去除。
|
||||
- 从商品方面考虑，存在一些商品频繁的修改，即ID对应的商品频繁更新，这使得这个ID可能变成一个完全不同的商品，这就需要移除与这个ID相关的这个商品。
|
||||
|
||||
在构建完item-item图之后，接下来看看三个模型的具体内容。
|
||||
|
||||
### 图嵌入(BGE)
|
||||
|
||||
对于图嵌入模型，第一步先进行随机游走得到物品序列；第二部通过skip-gram为图上节点生成embedding。那么对于随机游走的思想：如何利用随机游走在图中生成的序列？不同于DeepWalk中的随机游走，本文的采样策略使用的是带权游走策略，不同权重的游走到的概率不同，（其本质上就是node2vec），传统的node2vec方法可以直接支持有向带权图。因此在给定图的邻接矩阵M后(表示节点之间的边权重)，随机游走中每次转移的概率为：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220328144516898.png" style="zoom:80%;"/>
|
||||
</div>
|
||||
|
||||
其中$M_{ij}$为边$e_{ij}$上的权重，$N_{+}(v_i)$表示节点$v_i$所有邻居节点集合，并且随机游走的转移概率的对每个节点所有邻接边权重的归一化结果。在随即游走之后，每个item得到一个序列，如下图所示：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://cdn.jsdelivr.net/gh/swallown1/blogimages@main/images/image-20220418142135912.png" style="zoom:47%;"/>
|
||||
</div>
|
||||
|
||||
然后类似于word2vec，为每个item学习embedding，于是优化目标如下：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220328144931957.png" style="zoom:77%;"/>
|
||||
</div>
|
||||
|
||||
其中，w 为窗口大小。考虑独立性假设的话，上面的式子可以进一步化简：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220328145101109.png" style="zoom:77%;"/>
|
||||
</div>
|
||||
|
||||
这样看起来就很直观了，在已知物品 i 时，最大化序列中(上下文)其他物品 j 的条件概率。为了近似计算，采样了Negative sampling，上面的优化目标可以化简得到如下式子：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220328145318718.png" style="zoom:80%;"/>
|
||||
</div>
|
||||
|
||||
其中$N(v_i)'$表示负样本集合，负采样个数越多，结果越好。
|
||||
|
||||
### 基于side information的图嵌入（GES）
|
||||
|
||||
尽管BGE将行为序列关系编码进物品的embedding中，从而从用户行为中捕捉高阶相似性。但是这里有个问题，对于新加入的商品，由于未和用户产生过交互，所以不会出现在item-item图上，进而模型无法学习到其embedding，即无法解决冷启动问题。
|
||||
|
||||
为了解决冷启问题，本文通过使用side information（ 类别，店铺, 价格等）加入模型的训练过程中，使得模型最终的泛化能力体现在商品的side information上。这样通过**side information学习到的embedding来表示具体的商品**，使得相似side information的物品可以得到在空间上相近的表示，进而来增强 BGE。
|
||||
|
||||
那么对于每个商品如何通过side information的embedidng来表示呢？对于随机游走之后得到的商品序列，其中每个每个商品由其id和属性(品牌，价格等)组成。用公式表示，对于序列中的每一个物品可以得到$W^0_V,...W_V^n$,（n+1）个向量表示，$W^0_V$表示物品v，剩下是side information的embedding。然后将所有的side information聚合成一个整体来表示物品，聚合方式如下：
|
||||
|
||||
$$H_v = \frac{1}{n+1}\sum_{s=0}^n W^s_v$$
|
||||
|
||||
其中，$H_v$是商品 v 的聚合后的 embedding 向量。
|
||||
|
||||
### 增强型EGS（EGES）
|
||||
|
||||
尽管 GES 相比 BGE 在性能上有了提升，但是在聚合多个属性向量得到商品的embedding的过程中，不同 side information的聚合依然存在问题。在GES中采用 average-pooling 是在假设不同种类的 side information 对商品embedding的贡献是相等的，但实际中却并非如此。例如，购买 Iphone 的用户更可能倾向于 Macbook 或者 Ipad，相比于价格属性，品牌属性相对于苹果类商品具有更重要的影响。因此，根据实际现状，不同类型的 side information 对商品的表示是具有不同的贡献值的。
|
||||
|
||||
针对上述问题，作者提出了weight pooling方法来聚合不同类型的 side information。具体地，EGES 与 GES 的区别在聚合不同类型 side information计算不同的权重，根据权重聚合 side information 得到商品的embedding，如下图所示：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220328154950289.png" style="zoom:80%;"/>
|
||||
</div>
|
||||
|
||||
其中 $a_i$ 表示每个side information 用于计算权重的参数向量，最终通过下面的公式得到商品的embedding：
|
||||
|
||||
$$H_v = \frac{\sum_{j=0}^n e^{a_v^j} W_v^j}{\sum_{j=0}^n e^{a_v^j}}$$
|
||||
|
||||
这里对参数 $a_v^j$ 先做指数变换，目的是为了保证每个边界信息的贡献都能大于0，然后通过归一化为每个特征得到一个o-1之内的权重。最终物品的embedding通过权重进行加权聚合得到，进而优化损失函数：
|
||||
|
||||
$$L(v,u,y)=-[ylog( \sigma (H_v^TZ_u)) + (1-y)log(1 - \sigma(H_v^TZ_u))]$$
|
||||
|
||||
y是标签符号，等于1时表示正样本，等于0时表示负样本。$H_v$表示商品 v 的最终的隐层表示，$Z_u$表示训练数据中的上下文节点的embedding。
|
||||
|
||||
以上就是这三个模型主要的区别，下面是EGES的伪代码。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220328155406291.png" style="zoom:80%;"/>
|
||||
</div>
|
||||
|
||||
其中**WeightedSkipGram**函数为带权重的SkipGram算法。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220328155533704.png" style="zoom:80%;"/>
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
## 代码实现
|
||||
|
||||
下面我们简单的来看一下模型代码的实现，参考的内容在[这里](https://github.com/wangzhegeek/EGES)，其中实验使用的是jd 2019年比赛中提供的数据。
|
||||
|
||||
### 构建物品图
|
||||
|
||||
首先对用户的下单(type=2)行为序列进行session划分，其中30分钟没有产生下一个行为，划分为一个session。
|
||||
|
||||
```python
|
||||
def cnt_session(data, time_cut=30, cut_type=2):
|
||||
# 商品属性 id 被交互时间 商品种类
|
||||
sku_list = data['sku_id']
|
||||
time_list = data['action_time']
|
||||
type_list = data['type']
|
||||
session = []
|
||||
tmp_session = []
|
||||
for i, item in enumerate(sku_list):
|
||||
# 两个商品之间如果被交互的时间大于1小时，划分成不同的session
|
||||
if type_list[i] == cut_type or (i < len(sku_list)-1 and \
|
||||
(time_list[i+1] - time_list[i]).seconds/60 > time_cut) or i == len(sku_list)-1:
|
||||
tmp_session.append(item)
|
||||
session.append(tmp_session)
|
||||
tmp_session = []
|
||||
else:
|
||||
tmp_session.append(item)
|
||||
return session # 返回多个session list
|
||||
```
|
||||
|
||||
获取到所有session list之后(这里不区分具体用户)，对于session长度不超过1的去除(没有意义)。
|
||||
|
||||
接下来就是构建图，主要是先计算所有session中，相邻的物品共现频次(通过字典计算)。然后通过入度节点、出度节点以及权重分别转化成list，通过network来构建有向图。
|
||||
|
||||
```python
|
||||
node_pair = dict()
|
||||
# 遍历所有session list
|
||||
for session in session_list_all:
|
||||
for i in range(1, len(session)):
|
||||
# 将session共现的item存到node_pair中，用于构建item-item图
|
||||
# 将共现次数所谓边的权重，即node_pair的key为边(src_node,dst_node),value为边的权重(共现次数)
|
||||
if (session[i - 1], session[i]) not in node_pair.keys():
|
||||
node_pair[(session[i - 1], session[i])] = 1
|
||||
else:
|
||||
node_pair[(session[i - 1], session[i])] += 1
|
||||
|
||||
in_node_list = list(map(lambda x: x[0], list(node_pair.keys())))
|
||||
out_node_list = list(map(lambda x: x[1], list(node_pair.keys())))
|
||||
weight_list = list(node_pair.values())
|
||||
graph_list = list([(i,o,w) for i,o,w in zip(in_node_list,out_node_list,weight_list)])
|
||||
# 通过 network 构建图结构
|
||||
G = nx.DiGraph().add_weighted_edges_from(graph_list)
|
||||
|
||||
```
|
||||
|
||||
### 随机游走
|
||||
|
||||
先是基于构建的图进行随机游走，其中p和q是参数，用于控制采样的偏向于DFS还是BFS，其实也就是node2vec。
|
||||
|
||||
```python
|
||||
walker = RandomWalker(G, p=args.p, q=args.q)
|
||||
print("Preprocess transition probs...")
|
||||
walker.preprocess_transition_probs()
|
||||
```
|
||||
|
||||
对于采样的具体过程，是根据边的归一化权重作为采样概率进行采样。其中关于如何通过AliasSampling来实现概率采样的可以[参考](https://blog.csdn.net/haolexiao/article/details/65157026)，具体的是先通过计算create_alias_table，然后根据边上两个节点的alias计算边的alias。其中可以看到这里计算alias_table是根据边的归一化权重。
|
||||
|
||||
```python
|
||||
def preprocess_transition_probs(self):
|
||||
"""预处理随即游走的转移概率"""
|
||||
G = self.G
|
||||
alias_nodes = {}
|
||||
for node in G.nodes():
|
||||
# 获取每个节点与邻居节点边上的权重
|
||||
unnormalized_probs = [G[node][nbr].get('weight', 1.0)
|
||||
for nbr in G.neighbors(node)]
|
||||
norm_const = sum(unnormalized_probs)
|
||||
# 对每个节点的邻居权重进行归一化
|
||||
normalized_probs = [
|
||||
float(u_prob)/norm_const for u_prob in unnormalized_probs]
|
||||
# 根据权重创建alias表
|
||||
alias_nodes[node] = create_alias_table(normalized_probs)
|
||||
alias_edges = {}
|
||||
for edge in G.edges():
|
||||
# 获取边的alias
|
||||
alias_edges[edge] = self.get_alias_edge(edge[0], edge[1])
|
||||
self.alias_nodes = alias_nodes
|
||||
self.alias_edges = alias_edges
|
||||
return
|
||||
```
|
||||
|
||||
在构建好Alias之后，进行带权重的随机游走。
|
||||
|
||||
```python
|
||||
session_reproduce = walker.simulate_walks(num_walks=args.num_walks,
|
||||
walk_length=args.walk_length, workers=4,verbose=1)
|
||||
```
|
||||
|
||||
其中这里的随机游走是根据p和q的值，来选择是使用Deepwalk还是node2vec。
|
||||
|
||||
```python
|
||||
def _simulate_walks(self, nodes, num_walks, walk_length,):
|
||||
walks = []
|
||||
for _ in range(num_walks):
|
||||
# 打乱所有起始节点
|
||||
random.shuffle(nodes)
|
||||
for v in nodes:
|
||||
# 根据p和q选择随机游走或者带权游走
|
||||
if self.p == 1 and self.q == 1:
|
||||
walks.append(self.deepwalk_walk(
|
||||
walk_length=walk_length, start_node=v))
|
||||
else:
|
||||
walks.append(self.node2vec_walk(
|
||||
walk_length=walk_length, start_node=v))
|
||||
return walks
|
||||
|
||||
```
|
||||
|
||||
### 加载side information并构造训练正样本
|
||||
|
||||
主要是将目前所有的sku和其对应的side infromation进行left join，没有的特征用0补充。然后对所有的特征进行labelEncoder()
|
||||
|
||||
```python
|
||||
sku_side_info = pd.merge(all_skus, product_data, on='sku_id', how='left').fillna(0) # 为商品加载side information
|
||||
for feat in sku_side_info.columns:
|
||||
if feat != 'sku_id':
|
||||
lbe = LabelEncoder()
|
||||
# 对side information进行编码
|
||||
sku_side_info[feat] = lbe.fit_transform(sku_side_info[feat])
|
||||
else:
|
||||
sku_side_info[feat] = sku_lbe.transform(sku_side_info[feat])
|
||||
```
|
||||
|
||||
通过图中的公式可以知道优化目标是让在一个窗口内的物品尽可能相似，采样若干负样本使之与目标物品不相似。因此需要将一个窗口内的所有物品与目标物品组成pair作为训练正样本。这里不需要采样负样本，负样本是通过tf中的sample softmax方法自动进行采样。
|
||||
|
||||
```python
|
||||
def get_graph_context_all_pairs(walks, window_size):
|
||||
all_pairs = []
|
||||
for k in range(len(walks)):
|
||||
for i in range(len(walks[k])):
|
||||
# 通过窗口的方式采取正样本，具体的是，让随机游走序列的起始item与窗口内的每个item组成正样本对
|
||||
for j in range(i - window_size, i + window_size + 1):
|
||||
if i == j or j < 0 or j >= len(walks[k]):
|
||||
continue
|
||||
else:
|
||||
all_pairs.append([walks[k][i], walks[k][j]])
|
||||
return np.array(all_pairs, dtype=np.int32)
|
||||
|
||||
```
|
||||
|
||||
#### EGES模型
|
||||
|
||||
构造完数据之后，在funrec的基础上实现了EGES模型：
|
||||
|
||||
```python
|
||||
def EGES(side_information_columns, items_columns, merge_type = "weight", share_flag=True,
|
||||
l2_reg=0.0001, seed=1024):
|
||||
# side_information 所对应的特征
|
||||
feature_columns = list(set(side_information_columns))
|
||||
# 获取输入层，查字典
|
||||
feature_encode = FeatureEncoder(feature_columns, linear_sparse_feature=None)
|
||||
# 输入的值
|
||||
feature_inputs_list = list(feature_encode.feature_input_layer_dict.values())
|
||||
# item id 获取输入层的值
|
||||
items_Map = FeatureMap(items_columns)
|
||||
items_inputs_list = list(items_Map.feature_input_layer_dict.values())
|
||||
|
||||
# 正样本的id，在softmax中需要传入正样本的id
|
||||
label_columns = [DenseFeat('label_id', 1)]
|
||||
label_Map = FeatureMap(label_columns)
|
||||
label_inputs_list = list(label_Map.feature_input_layer_dict.values())
|
||||
|
||||
# 通过输入的值查side_information的embedding，返回所有side_information的embedding的list
|
||||
side_embedding_list = process_feature(side_information_columns, feature_encode)
|
||||
# 拼接 N x num_feature X Dim
|
||||
side_embeddings = Concatenate(axis=1)(side_embedding_list)
|
||||
|
||||
# items_inputs_list[0] 为了查找每个item 用于计算权重的 aplha 向量
|
||||
eges_inputs = [side_embeddings, items_inputs_list[0]]
|
||||
|
||||
merge_emb = EGESLayer(items_columns[0].vocabulary_size, merge_type=merge_type,
|
||||
l2_reg=l2_reg, seed=seed)(eges_inputs) # B * emb_dim
|
||||
|
||||
label_idx = label_Map.feature_input_layer_dict[label_columns[0].name]
|
||||
softmaxloss_inputs = [merge_emb,label_idx]
|
||||
|
||||
item_vocabulary_size = items_columns[0].vocabulary_size
|
||||
|
||||
all_items_idx = EmbeddingIndex(list(range(item_vocabulary_size)))
|
||||
all_items_embeddings = feature_encode.embedding_layers_dict[side_information_columns[0].name](all_items_idx)
|
||||
|
||||
if share_flag:
|
||||
softmaxloss_inputs.append(all_items_embeddings)
|
||||
|
||||
output = SampledSoftmaxLayer(num_items=item_vocabulary_size, share_flage=share_flag,
|
||||
emb_dim=side_information_columns[0].embedding_dim,num_sampled=10)(softmaxloss_inputs)
|
||||
|
||||
model = Model(feature_inputs_list + items_inputs_list + label_inputs_list, output)
|
||||
|
||||
model.__setattr__("feature_inputs_list", feature_inputs_list)
|
||||
model.__setattr__("label_inputs_list", label_inputs_list)
|
||||
model.__setattr__("merge_embedding", merge_emb)
|
||||
model.__setattr__("item_embedding", get_item_embedding(all_items_embeddings, items_Map.feature_input_layer_dict[items_columns[0].name]))
|
||||
return model
|
||||
|
||||
```
|
||||
|
||||
其中EGESLayer为聚合每个item的多个side information的方法，其中根据merge_type可以选择average-pooling或者weight-pooling
|
||||
|
||||
```python
|
||||
class EGESLayer(Layer):
|
||||
def __init__(self,item_nums, merge_type="weight",l2_reg=0.001,seed=1024, **kwargs):
|
||||
super(EGESLayer, self).__init__(**kwargs)
|
||||
self.item_nums = item_nums
|
||||
self.merge_type = merge_type #聚合方式
|
||||
self.l2_reg = l2_reg
|
||||
self.seed = seed
|
||||
|
||||
def build(self, input_shape):
|
||||
if not isinstance(input_shape, list) or len(input_shape) < 2:
|
||||
raise ValueError('`EGESLayer` layer should be called \
|
||||
on a list of at least 2 inputs')
|
||||
self.feat_nums = input_shape[0][1]
|
||||
|
||||
if self.merge_type == "weight":
|
||||
self.alpha_embeddings = self.add_weight(
|
||||
name='alpha_attention',
|
||||
shape=(self.item_nums, self.feat_nums),
|
||||
dtype=tf.float32,
|
||||
initializer=tf.keras.initializers.RandomUniform(minval=-1, maxval=1, seed=self.seed),
|
||||
regularizer=l2(self.l2_reg))
|
||||
|
||||
def call(self, inputs, **kwargs):
|
||||
if self.merge_type == "weight":
|
||||
stack_embedding = inputs[0] # (B * num_feate * embedding_size)
|
||||
item_input = inputs[1] # (B * 1)
|
||||
alpha_embedding = tf.nn.embedding_lookup(self.alpha_embeddings, item_input) #(B * 1 * num_feate)
|
||||
alpha_emb = tf.exp(alpha_embedding)
|
||||
alpha_i_sum = tf.reduce_sum(alpha_emb, axis=-1)
|
||||
merge_embedding = tf.squeeze(tf.matmul(alpha_emb, stack_embedding),axis=1) / alpha_i_sum
|
||||
else:
|
||||
stack_embedding = inputs[0] # (B * num_feate * embedding_size)
|
||||
merge_embedding = tf.squeeze(tf.reduce_mean(alpha_emb, axis=1),axis=1) # (B * embedding_size)
|
||||
|
||||
return merge_embedding
|
||||
|
||||
def compute_output_shape(self, input_shape):
|
||||
return input_shape
|
||||
|
||||
def get_config(self):
|
||||
config = {"merge_type": self.merge_type, "seed": self.seed}
|
||||
base_config = super(EGESLayer, self).get_config()
|
||||
base_config.update(config)
|
||||
return base_config
|
||||
|
||||
```
|
||||
|
||||
至此已经从原理到代码详细的介绍了关于EGES的内容。
|
||||
|
||||
|
||||
|
||||
## 参考
|
||||
|
||||
[Billion-scale Commodity Embedding for E-commerce Recommendation in Alibaba](https://arxiv.org/abs/1803.02349)
|
||||
|
||||
[深度学习中不得不学的Graph Embedding方法](https://zhuanlan.zhihu.com/p/64200072)
|
||||
|
||||
[【Embedding】EGES：阿里在图嵌入领域中的探索](https://blog.csdn.net/qq_27075943/article/details/106244434)
|
||||
|
||||
[推荐系统遇上深度学习(四十六)-阿里电商推荐中亿级商品的embedding策略](https://www.jianshu.com/p/229b686535f1)
|
||||
|
||||
577
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.3/PinSage.md
Normal file
577
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.3/PinSage.md
Normal file
@@ -0,0 +1,577 @@
|
||||
# Graph Convolutional Neural Networks for Web-Scale Recommender Systems
|
||||
|
||||
该论文是斯坦福大学和Pinterest公司与2018年联合发表与KDD上的一篇关于GCN成功应用于工业级推荐系统的工作。该论文提到的PinSage模型，是在GraphSAGE的理论基础进行了更改，以适用于实际的工业场景。下面将简单介绍一下GraphSAGE的原理，以及Pinsage的核心和细节。
|
||||
|
||||
## GraphSAGE原理
|
||||
|
||||
GraphSAGE提出的前提是因为基于直推式(transductive)学习的图卷积网络无法适应工业界的大多数业务场景。我们知道的是，基于直推式学习的图卷积网络是通过拉普拉斯矩阵直接为图上的每个节点学习embedding表示，每次学习是针对于当前图上所有的节点。然而在实际的工业场景中，图中的结构和节点都不可能是固定的，会随着时间的变化而发生改变。例如在Pinterest公司的场景下，每分钟都会上传新的照片素材，同时也会有新用户不断的注册，那么图上的节点会不断的变化。在这样的场景中，直推式学习的方法就需要不断的重新训练才能够为新加入的节点学习embedding，导致在实际场景中无法投入使用。
|
||||
|
||||
在这样的背景下，斯坦福大学提出了一种归纳(inductive)学习的GCN方法——GraphSAGE，即**通过聚合邻居信息的方式为给定的节点学习embedding**。不同于直推式(transductive)学习，GraphSAGE是通过学习聚合节点邻居生成节点Embedding的函数的方式，为任意节点学习embedding，进而将GCN扩展成归纳学习任务。
|
||||
|
||||
对于想直接应用GCN或者GraphSAGE的我们而言，不用非要去理解其背后晦涩难懂的数学原理，可以仅从公式的角度来理解GraphSAGE的具体操作。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://cdn.jsdelivr.net/gh/swallown1/blogimages@main/images/image-20220423094435223.png" style="zoom:90%;"/>
|
||||
</div>
|
||||
|
||||
上面这个公式可以非常直观的让我们理解GraphSAGE的原理。
|
||||
|
||||
- $h_v^0$表示图上节点的初始化表示，等同于节点自身的特征。
|
||||
- $h_v^k$表示第k层卷积后的节点表示，其来源于两个部分：
|
||||
- 第一部分来源于节点v的邻居节点集合$N(v)$，利用邻居节点的第k-1层卷积后的特征$h_u^{k-1}$进行 （ $\sum_{u \in N(v)} \frac{h_u^{k-1}}{|N(v)|}$ ）后，在进行线性变换。这里**借助图上的边将邻居节点的信息通过边关系聚合到节点表示中(简称卷积操作)**。
|
||||
- 第二部分来源于节点v的第k-1成卷积后的特征$h_v^{k-1}$，进行线性变换。总的来说图卷积的思想是**在对自身做多次非线性变换时，同时利用边关系聚合邻居节点信息。**
|
||||
- 最后一次卷积结果作为节点的最终表示$Z_v$，以用于下游任务(节点分类，链路预测或节点召回)。
|
||||
|
||||
可以发现相比传统的方法(MLP，CNN，DeepWalk 或 EGES)，GCN或GraphSAGE存在一些优势：
|
||||
|
||||
1. 相比于传统的深度学习方法(MLP,CNN)，GCN在对自身节点进行非线性变换时，同时考虑了图中的邻接关系。从CNN的角度理解，GCN通过堆叠多层结构在图结构数据上拥有更大的**感受野**，利用更加广域内的信息。
|
||||
2. 相比于图嵌入学习方法(DeepWalk，EGES)，GCN在学习节点表示的过程中，在利用节点自身的属性信息之外，更好的利用图结构上的边信息。相比于借助随机采样的方式来使用边信息，GCN的方式能从全局的角度利用的邻居信息。此外，类似于GraphSAGE这种归纳(inductive)学习的GCN方法，通过学习聚合节点邻居生成节点Embedding的函数的方式，更适用于图结构和节点会不断变化的工业场景。
|
||||
|
||||
在采样得到目标节点的邻居集之后，那么如何聚合邻居节点的信息来更新目标节点的嵌入表示呢？下面就来看看GraphSAGE中提及的四个聚合函数。
|
||||
|
||||
## GraphSAGE的采样和聚合
|
||||
|
||||
通过上面的公式可以知道，得到节点的表示主要依赖于两部分，其中一部分其邻居节点。因此对于GraphSAGE的关键主要分为两步：Sample采样和Aggregate聚合。其中Sample的作用是从庞大的邻居节点中选出用于聚合的邻居节点集合$N(v)$以达到降低迭代计算复杂度，而聚合操作就是如何利用邻居节点的表示来更新节点v的表示，已达到聚合作用。具体的过程如下伪代码所示：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://cdn.jsdelivr.net/gh/swallown1/blogimages@main/images/image-20220406135753358.png" style="zoom:90%;"/>
|
||||
</div>
|
||||
|
||||
GraphSAGE的minibatch算法的思路是针对Batch内的所有节点，通过采样和聚合节点，为每一个节点学习一个embedding。
|
||||
|
||||
#### 邻居采样
|
||||
|
||||
GraphSAGE的具体采样过程是，首先根据中心节点集合$B^k$，对集合中每个中心节点通过随机采样的方式对其邻居节点采样固定数量S个(如果邻居节点数量大于S，采用无放回抽样；如果小于S，则采用有放回抽样)，形成的集合表示为$B^{k-1}$；以此类推每次都是为前一个得到的集合的每个节点随机采样S个邻居，最终得到第k层的所有需要参与计算的节点集合$B^{0}$。值得注意的有两点：**为什么需要采样并且固定采样数量S？** **为什么第k层所采样的节点集合表示为$B^0$？**
|
||||
|
||||
进行邻居采样并固定采样数量S主要是因为：1. 采样邻居节点避免了在全图的搜索以及使用全部邻居节点所导致计算复杂度高的问题；2. 可以通过采样使得部分节点更同质化，即两个相似的节点具有相同表达形式。3. 采样固定数量是保持每个batch的计算占用空间是固定的，方便进行批量训练。
|
||||
|
||||
第k层所采样的节点集合表示为$B^0$主要是因为：采样和聚合过程是相反的，即采样时我们是从中心节点组层进行采样，而聚合的过程是从中心节点的第k阶邻居逐层聚合得到前一层的节点表示。因此可以认为聚合阶段是：将k阶邻居的信息聚合到k-1阶邻居上，k-1阶邻居的信息聚合到k-2阶邻居上，....，1阶邻居的信息聚合到中心节点上的过程。
|
||||
|
||||
#### 聚合函数
|
||||
|
||||
如何对于采样到的节点集进行聚合，介绍的4种方式：Mean 聚合、Convolutional 聚合、LSTM聚合以及Pooling聚合。由于邻居节点是无序的，所以希望构造的聚合函数具有**对称性(即输出的结果不因输入排序的不同而改变)**，同时拥有**较强的表达能力**。
|
||||
|
||||
- Mean 聚合：首先会对邻居节点按照**element-wise**进行均值聚合，然后将当前节点k-1层得到特征$h_v^{k-1}$与邻居节点均值聚合后的特征 $MEAN(h_u^k | u\in N(v))$**分别**送入全连接网络后**相加**得到结果。
|
||||
- Convolutional 聚合：这是一种基于GCN聚合方式的变种，首先对邻居节点特征和自身节点特征求均值，得到的聚合特征送入到全连接网络中。与Mean不同的是，这里**只经过一个全连接层**。
|
||||
|
||||
- LSTM聚合：由于LSTM可以捕捉到序列信息，因此相比于Mean聚合，这种聚合方式的**表达能力更强**；但由于LSTM对于输入是有序的，因此该方法不具备**对称性**。作者对于无序的节点进行随机排列以调整LSTM所需的有序性。
|
||||
- Pooling聚合：对于邻居节点和中心节点进行一次非线性转化，将结果进行一次基于**element-wise**的**最大池化**操作。该种方式具有**较强的表达能力**的同时还具有**对称性**。
|
||||
|
||||
综上，可以发现GraphSAGE之所以可以用于大规模的工业场景，主要是因为模型主要是通过学习聚合函数，通过归纳式的学习方法为节点学习特征表示。接下来看看PinSAGE 的主要内容。
|
||||
|
||||
## PinSAGE
|
||||
|
||||
### 背景
|
||||
|
||||
PinSAGE 模型是Pinterest 在GraphSAGE 的基础上实现的可以应用于实际工业场景的召回算法。Pinterest 公司的主要业务是采用瀑布流的形式向用户展现图片，无需用户翻页，新的图片会自动加载。因此在Pinterest网站上，有大量的图片(被称为pins)，而用户可以将喜欢的图片分类，即将pins钉在画板 boards上。可以发现基于这样的场景，pin相当于普通推荐场景中item，用户**钉**的行为可以认为是用于的交互行为。于是PinSAGE 模型主要应用的思路是，基于GraphSAGE 的原理学习到聚合方法，并为每个图片(pin)学习一个向量表示，然后基于pin的向量表示做**item2item的召回**。
|
||||
|
||||
可以知道的是，PinSAGE 是在GraphSAGE的基础上进行改进以适应实际的工业场景，因此除了改进卷积操作中的邻居采样策略以及聚合函数的同时还有一些工程技巧上的改进，使得在大数据场景下能更快更好的进行模型训练。因此在了解GraphSAGE的原理后，我们详细的了解一下本文的主要改进以及与GraphSAGE的区别。
|
||||
|
||||
### 重要性采样
|
||||
|
||||
在实际场景当中，一个item可能被数以百万，千万的用户交互过，所以不可能聚合所有邻居节点是不可行的，只可能是采样部分邻居进行信息聚合。但是如果采用GraphSAGE中随机采样的方法，由于采样的邻居有限(这里是相对于所有节点而言)，会存在一定的偏差。因此PinSAGE 在采样中考虑了更加重要的邻居节点，即卷积时只注重部分重要的邻居节点信息，已达到高效计算的同时又可以消除偏置。
|
||||
|
||||
PinSAGE使用重要性采样方法，即需要为每个邻居节点计算一个重要性权重，根据权重选取top-t的邻居作为聚合时的邻居集合。其中计算重要性的过程是，以目标节点为起点，进行random-walk，采样结束之后计算所有节点访问数的L1-normalized作为重要性权重，同时这个权重也会在聚合过程中加以使用(**加权聚合**)。
|
||||
|
||||
这里对于**计算权重之后如何得到top-t的邻居节点，**原文并没有直接的叙述。这里可以有两种做法，第一种就是直接采用重要权重，这种方法言简意赅，比较直观。第二种做法就是对游走得到的所有邻居进行随机抽样，而计算出的权重可以用于聚合阶段。个人理解第二种做法的可行性出于两点原因，其一是这样方法可以避免存在一些item由于权重系数低永远不会被选中的问题；其二可能并不是将所有重要性的邻居进行聚合更合理，毕竟重要性权重是通过随机采样而得到的，具有一定的随机性。当然以上两种方法都是可行的方案，可以通过尝试看看具体哪种方法会更有效。
|
||||
|
||||
### 聚合函数
|
||||
|
||||
PinSAGE中提到的Convolve算法（单层图卷积操作）相当于GraphSAGE算法的聚合过程，在实际执行过程中通过对每一层执行一次图卷积操作以得到不同阶邻居的信息，具体过程如下图所示：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://cdn.jsdelivr.net/gh/swallown1/blogimages@main/images/image-20220406202027832.png" style="zoom:110%;"/>
|
||||
</div>
|
||||
|
||||
上述的单层图卷积过程如下三步：
|
||||
|
||||
1. 聚合邻居： 先将所有的邻居节点经过一次非线性转化(一层DNN)，再由聚合函数(Pooling聚合) $\gamma$（如元素平均，**加权和**等）将所有邻居信息聚合成目标节点的embedding。这里的加权聚合采用的是通过random-walk得到的重要性权重。
|
||||
2. 更新当前节点的embedding：将目标节点当前的向量 $z_u$ 与步骤1中聚合得到的邻居向量 $n_u$ 进行拼接，在通过一次非线性转化。
|
||||
3. 归一化操作：对目标节点向量 $z_u$ 归一化。
|
||||
|
||||
Convolve算法的聚合方法与GraphSAGE的Pooling聚合函数相同，主要区别在于对更新得到的向量 $z_u$ 进行归一化操作，**可以使训练更稳定，以及在近似查找最近邻的应用中更有效率。**
|
||||
|
||||
### 基于**mini-batch**堆叠多层图卷积
|
||||
|
||||
与GraphSAGE类似，采用的是基于mini-batch 的方式进行训练。之所以这么做的原因是因为什么呢？在实际的工业场景中，由于用户交互图非常庞大，无法对于所有的节点同时学习一个embedding，因此需要从原始图上寻找与 mini-batch 节点相关的子图。具体地是说，对于mini-batch内的所有节点，会通过采样的方式逐层的寻找相关邻居节点，再通过对每一层的节点做一次图卷积操作，以从k阶邻居节点聚合信息。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://cdn.jsdelivr.net/gh/swallown1/blogimages@main/images/image-20220406204431024.png" style="zoom:60%;"/>
|
||||
</div>
|
||||
|
||||
如上图所示：对于batch内的所有节点(图上最顶层的6个节点)，依次根据权重采样，得到batch内所有节点的一阶邻居(图上第二层的所有节点)；然后对于所有一阶邻居再次进行采样，得到所有二阶邻居(图上的最后一层)。节点采样阶段完成之后，与采样的顺序相反进行聚合操作。首先对二阶邻居进行单次图卷积，将二阶节点信息聚合已更新一阶节点的向量表示(其中小方块表示的是一层非线性转化)；其次对一阶节点再次进行图卷积操作，将一阶节点的信息聚合已更新batch内所有节点的向量表示。仅此对于一个batch内的所有的样本通过卷积操作学习到一个embedding，而每一个batch的学习过程中仅**利用与mini-batch内相关节点的子图结构。**
|
||||
|
||||
### **训练过程**
|
||||
|
||||
PinSage在训练时采用的是 Margin Hinge Loss 损失函数，主要的思想是最大化正例embedding之间的相关性，同时还要保证负例之间相关性相比正例之间的相关性小于某个阈值(Margin)。具体的公式如下：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://cdn.jsdelivr.net/gh/swallown1/blogimages@main/images/image-20220406210833675.png" style="zoom:100%;"/>
|
||||
</div>
|
||||
|
||||
其中$Z_p$是学习得到的目标节点embedding，$Z_i$是与目标节点相关item的embedding，$Z_{n_k}$是与目标节点不相关item的embedding，$\Delta$为margin值，具体大小需要调参。那么对于相关节点i，以及不相关节点nk，具体都是如何定义的，这对于召回模型的训练意义重大，让我们看看具体是如何定义的。
|
||||
|
||||
对于正样本而言，文中的定义是如果用户在点击的 item q之后立即点击了 item i，即认为 < q, i >构成正样本对。直观的我们很好理解这句话，不过在参考DGL中相关代码实现时，发现这部分的内容和原文中有一定的出入。具体地，代码中将所有的训练样本构造成用户-项目二部图，然后对batch内的每个 item q，根据item-user-item的元路径进行随机游走，得到被同一个用户交互过的 item i，因此组成<q,i>正样本对。对于负样本部分，相对来说更为重要，因此内容相对比较多，将在下面的负样本生成部分详细介绍。
|
||||
|
||||
这里还有一个比较重要的细节需要注意，由于模型是用于 item to item的召回，因此优化目标是与正样本之间的表示尽可能的相近，与负样本之间的表示尽可能的远。而图卷积操作会使得具有邻接关系的节点表示具有同质性，因此结合这两点，就需要在构建图结构的时，要将**训练样本之间可能存在的边在二部图上删除**，避免因为边的存在使得因卷积操作而导致的信息泄露。
|
||||
|
||||
### 工程技巧
|
||||
|
||||
由于PinSAGE是一篇工业界的论文，其中会涉及与实际工程相关的内容，这里在了解完算法思想之后，再从实际落地的角度看看PinSAGE给我们介绍的工程技巧。
|
||||
|
||||
**负样本的生成**
|
||||
|
||||
召回模型最主要的任务是从候选集合中选出用户可能感兴趣的item，直观的理解就是让模型将用户喜欢的和不喜欢的进行区分。然而由于候选集合的庞大数量，许多item之间十分相似，导致模型划分出来用户喜欢的item中会存在一些难以区分的item(即与用户非常喜欢item比较相似的那一部分)。因此对于召回模型不仅能区分用户喜欢和不喜欢的 item，同时还能区分与用户喜欢的 item 十分相似的那一部分item。那么如果做到呢？这主要是交给 easy negative examples 和 hard negative examples 两种负样本给模型学习。
|
||||
|
||||
- easy 负样本：这里对于mini-batch内的所有pair(训练样本对)会共享500负样本，这500个样本从batch之外的所有节点中随机采样得到。这么做可以减少在每个mini-batch中因计算所有节点的embedding所需的时间，文中指出这和为每个item采样一定数量负样本无差异。
|
||||
- hard 负样本：这里使用hard 负样本的原因是根据实际场景的问题出发，模型需要从20亿的物品item集合中识别出最相似的1000个，即模型需要从2百万 item 中识别出最相似的那一个 item。也就是说模型的区分能力不够细致，为了解决这个问题，加入了一些hard样本。对于hard 负样本，应该是与 q 相似 以及和 i 不相似的物品，具体地的生成方式是将图上的节点计算相对节点 q 的个性化PageRank分值，根据分值的排序随机从2000~5000的位置选取节点作为负样本。
|
||||
|
||||
负样本的构建是召回模型的中关键的内容，在各家公司的工作都予以体现，具体的大家可以参考 Facebook 发表的[《Embedding-based Retrieval in Facebook Search》](https://arxiv.org/pdf/2006.11632v1.pdf)
|
||||
|
||||
**渐进式训练(Curriculum training)**
|
||||
|
||||
由于hard 负样本的加入，模型的训练时间加长（由于与q过于相似，导致loss比较小，导致梯度更新的幅度比较小，训练起来比较慢），那么渐进式训练就是为了来解决这个问题。
|
||||
|
||||
如何渐进式：先在第一轮训练使用easy 负样本，帮助模型先快速收敛(先让模型有个最基本的分辨能力)到一定范围，然后在逐步分加入hard负样本(方式是在第n轮训练时给每个物品的负样本集合增加n-1个 hard 负样本)，以调整模型细粒度的区分能力(让模型能够区分相似的item)。
|
||||
|
||||
**节点特征(side information)**
|
||||
|
||||
这里与EGES的不同，这里的边信息不是端到端训练得到，而是通过事前的预处理得到的。对于每个节点(即 pin)，都会有一个图片和一点文本信息。因此对于每个节点使用图片的向量、文字的向量以及节点的度拼接得到。这里其实也解释了为什么在图卷积操作时，会先进行一个非线性转化，其实就是将不同空间的特征进行转化(融合)。
|
||||
|
||||
**构建 mini-batch**
|
||||
|
||||
不同于常规的构建方式，PinSAGE中构建mini-batch的方式是基于生产者消费者模式。什么意思的，就是将CPU和GPU分开工作，让CPU负责取特征，重建索引，邻接列表，负采样等工作，让GPU进行矩阵运算，即CPU负责生产每个batch所需的所有数据，GPU则根据CPU生产的数据进行消费(运算)。这样由于考虑GPU的利用率，无法将所有特征矩阵放在GPU，只能存在CPU中，然而每次查找会导致非常耗时，通过上面的方式使得图卷积操作过程中就没有GPU与CPU的通信需求。
|
||||
|
||||
**多GPU训练超大batch**
|
||||
|
||||
前向传播过程中，各个GPU等分minibatch，共享一套模型参数；反向传播时，将每个GPU中的参数梯度都聚合到一起，同步执行SGD。为了保证因海量数据而使用的超大batchsize的情况下模型快速收敛以及泛化精度，采用warmup过程，即在第一个epoch中将学习率线性提升到最高，后面的epoch中再逐步指数下降。
|
||||
|
||||
**使用MapReduce高效推断**
|
||||
|
||||
在模型训练结束之后，需要为所有节点计算一个embedding，如果按照训练过程中的前向传播过程来生成，会存在大量重复的计算。因为当计算一个节点的embedding的时候，其部分邻居节点已经计算过了，同时如果该节点作为其他节点邻居时，也会被再次计算。针对这个问题，本文采用MapReduce的方法进行推断。该过程主要分为两步，具体如下图所示：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://cdn.jsdelivr.net/gh/swallown1/blogimages@main/images/image-20220407132111547.png" style="zoom:60%;"/>
|
||||
</div>
|
||||
|
||||
1. 将item的embedding进行聚合，即利用item的图片、文字和度等信息的表示进行join(拼接)，在通过一层dense后得到item的低维向量。
|
||||
2. 然后根据item来匹配其一阶邻居(join)，然后根据item进行pooling(其实就是GroupBy pooling)，得到一次图卷积操作。通过堆叠多次直接得到全量的embedding。
|
||||
|
||||
其实这块主要就是通过MapReduce的大数据处理能力，直接对全量节点进行一次运算得到其embedding，避免了分batch所导致的重复计算。
|
||||
|
||||
## 代码解析
|
||||
|
||||
了解完基本的原理之后，最关键的还是得解析源码，以证实上面讲的细节的准确性。下面基于DGL中实现的代码，看看模型中的一些细节。
|
||||
|
||||
### 数据处理
|
||||
|
||||
在弄清楚模型之前，最重要的就是知道送入模型的数据到底是什么养的，以及PinSAGE相对于GraphSAGE最大的区别就在于如何采样邻居，如何构建负样本等。
|
||||
|
||||
首先需要明确的是，无论是**邻居采样**还是**样本的构造**都发生在图结构上，因此最主要的是需要先构建一个user和item组成的二部图。
|
||||
|
||||
```python
|
||||
# ratings是所有的用户交互
|
||||
# 过滤掉为出现在交互中的用户和项目
|
||||
distinct_users_in_ratings = ratings['user_id'].unique()
|
||||
distinct_movies_in_ratings = ratings['movie_id'].unique()
|
||||
users = users[users['user_id'].isin(distinct_users_in_ratings)]
|
||||
movies = movies[movies['movie_id'].isin(distinct_movies_in_ratings)]
|
||||
|
||||
# 将电影特征分组 genres (a vector), year (a category), title (a string)
|
||||
genre_columns = movies.columns.drop(['movie_id', 'title', 'year'])
|
||||
movies[genre_columns] = movies[genre_columns].fillna(False).astype('bool')
|
||||
movies_categorical = movies.drop('title', axis=1)
|
||||
|
||||
## 构建图
|
||||
graph_builder = PandasGraphBuilder()
|
||||
graph_builder.add_entities(users, 'user_id', 'user') # 添加user类型节点
|
||||
graph_builder.add_entities(movies_categorical, 'movie_id', 'movie') # 添加movie类型节点
|
||||
|
||||
# 构建用户-电影的无向图
|
||||
graph_builder.add_binary_relations(ratings, 'user_id', 'movie_id', 'watched')
|
||||
graph_builder.add_binary_relations(ratings, 'movie_id', 'user_id', 'watched-by')
|
||||
|
||||
g = graph_builder.build()
|
||||
```
|
||||
|
||||
在构建完原图之后，需要将交互数据(ratings)分成训练集和测试集，然后根据测试集从原图中抽取出与训练集中相关节点的子图。
|
||||
|
||||
```python
|
||||
# train_test_split_by_time 根据时间划分训练集和测试集
|
||||
# 将用户的倒数第二次交互作为验证，最后一次交互用作测试
|
||||
# train_indices 为用于训练的用户与电影的交互
|
||||
train_indices, val_indices, test_indices = train_test_split_by_time(ratings, 'timestamp', 'user_id')
|
||||
|
||||
# 只使用训练交互来构建图形，测试集相关的节点不应该出现在训练过程中。
|
||||
# 从原图中提取与训练集相关节点的子图
|
||||
train_g = build_train_graph(g, train_indices, 'user', 'movie', 'watched', 'watched-by')
|
||||
```
|
||||
|
||||
|
||||
|
||||
### 正负样本采样
|
||||
|
||||
在得到训练图结构之后，为了进行PinSAGE提出的item2item召回任务，需要构建相应的训练样本。对于训练样本主要是构建正样本对和负样本对，前面我们已经提到了正样本对是基于 item to user to item的随即游走得到的；对于负样本DGL的实现主要是随机采样，即只有easy sample，未实现hard sample。具体地，DGL中主要是通过sampler_module.ItemToItemBatchSampler方法进行采样，主要代码如下：
|
||||
|
||||
```python
|
||||
class ItemToItemBatchSampler(IterableDataset):
|
||||
def __init__(self, g, user_type, item_type, batch_size):
|
||||
self.g = g
|
||||
self.user_type = user_type
|
||||
self.item_type = item_type
|
||||
self.user_to_item_etype = list(g.metagraph()[user_type][item_type])[0]
|
||||
self.item_to_user_etype = list(g.metagraph()[item_type][user_type])[0]
|
||||
self.batch_size = batch_size
|
||||
|
||||
def __iter__(self):
|
||||
while True:
|
||||
# 随机采样batch_size个节点作为head 即论文中的q
|
||||
heads = torch.randint(0, self.g.number_of_nodes(self.item_type), (self.batch_size,))
|
||||
|
||||
# 本次元路径表示从item游走到user，再从user游走到item，总共二跳，取出二跳节点(电影节点)作为tails(即正样本)
|
||||
# 得到与heads被同一个用户消费过的其他item，做正样本
|
||||
# 这么做可能存在问题，
|
||||
# 1. 这种游走肯定会使正样本集中于少数热门item；
|
||||
# 2. 如果item只被一个用户消费过，二跳游走岂不是又回到起始item，这种case还是要处理的
|
||||
tails = dgl.sampling.random_walk(
|
||||
self.g,
|
||||
heads,
|
||||
metapath=[self.item_to_user_etype, self.user_to_item_etype])[0][:, 2]
|
||||
|
||||
# 随机采样做负样本， 没有hard negative
|
||||
# 这么做会存在被同一个用户交互过的movie也会作为负样本
|
||||
neg_tails = torch.randint(0, self.g.number_of_nodes(self.item_type), (self.batch_size,))
|
||||
|
||||
mask = (tails != -1)
|
||||
yield heads[mask], tails[mask], neg_tails[mask]
|
||||
```
|
||||
|
||||
上面的样本采样过程只是一个简单的示例，如果面对实际问题，需要自己来重新完成这部分的内容。
|
||||
|
||||
### 邻居节点采样
|
||||
|
||||
再得到训练样本之后，接下来主要是在训练图上，为heads节点采用其邻居节点。在DGL中主要是通过sampler_module.NeighborSampler来实现，具体地，通过**sample_blocks**方法回溯生成各层卷积需要的block，即所有的邻居集合。其中需要注意的几个地方，基于随机游走的重要邻居采样，DGL已经实现，具体参考**[dgl.sampling.PinSAGESampler](https://docs.dgl.ai/generated/dgl.sampling.PinSAGESampler.html)**，其次避免信息泄漏，代码中，先将head → tails,head → neg_tails从frontier中先删除，再生成block。
|
||||
|
||||
```python
|
||||
class NeighborSampler(object): # 图卷积的邻居采样
|
||||
def __init__(self, g, user_type, item_type, random_walk_length, random_walk_restart_prob,
|
||||
num_random_walks, num_neighbors, num_layers):
|
||||
self.g = g
|
||||
self.user_type = user_type
|
||||
self.item_type = item_type
|
||||
self.user_to_item_etype = list(g.metagraph()[user_type][item_type])[0]
|
||||
self.item_to_user_etype = list(g.metagraph()[item_type][user_type])[0]
|
||||
|
||||
# 每层都有一个采样器，根据随机游走来决定某节点邻居的重要性(主要的实现已封装在PinSAGESampler中)
|
||||
# 可以认为经过多次游走，落脚于某邻居节点的次数越多，则这个邻居越重要，就更应该优先作为邻居
|
||||
self.samplers = [
|
||||
dgl.sampling.PinSAGESampler(g, item_type, user_type, random_walk_length,
|
||||
random_walk_restart_prob, num_random_walks, num_neighbors)
|
||||
for _ in range(num_layers)]
|
||||
|
||||
def sample_blocks(self, seeds, heads=None, tails=None, neg_tails=None):
|
||||
"""根据随机游走得到的重要性权重，进行邻居采样"""
|
||||
blocks = []
|
||||
for sampler in self.samplers:
|
||||
frontier = sampler(seeds) # 通过随机游走进行重要性采样，生成中间状态
|
||||
if heads is not None:
|
||||
# 如果是在训练，需要将heads->tails 和 head->neg_tails这些待预测的边都去掉
|
||||
eids = frontier.edge_ids(torch.cat([heads, heads]), torch.cat([tails, neg_tails]), return_uv=True)
|
||||
|
||||
if len(eids) > 0:
|
||||
old_frontier = frontier
|
||||
frontier = dgl.remove_edges(old_frontier, eids)
|
||||
|
||||
# 只保留seeds这些节点，将frontier压缩成block
|
||||
# 并设置block的input/output nodes
|
||||
block = compact_and_copy(frontier, seeds)
|
||||
|
||||
# 本层的输入节点就是下一层的seeds
|
||||
seeds = block.srcdata[dgl.NID]
|
||||
blocks.insert(0, block)
|
||||
return blocks
|
||||
```
|
||||
|
||||
其次**sample_from_item_pairs**方法是通过上面得到的heads, tails, neg_tails分别构建基于正样本对以及基于负样本对的item-item图。由heads→tails生成的pos_graph，用于计算pairwise loss中的pos_score，由heads→neg_tails生成的neg_graph，用于计算pairwise loss中的neg_score。
|
||||
|
||||
```python
|
||||
class NeighborSampler(object): # 图卷积的邻居采样
|
||||
def __init__(self, g, user_type, item_type, random_walk_length, ....):
|
||||
pass
|
||||
|
||||
def sample_blocks(self, seeds, heads=None, tails=None, neg_tails=None):
|
||||
pass
|
||||
|
||||
def sample_from_item_pairs(self, heads, tails, neg_tails):
|
||||
# 由heads->tails构建positive graph， num_nodes设置成原图中所有item节点
|
||||
pos_graph = dgl.graph(
|
||||
(heads, tails),
|
||||
num_nodes=self.g.number_of_nodes(self.item_type))
|
||||
|
||||
# 由heads->neg_tails构建negative graph，num_nodes设置成原图中所有item节点
|
||||
neg_graph = dgl.graph(
|
||||
(heads, neg_tails),
|
||||
num_nodes=self.g.number_of_nodes(self.item_type))
|
||||
|
||||
# 去除heads, tails, neg_tails以外的节点，将大图压缩成小图，避免与本轮训练不相关节点的结构也传入模型，提升计算效率
|
||||
pos_graph, neg_graph = dgl.compact_graphs([pos_graph, neg_graph])
|
||||
|
||||
# 压缩后的图上的节点是原图中的编号
|
||||
# 注意这时pos_graph与neg_graph不是分开编号的两个图，它们来自于同一幅由heads, tails, neg_tails组成的大图
|
||||
# pos_graph和neg_graph中的节点相同，都是heads+tails+neg_tails，即这里的seeds，pos_graph和neg_graph只是边不同而已
|
||||
seeds = pos_graph.ndata[dgl.NID] # 字典 不同类型节点为一个tensor，为每个节点的id值
|
||||
|
||||
blocks = self.sample_blocks(seeds, heads, tails, neg_tails)
|
||||
return pos_graph, neg_graph, blocks
|
||||
```
|
||||
|
||||
|
||||
|
||||
### PinSAGE
|
||||
|
||||
在得到所有所需的数据之后，看看模型结构。其中主要分为三个部分:**节点特征映射**，**多层卷积模块 **和 **给边打分**。
|
||||
|
||||
```python
|
||||
class PinSAGEModel(nn.Module):
|
||||
def __init__(self, full_graph, ntype, textsets, hidden_dims, n_layers):
|
||||
super().__init__()
|
||||
# 负责将节点上的各种特征都映射成向量，并聚合在一起，形成这个节点的原始特征向量
|
||||
self.proj = layers.LinearProjector(full_graph, ntype, textsets, hidden_dims)
|
||||
# 负责多层图卷积，得到各节点最终的embedding
|
||||
self.sage = layers.SAGENet(hidden_dims, n_layers)
|
||||
# 负责根据首尾两端的节点的embedding，计算边上的得分
|
||||
self.scorer = layers.ItemToItemScorer(full_graph, ntype)
|
||||
|
||||
def forward(self, pos_graph, neg_graph, blocks):
|
||||
""" pos_graph, neg_graph, blocks 的最后一层都对应batch中 heads+tails+neg_tails 这些节点
|
||||
"""
|
||||
# 得到batch中heads+tails+neg_tails这些节点的最终embedding
|
||||
h_item = self.get_repr(blocks)
|
||||
# 得到heads->tails这些边上的得分
|
||||
pos_score = self.scorer(pos_graph, h_item)
|
||||
# 得到heads->neg_tails这些边上的得分
|
||||
neg_score = self.scorer(neg_graph, h_item)
|
||||
# pos_graph与neg_graph边数相等，因此neg_score与pos_score相减
|
||||
# 返回margin hinge loss，这里的margin是1
|
||||
return (neg_score - pos_score + 1).clamp(min=0)
|
||||
|
||||
def get_repr(self, blocks):
|
||||
"""
|
||||
通过self.sage，经过多层卷积，得到输出节点上的卷积结果，再加上这些输出节点上原始特征的映射结果
|
||||
得到输出节点上最终的向量表示
|
||||
"""
|
||||
h_item = self.proj(blocks[0].srcdata) # 将输入节点上的原始特征映射成hidden_dims长的向量
|
||||
h_item_dst = self.proj(blocks[-1].dstdata) # 将输出节点上的原始特征映射成hidden_dims长的向量
|
||||
return h_item_dst + self.sage(blocks, h_item)
|
||||
```
|
||||
|
||||
**节点特征映射：**由于节点使用到了多种类型（int,float array,text）的原始特征，这里使用了一个DNN层来融合成固定的长度。
|
||||
|
||||
```python
|
||||
class LinearProjector(nn.Module):
|
||||
def __init__(self, full_graph, ntype, textset, hidden_dims):
|
||||
super().__init__()
|
||||
self.ntype = ntype
|
||||
# 初始化参数,这里为全图中所有节点特征初始化
|
||||
# 如果特征类型是float，就定义一个nn.Linear线性变化为指定维度
|
||||
# 如果特征类型是int，就定义Embedding矩阵，将id型特征转化为向量
|
||||
self.inputs = _init_input_modules(full_graph, ntype, textset, hidden_dims)
|
||||
|
||||
def forward(self, ndata):
|
||||
projections = []
|
||||
for feature, data in ndata.items():
|
||||
# NID是计算子图中节点、边在原图中的编号，没必要用做特征
|
||||
if feature == dgl.NID:
|
||||
continue
|
||||
module = self.inputs[feature] # 根据特征名取出相应的特征转化器
|
||||
# 对文本属性进行处理
|
||||
if isinstance(module, (BagOfWords, BagOfWordsPretrained)):
|
||||
length = ndata[feature + '__len']
|
||||
result = module(data, length)
|
||||
else:
|
||||
result = module(data) # look_up
|
||||
projections.append(result)
|
||||
|
||||
# 将每个特征都映射后的hidden_dims长的向量，element-wise相加
|
||||
return torch.stack(projections, 1).sum(1) # [nodes, hidden_dims]
|
||||
```
|
||||
|
||||
**多层卷积模块：**根据采样得到的节点blocks，然后通过进行逐层卷积，得到各节点最终的embedding。
|
||||
|
||||
```python
|
||||
class SAGENet(nn.Module):
|
||||
def __init__(self, hidden_dims, n_layers):
|
||||
"""g : 二部图"""
|
||||
super().__init__()
|
||||
self.convs = nn.ModuleList()
|
||||
for _ in range(n_layers):
|
||||
self.convs.append(WeightedSAGEConv(hidden_dims, hidden_dims, hidden_dims))
|
||||
|
||||
def forward(self, blocks, h):
|
||||
# 这里根据邻居节点进逐层聚合
|
||||
for layer, block in zip(self.convs, blocks):
|
||||
h_dst = h[:block.number_of_nodes('DST/' + block.ntypes[0])] #前一次卷积的结果
|
||||
h = layer(block, (h, h_dst), block.edata['weights'])
|
||||
return h
|
||||
```
|
||||
|
||||
其中WeightedSAGEConv为根据邻居权重的聚合函数。
|
||||
|
||||
```python
|
||||
class WeightedSAGEConv(nn.Module):
|
||||
def __init__(self, input_dims, hidden_dims, output_dims, act=F.relu):
|
||||
super().__init__()
|
||||
self.act = act
|
||||
self.Q = nn.Linear(input_dims, hidden_dims)
|
||||
self.W = nn.Linear(input_dims + hidden_dims, output_dims)
|
||||
self.reset_parameters()
|
||||
self.dropout = nn.Dropout(0.5)
|
||||
|
||||
def reset_parameters(self):
|
||||
gain = nn.init.calculate_gain('relu')
|
||||
nn.init.xavier_uniform_(self.Q.weight, gain=gain)
|
||||
nn.init.xavier_uniform_(self.W.weight, gain=gain)
|
||||
nn.init.constant_(self.Q.bias, 0)
|
||||
nn.init.constant_(self.W.bias, 0)
|
||||
|
||||
def forward(self, g, h, weights):
|
||||
"""
|
||||
g : 基于batch的子图
|
||||
h : 节点特征
|
||||
weights : 边的权重
|
||||
"""
|
||||
h_src, h_dst = h # 邻居节点特征，自身节点特征
|
||||
with g.local_scope():
|
||||
# 将src节点上的原始特征映射成hidden_dims长，存储于'n'字段
|
||||
g.srcdata['n'] = self.act(self.Q(self.dropout(h_src)))
|
||||
g.edata['w'] = weights.float()
|
||||
|
||||
# src节点上的特征'n'乘以边上的权重，构成消息'm'
|
||||
# dst节点将所有接收到的消息'm'，相加起来，存入dst节点的'n'字段
|
||||
g.update_all(fn.u_mul_e('n', 'w', 'm'), fn.sum('m', 'n'))
|
||||
|
||||
# 将边上的权重w拷贝成消息'm'
|
||||
# dst节点将所有接收到的消息'm'，相加起来，存入dst节点的'ws'字段
|
||||
g.update_all(fn.copy_e('w', 'm'), fn.sum('m', 'ws'))
|
||||
|
||||
# 邻居节点的embedding的加权和
|
||||
n = g.dstdata['n']
|
||||
ws = g.dstdata['ws'].unsqueeze(1).clamp(min=1) # 边上权重之和
|
||||
|
||||
# 先将邻居节点的embedding，做加权平均
|
||||
# 再拼接上一轮卷积后，dst节点自身的embedding
|
||||
# 再经过线性变化与非线性激活，得到这一轮卷积后各dst节点的embedding
|
||||
z = self.act(self.W(self.dropout(torch.cat([n / ws, h_dst], 1))))
|
||||
|
||||
# 本轮卷积后，各dst节点的embedding除以模长，进行归一化
|
||||
z_norm = z.norm(2, 1, keepdim=True)
|
||||
z_norm = torch.where(z_norm == 0, torch.tensor(1.).to(z_norm), z_norm)
|
||||
z = z / z_norm
|
||||
return z
|
||||
```
|
||||
|
||||
**给边打分：** 经过SAGENet得到了batch内所有节点的embedding，这时需要根据学习到的embedding为pos_graph和neg_graph中的每个边打分，即计算正样本对和负样本的內积。具体逻辑是根据两端节点embedding的点积，然后加上两端节点的bias。
|
||||
|
||||
```python
|
||||
class ItemToItemScorer(nn.Module):
|
||||
def __init__(self, full_graph, ntype):
|
||||
super().__init__()
|
||||
n_nodes = full_graph.number_of_nodes(ntype)
|
||||
self.bias = nn.Parameter(torch.zeros(n_nodes, 1))
|
||||
|
||||
def _add_bias(self, edges):
|
||||
bias_src = self.bias[edges.src[dgl.NID]]
|
||||
bias_dst = self.bias[edges.dst[dgl.NID]]
|
||||
# 边上两顶点的embedding的点积，再加上两端节点的bias
|
||||
return {'s': edges.data['s'] + bias_src + bias_dst}
|
||||
|
||||
def forward(self, item_item_graph, h):
|
||||
"""
|
||||
item_item_graph : 每个边 为 pair 对
|
||||
h : 每个节点隐层状态
|
||||
"""
|
||||
with item_item_graph.local_scope():
|
||||
item_item_graph.ndata['h'] = h
|
||||
# 边两端节点的embedding做点积，保存到s
|
||||
item_item_graph.apply_edges(fn.u_dot_v('h', 'h', 's'))
|
||||
# 为每个边加上偏置，即加上两个顶点的偏置
|
||||
item_item_graph.apply_edges(self._add_bias)
|
||||
# 算出来的得分为 pair 的预测得分
|
||||
pair_score = item_item_graph.edata['s']
|
||||
return pair_score
|
||||
```
|
||||
|
||||
### 训练过程
|
||||
|
||||
介绍完“数据处理”和“PinSAGE模块”之后，接下来就是通过训练过程将上述两部分串起来，详细的见代码：
|
||||
|
||||
```python
|
||||
def train(dataset, args):
|
||||
#从dataset中加载数据和原图
|
||||
g = dataset['train-graph']
|
||||
...
|
||||
|
||||
device = torch.device(args.device)
|
||||
# 为节点随机初始化一个id，用于做embedding
|
||||
g.nodes[user_ntype].data['id'] = torch.arange(g.number_of_nodes(user_ntype))
|
||||
g.nodes[item_ntype].data['id'] = torch.arange(g.number_of_nodes(item_ntype))
|
||||
|
||||
|
||||
# 负责采样出batch_size大小的节点列表: heads, tails, neg_tails
|
||||
batch_sampler = sampler_module.ItemToItemBatchSampler(
|
||||
g, user_ntype, item_ntype, args.batch_size)
|
||||
|
||||
# 由一个batch中的heads,tails,neg_tails构建训练这个batch所需要的
|
||||
# pos_graph,neg_graph 和 blocks
|
||||
neighbor_sampler = sampler_module.NeighborSampler(
|
||||
g, user_ntype, item_ntype, args.random_walk_length,
|
||||
args.random_walk_restart_prob, args.num_random_walks, args.num_neighbors,
|
||||
args.num_layers)
|
||||
|
||||
# 每次next()返回: pos_graph,neg_graph和blocks，做训练之用
|
||||
collator = sampler_module.PinSAGECollator(neighbor_sampler, g, item_ntype, textset)
|
||||
dataloader = DataLoader(
|
||||
batch_sampler,
|
||||
collate_fn=collator.collate_train,
|
||||
num_workers=args.num_workers)
|
||||
|
||||
# 每次next()返回blocks，做训练中测试之用
|
||||
dataloader_test = DataLoader(
|
||||
torch.arange(g.number_of_nodes(item_ntype)),
|
||||
batch_size=args.batch_size,
|
||||
collate_fn=collator.collate_test,
|
||||
num_workers=args.num_workers)
|
||||
dataloader_it = iter(dataloader)
|
||||
|
||||
# 准备模型
|
||||
model = PinSAGEModel(g, item_ntype, textset, args.hidden_dims, args.num_layers).to(device)
|
||||
opt = torch.optim.Adam(model.parameters(), lr=args.lr)
|
||||
|
||||
# 训练过程
|
||||
for epoch_id in range(args.num_epochs):
|
||||
model.train()
|
||||
for batch_id in tqdm.trange(args.batches_per_epoch):
|
||||
pos_graph, neg_graph, blocks = next(dataloader_it)
|
||||
for i in range(len(blocks)):
|
||||
blocks[i] = blocks[i].to(device)
|
||||
pos_graph = pos_graph.to(device)
|
||||
neg_graph = neg_graph.to(device)
|
||||
|
||||
loss = model(pos_graph, neg_graph, blocks).mean()
|
||||
opt.zero_grad()
|
||||
loss.backward()
|
||||
opt.step()
|
||||
```
|
||||
|
||||
至此，DGL PinSAGE example的主要实现代码已经全部介绍完了，感兴趣的可以去官网对照源代码自行学习。
|
||||
|
||||
## 参考
|
||||
|
||||
[Graph Convolutional Neural Networks for Web-Scale Recommender Systems](https://arxiv.org/abs/1806.01973)
|
||||
|
||||
[PinSAGE 召回模型及源码分析(1): PinSAGE 简介](https://zhuanlan.zhihu.com/p/275942839)
|
||||
|
||||
[全面理解PinSage](https://zhuanlan.zhihu.com/p/133739758)
|
||||
|
||||
[[论文笔记]PinSAGE——Graph Convolutional Neural Networks for Web-Scale Recommender Systems](https://zhuanlan.zhihu.com/p/461720302)
|
||||
|
||||
415
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.4/MIND.md
Normal file
415
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.4/MIND.md
Normal file
@@ -0,0 +1,415 @@
|
||||
## 写在前面
|
||||
MIND模型(Multi-Interest Network with Dynamic Routing)， 是阿里团队2019年在CIKM上发的一篇paper，该模型依然是用在召回阶段的一个模型，解决的痛点是之前在召回阶段的模型，比如双塔，YouTubeDNN召回模型等，在模拟用户兴趣的时候，总是基于用户的历史点击，最后通过pooling的方式得到一个兴趣向量，用该向量来表示用户的兴趣，但是该篇论文的作者认为，**用一个向量来表示用户的广泛兴趣未免有点太过于单一**，这是作者基于天猫的实际场景出发的发现，每个用户每天与数百种产品互动， 而互动的产品往往来自于很多个类别，这就说明用户的兴趣极其广泛，**用一个向量是无法表示这样广泛的兴趣的**，于是乎，就自然而然的引出一个问题，**有没有可能用多个向量来表示用户的多种兴趣呢？**
|
||||
|
||||
这篇paper的核心是胶囊网络，**该网络采用了动态路由算法能非常自然的将历史商品聚成多个集合，每个集合的历史行为进一步推断对应特定兴趣的用户表示向量。这样，对于一个特定的用户，MND输出了多个表示向量，它们代表了用户的不同兴趣。当用户再有新的交互时，通过胶囊网络，还能实时的改变用户的兴趣表示向量，做到在召回阶段的实时个性化**。那么，胶囊网络究竟是怎么做到的呢？ 胶囊网络又是什么原理呢？
|
||||
|
||||
**主要内容**：
|
||||
* 背景与动机
|
||||
* 胶囊网络与动态路由机制
|
||||
* MIND模型的网络结构与细节剖析
|
||||
* MIND模型之简易代码复现
|
||||
* 总结
|
||||
|
||||
## 背景与动机
|
||||
本章是基于天猫APP的背景来探索十亿级别的用户个性化推荐。天猫的推荐的流程主要分为召回阶段和排序阶段。召回阶段负责检索数千个与用户兴趣相关的候选物品，之后，排序阶段预测用户与这些候选物品交互的精确概率。这篇文章做的是召回阶段的工作，来对满足用户兴趣的物品的有效检索。
|
||||
|
||||
作者这次的出发点是基于场景出发，在天猫的推荐场景中，作者发现**用户的兴趣存在多样性**。平均上，10亿用户访问天猫，每个用户每天与数百种产品互动。交互后的物品往往属于不同的类别，说明用户兴趣的多样性。 一张图片会更加简洁直观：
|
||||
|
||||
|
||||
因此如果能在**召回阶段建立用户多兴趣模型来模拟用户的这种广泛兴趣**，那么作者认为是非常有必要的，因为召回阶段的任务就是根据用户兴趣检索候选商品嘛。
|
||||
|
||||
那么，如何能基于用户的历史交互来学习用户的兴趣表示呢？ 以往的解决方案如下：
|
||||
* 协同过滤的召回方法(itemcf和usercf)是通过历史交互过的物品或隐藏因子直接表示用户兴趣， 但会遇到**稀疏或计算问题**
|
||||
* 基于深度学习的方法用低维的embedding向量表示用户，比如YoutubeDNN召回模型，双塔模型等，都是把用户的基本信息，或者用户交互过的历史商品信息等，过一个全连接层，最后编码成一个向量，用这个向量来表示用户兴趣，但作者认为，**这是多兴趣表示的瓶颈**，因为需要压缩所有与用户多兴趣相关的信息到一个表示向量，所有用户多兴趣的信息进行了混合，导致这种多兴趣并无法体现，所以往往召回回来的商品并不是很准确，除非向量维度很大，但是大维度又会带来高计算。
|
||||
* DIN模型在Embedding的基础上加入了Attention机制，来选择的捕捉用户兴趣的多样性，但采用Attention机制，**对于每个目标物品，都需要重新计算用户表示**，这在召回阶段是行不通的(海量)，所以DIN一般是用于排序。
|
||||
|
||||
所以，作者想在召回阶段去建模用户的多兴趣，但以往的方法都不好使，为了解决这个问题，就提出了动态路由的多兴趣网络MIND。为了推断出用户的多兴趣表示，提出了一个多兴趣提取层，该层使用动态路由机制自动的能将用户的历史行为聚类，然后每个类簇中产生一个表示向量，这个向量能代表用户某种特定的兴趣，而多个类簇的多个向量合起来，就能表示用户广泛的兴趣了。
|
||||
|
||||
这就是MIND的提出动机以及初步思路了，这里面的核心是Multi-interest extractor layer， 而这里面重点是动态路由与胶囊网络，所以接下来先补充这方面的相关知识。
|
||||
|
||||
## 胶囊网络与动态路由机制
|
||||
### 胶囊网络初识
|
||||
Hinton大佬在2011年的时候，就首次提出了"胶囊"的概念， "胶囊"可以看成是一组聚合起来输出整个向量的小神经元组合，这个向量的每个维度(每个小神经元)，代表着某个实体的某个特征。
|
||||
|
||||
胶囊网络其实可以和神经网络对比着看可能更好理解，我们知道神经网络的每一层的神经元输出的是单个的标量值，接收的输入，也是多个标量值，所以这是一种value to value的形式，而胶囊网络每一层的胶囊输出的是一个向量值，接收的输入也是多个向量，所以它是vector to vector形式的。来个图对比下就清楚了：
|
||||
|
||||
|
||||
左边的图是普通神经元的计算示意，而右边是一个胶囊内部的计算示意图。 神经元这里不过多解释，这里主要是剖析右边的这个胶囊计算原理。从上图可以看出， 输入是两个向量$v_1,v_2$，首先经过了一个线性映射，得到了两个新向量$u_1,u_2$，然后呢，经过了一个向量的加权汇总，这里的$c_1$,$c_2$可以先理解成权重，具体计算后面会解释。 得到汇总后的向量$s$，接下来进行了Squash操作，整体的计算公式如下：
|
||||
$$
|
||||
\begin{aligned}
|
||||
&u^{1}=W^{1} v^{1} \quad u^{2}=W^{2} v^{2} \\
|
||||
&s=c_{1} u^{1}+c_{2} u^{2} \\
|
||||
&v=\operatorname{Squash}(s) =\frac{\|s\|^{2}}{1+\|s\|^{2}} \frac{s}{\|s\|}
|
||||
\end{aligned}
|
||||
$$
|
||||
这里的Squash操作可以简单看下，主要包括两部分，右边的那部分其实就是向量归一化操作，把norm弄成1，而左边那部分算是一个非线性操作，如果$s$的norm很大，那么这个整体就接近1， 而如果这个norm很小，那么整体就会接近0， 和sigmoid很像有没有？
|
||||
|
||||
这样就完成了一个胶囊的计算，但有两点需要注意：
|
||||
1. 这里的$W^i$参数是可学习的，和神经网络一样， 通过BP算法更新
|
||||
2. 这里的$c_i$参数不是BP算法学习出来的，而是采用动态路由机制现场算出来的，这个非常类似于pooling层，我们知道pooling层的参数也不是学习的，而是根据前面的输入现场取最大或者平均计算得到的。
|
||||
|
||||
所以这里的问题，就是怎么通过动态路由机制得到$c_i$，下面是动态路由机制的过程。
|
||||
|
||||
### 动态路由机制原理
|
||||
我们先来一个胶囊结构:
|
||||
|
||||
|
||||
这个$c_i$是通过动态路由机制计算得到，那么动态路由机制究竟是啥子意思？ 其实就是通过迭代的方式去计算，没有啥神秘的，迭代计算的流程如下图:
|
||||
|
||||
首先我们先初始化$b_i$，与每一个输入胶囊$u_i$进行对应，这哥们有个名字叫做"routing logit"， 表示的是输出的这个胶囊与输入胶囊的相关性，和注意力机制里面的score值非常像。由于一开始不知道这个哪个胶囊与输出的胶囊有关系，所以默认相关性分数都一样，然后进入迭代。
|
||||
|
||||
在每一次迭代中，首先把分数转成权重，然后加权求和得到$s$，这个很类似于注意力机制的步骤，得到$s$之后，通过归一化操作，得到$a$，接下来要通过$a$和输入胶囊的相关性以及上一轮的$b_i$来更新$b_i$。最后那个公式有必要说一下在干嘛：
|
||||
>如果当前的$a$与某一个输入胶囊$u_i$非常相关，即内积结果很大的话，那么相应的下一轮的该输入胶囊对应的$b_i$就会变大， 那么， 在计算下一轮的$a$的时候，与上一轮$a$相关的$u_i$就会占主导，相当于下一轮的$a$与上一轮中和他相关的那些$u_i$之间的路径权重会大一些，这样从空间点的角度观察，就相当于$a$点朝与它相关的那些$u$点更近了一点。
|
||||
|
||||
通过若干次迭代之后，得到最后的输出胶囊向量$a$会慢慢的走到与它更相关的那些$u$附近，而远离那些与它不相干的$u$。所以上面的这个迭代过程有点像**排除异常输入胶囊的感觉**。
|
||||
|
||||
|
||||
|
||||
而从另一个角度来考虑，这个过程其实像是聚类的过程，因为胶囊的输出向量$v$经过若干次迭代之后，会最终停留到与其非常相关的那些输入胶囊里面，而这些输入胶囊，其实就可以看成是某个类别了，因为既然都共同的和输出胶囊$v$比较相关，那么彼此之间的相关性也比较大，于是乎，经过这样一个动态路由机制之后，就不自觉的，把输入胶囊实现了聚类。把和与其他输入胶囊不同的那些胶囊给排除了出去。
|
||||
|
||||
所以，这个动态路由机制的计算设计的还是比较巧妙的， 下面是上述过程的展开计算过程， 这个和RNN的计算有点类似：
|
||||
|
||||
这样就完成了一个胶囊内部的计算过程了。
|
||||
|
||||
Ok， 有了上面的这些铺垫，再来看MIND就会比较简单了。下面正式对MIND模型的网络架构剖析。
|
||||
|
||||
## MIND模型的网络结构与细节剖析
|
||||
### 网络整体结构
|
||||
MIND网络的架构如下：
|
||||
|
||||
初步先分析这个网络结构的运作： 首先接收的输入有三类特征，用户base属性，历史行为属性以及商品的属性，用户的历史行为序列属性过了一个多兴趣提取层得到了多个兴趣胶囊，接下来和用户base属性拼接过DNN，得到了交互之后的用户兴趣。然后在训练阶段，用户兴趣和当前商品向量过一个label-aware attention，然后求softmax损失。 在服务阶段，得到用户的向量之后，就可以直接进行近邻检索，找候选商品了。 这就是宏观过程，但是，多兴趣提取层以及这个label-aware attention是在做什么事情呢？ 如果单独看这个图，感觉得到多个兴趣胶囊之后，直接把这些兴趣胶囊以及用户的base属性拼接过全连接，那最终不就成了一个用户向量，此时label-aware attention的意义不就没了？ 所以这个图初步感觉画的有问题，和论文里面描述的不符。所以下面先以论文为主，正式开始描述具体细节。
|
||||
|
||||
### 任务目标
|
||||
召回任务的目标是对于每一个用户$u \in \mathcal{U}$从十亿规模的物品池$\mathcal{I}$检索出包含与用户兴趣相关的上千个物品集。
|
||||
#### 模型的输入
|
||||
对于模型，每个样本的输入可以表示为一个三元组：$\left(\mathcal{I}_{u}, \mathcal{P}_{u}, \mathcal{F}_{i}\right)$，其中$\mathcal{I}_{u}$代表与用户$u$交互过的物品集，即用户的历史行为；$\mathcal{P}_{u}$表示用户的属性，例如性别、年龄等；$\mathcal{F}_{i}$定义为目标物品$i$的一些特征，例如物品id和种类id等。
|
||||
#### 任务描述
|
||||
MIND的核心任务是学习一个从原生特征映射到**用户表示**的函数，用户表示定义为：
|
||||
$$
|
||||
\mathrm{V}_{u}=f_{u s e r}\left(\mathcal{I}_{u}, \mathcal{P}_{u}\right)
|
||||
$$
|
||||
其中，$\mathbf{V}_{u}=\left(\overrightarrow{\boldsymbol{v}}_{u}^{1}, \ldots, \overrightarrow{\boldsymbol{v}}_{u}^{K}\right) \in \mathbb{R}^{d \times k}$是用户$u$的表示向量，$d$是embedding的维度，$K$表示向量的个数，即兴趣的数量。如果$K=1$，那么MIND模型就退化成YouTubeDNN的向量表示方式了。
|
||||
|
||||
目标物品$i$的embedding函数为：
|
||||
$$
|
||||
\overrightarrow{\mathbf{e}}_{i}=f_{\text {item }}\left(\mathcal{F}_{i}\right)
|
||||
$$
|
||||
其中，$\overrightarrow{\mathbf{e}}_{i} \in \mathbb{R}^{d \times 1}, \quad f_{i t e m}(\cdot)$表示一个embedding&pooling层。
|
||||
#### 最终结果
|
||||
根据评分函数检索（根据**目标物品与用户表示向量的内积的最大值作为相似度依据**，DIN的Attention部分也是以这种方式来衡量两者的相似度），得到top N个候选项：
|
||||
|
||||
$$
|
||||
f_{\text {score }}\left(\mathbf{V}_{u}, \overrightarrow{\mathbf{e}}_{i}\right)=\max _{1 \leq k \leq K} \overrightarrow{\mathbf{e}}_{i}^{\mathrm{T}} \overrightarrow{\mathbf{V}}_{u}^{\mathrm{k}}
|
||||
$$
|
||||
|
||||
### Embedding & Pooling层
|
||||
Embedding层的输入由三部分组成，用户属性$\mathcal{P}_{u}$、用户行为$\mathcal{I}_{u}$和目标物品标签$\mathcal{F}_{i}$。每一部分都由多个id特征组成，则是一个高维的稀疏数据，因此需要Embedding技术将其映射为低维密集向量。具体来说，
|
||||
|
||||
* 对于$\mathcal{P}_{u}$的id特征（年龄、性别等）是将其Embedding的向量进行Concat，组成用户属性Embedding$\overrightarrow{\mathbf{p}}_{u}$；
|
||||
* 目标物品$\mathcal{F}_{i}$通常包含其他分类特征id（品牌id、店铺id等） ，这些特征有利于物品的冷启动问题，需要将所有的分类特征的Embedding向量进行平均池化，得到一个目标物品向量$\overrightarrow{\mathbf{e}}_{i}$；
|
||||
* 对于用户行为$\mathcal{I}_{u}$，由物品的Embedding向量组成用户行为Embedding列表$E_{u}=\overrightarrow{\mathbf{e}}_{j}, j \in \mathcal{I}_{u}$， 当然这里不仅只有物品embedding哈，也可能有类别，品牌等其他的embedding信息。
|
||||
|
||||
### Multi-Interest Extractor Layer(核心)
|
||||
作者认为，单一的向量不足以表达用户的多兴趣。所以作者采用**多个表示向量**来分别表示用户不同的兴趣。通过这个方式，在召回阶段，用户的多兴趣可以分别考虑，对于兴趣的每一个方面，能够更精确的进行物品检索。
|
||||
|
||||
为了学习多兴趣表示，作者利用胶囊网络表示学习的动态路由将用户的历史行为分组到多个簇中。来自一个簇的物品应该密切相关，并共同代表用户兴趣的一个特定方面。
|
||||
|
||||
由于多兴趣提取器层的设计灵感来自于胶囊网络表示学习的动态路由，所以这里作者回顾了动态路由机制。当然，如果之前对胶囊网络或动态路由不了解，这里读起来就会有点艰难，但由于我上面进行了铺垫，这里就直接拿过原文并解释即可。
|
||||
#### 动态路由
|
||||
动态路由是胶囊网络中的迭代学习算法，用于学习低水平胶囊和高水平胶囊之间的路由对数（logit）$b_{ij}$，来得到高水平胶囊的表示。
|
||||
|
||||
我们假设胶囊网络有两层，即低水平胶囊$\vec{c}_{i}^{l} \in \mathbb{R}^{N_{l} \times 1}, i \in\{1, \ldots, m\}$和高水平胶囊$\vec{c}_{j}^{h} \in \mathbb{R}^{N_{h} \times 1}, j \in\{1, \ldots, n\}$，其中$m,n$表示胶囊的个数， $N_l,N_h$表示胶囊的维度。 路由对数$b_{ij}$计算公式如下：
|
||||
$$
|
||||
b_{i j}=\left(\vec{c}_{j}^{h}\right)^{T} \mathrm{~S}_{i j} \vec{c}_{i}^{l}
|
||||
$$
|
||||
其中$\mathbf{S}_{i j} \in \mathbb{R}^{N_{h} \times N_{l}}$表示待学习的双线性映射矩阵【在胶囊网络的原文中称为转换矩阵】
|
||||
|
||||
通过计算路由对数，将高阶胶囊$j$的候选向量计算为所有低阶胶囊的加权和：
|
||||
$$
|
||||
\vec{z}_{j}^{h}=\sum_{i=1}^{m} w_{i j} S_{i j} \vec{c}_{i}^{l}
|
||||
$$
|
||||
其中$w_{ij}$定义为连接低阶胶囊$i$和高阶胶囊$j$的权重【称为耦合系数】，而且其通过对路由对数执行softmax来计算：
|
||||
$$
|
||||
w_{i j}=\frac{\exp b_{i j}}{\sum_{k=1}^{m} \exp b_{i k}}
|
||||
$$
|
||||
最后，应用一个非线性的“压缩”函数来获得一个高阶胶囊的向量【胶囊网络向量的模表示由胶囊所代表的实体存在的概率】
|
||||
$$
|
||||
\vec{c}_{j}^{h}=\operatorname{squash}\left(\vec{z}_{j}^{h}\right)=\frac{\left\|\vec{z}_{j}^{h}\right\|^{2}}{1+\left\|\vec{z}_{j}^{h}\right\|^{2}} \frac{\vec{z}_{j}^{h}}{\left\|\vec{z}_{j}^{h}\right\|}
|
||||
$$
|
||||
路由过程重复进行3次达到收敛。当路由结束，高阶胶囊值$\vec{c}_{j}^{h}$固定，作为下一层的输入。
|
||||
|
||||
Ok，下面我们开始解释，其实上面说的这些就是胶囊网络的计算过程，只不过和之前所用的符号不一样了。这里拿个图：
|
||||
|
||||
首先，论文里面也是个两层的胶囊网络，低水平层->高水平层。 低水平层有$m$个胶囊，每个胶囊向量维度是$N_l$，用$\vec{c}_{i}^l$表示的，高水平层有$n$个胶囊，每个胶囊$N_h$维，用$\vec{c}_{j}^h$表示。
|
||||
|
||||
单独拿出每个$\vec{c}_{j}^h$，其计算过程如上图所示。首先，先随机初始化路由对数$b_{ij}=0$，然后开始迭代，对于每次迭代：
|
||||
$$
|
||||
w_{i j}=\frac{\exp b_{i j}}{\sum_{k=1}^{m} \exp b_{i k}} \\
|
||||
\vec{z}_{j}^{h}=\sum_{i=1}^{m} w_{i j} S_{i j} \vec{c}_{i}^{l} \\ \vec{c}_{j}^{h}=\operatorname{squash}\left(\vec{z}_{j}^{h}\right)=\frac{\left\|\vec{z}_{j}^{h}\right\|^{2}}{1+\left\|\vec{z}_{j}^{h}\right\|^{2}} \frac{\vec{z}_{j}^{h}}{\left\|\vec{z}_{j}^{h}\right\|} \\ b_{i j}=\left(\vec{c}_{j}^{h}\right)^{T} \mathrm{~S}_{i j} \vec{c}_{i}^{l}
|
||||
$$
|
||||
只不过这里的符合和上图中的不太一样，这里的$w_{ij}$对应的是每个输入胶囊的权重$c_{ij}$， 这里的$\vec{c}_{j}^h$对应上图中的$a$， 这里的$\vec{z}_{j}^h$对应的是输入胶囊的加权组合。这里的$\vec{c}_{i}^l$对应上图中的$v_i$，这里的$S_{ij}$对应的是上图的权重$W_{ij}$，只不过这个可以换成矩阵运算。 和上图中不同的是路由对数$b_{ij}$更新那里，没有了上一层的路由对数值，但感觉这样会有问题。
|
||||
|
||||
所以，这样解释完之后就会发现，其实上面的一顿操作就是说的传统的动态路由机制。
|
||||
|
||||
#### B2I动态路由
|
||||
作者设计的多兴趣提取层就是就是受到了上述胶囊网络的启发。
|
||||
|
||||
如果把用户的行为序列看成是行为胶囊， 把用户的多兴趣看成兴趣胶囊，那么多兴趣提取层就是利用动态路由机制学习行为胶囊`->`兴趣胶囊的映射关系。但是原始路由算法无法直接应用于处理用户行为数据。因此，提出了**行为(Behavior)到兴趣(Interest)（B2I）动态路由**来自适应地将用户的行为聚合到兴趣表示向量中，它与原始路由算法有三个不同之处：
|
||||
|
||||
1. **共享双向映射矩阵**。在初始动态路由中，使用固定的或者说共享的双线性映射矩阵$S$而不是单独的双线性映射矩阵， 在原始的动态路由中，对于每个输出胶囊$\vec{c}_{j}^h$，都会有对应的$S_{ij}$，而这里是每个输出胶囊，都共用一个$S$矩阵。 原因有两个：
|
||||
1. 一方面，用户行为是可变长度的，从几十个到几百个不等，因此使用共享的双线性映射矩阵是有利于泛化。
|
||||
2. 另一方面，希望兴趣胶囊在同一个向量空间中，但不同的双线性映射矩阵将兴趣胶囊映射到不同的向量空间中。因为映射矩阵的作用就是对用户的行为胶囊进行线性映射嘛， 由于用户的行为序列都是商品，所以希望经过映射之后，到统一的商品向量空间中去。路由对数计算如下：
|
||||
$$
|
||||
b_{i j}=\overrightarrow{\boldsymbol{u}}_{j}^{T} \mathrm{S\overrightarrow{e}}_{i}, \quad i \in \mathcal{I}_{u}, j \in\{1, \ldots, K\}
|
||||
$$
|
||||
其中，$\overrightarrow{\boldsymbol{e}}_{i} \in \mathbb{R}^{d}$是历史物品$i$的embedding，$\vec{u}_{j} \in \mathbb{R}^{d}$表示兴趣胶囊$j$的向量。$S \in \mathbb{R}^{d \times d}$是每一对行为胶囊(低价)到兴趣胶囊(高阶)之间 的共享映射矩阵。
|
||||
|
||||
|
||||
2. **随机初始化路由对数**。由于利用共享双向映射矩阵$S$，如果再初始化路由对数为0将导致相同的初始的兴趣胶囊。随后的迭代将陷入到一个不同兴趣胶囊在所有的时间保持相同的情景。因为每个输出胶囊的运算都一样了嘛(除非迭代的次数不同，但这样也会导致兴趣胶囊都很类似)，为了减轻这种现象，作者通过高斯分布进行随机采样来初始化路由对数$b_{ij}$，让初始兴趣胶囊与其他每一个不同，其实就是希望在计算每个输出胶囊的时候，通过随机化的方式，希望这几个聚类中心离得远一点，这样才能表示出广泛的用户兴趣(我们已经了解这个机制就仿佛是聚类，而计算过程就是寻找聚类中心)。
|
||||
3. **动态的兴趣数量**，兴趣数量就是聚类中心的个数，由于不同用户的历史行为序列不同，那么相应的，其兴趣胶囊有可能也不一样多，所以这里使用了一种启发式方式自适应调整聚类中心的数量，即$K$值。
|
||||
$$
|
||||
K_{u}^{\prime}=\max \left(1, \min \left(K, \log _{2}\left(\left|\mathcal{I}_{u}\right|\right)\right)\right)
|
||||
$$
|
||||
这种调整兴趣胶囊数量的策略可以为兴趣较小的用户节省一些资源，包括计算和内存资源。这个公式不用多解释，与行为序列长度成正比。
|
||||
|
||||
最终的B2I动态路由算法如下：
|
||||
|
||||
应该很好理解了吧。
|
||||
|
||||
### Label-aware Attention Layer
|
||||
通过多兴趣提取器层，从用户的行为embedding中生成多个兴趣胶囊。不同的兴趣胶囊代表用户兴趣的不同方面，相应的兴趣胶囊用于评估用户对特定类别的偏好。所以，在训练的期间，最后需要设置一个Label-aware的注意力层，对于当前的商品，根据相关性选择最相关的兴趣胶囊。这里其实就是一个普通的注意力机制，和DIN里面的那个注意力层基本上是一模一样，计算公式如下：
|
||||
$$
|
||||
\begin{aligned}
|
||||
\overrightarrow{\boldsymbol{v}}_{u} &=\operatorname{Attention}\left(\overrightarrow{\boldsymbol{e}}_{i}, \mathrm{~V}_{u}, \mathrm{~V}_{u}\right) \\
|
||||
&=\mathrm{V}_{u} \operatorname{softmax}\left(\operatorname{pow}\left(\mathrm{V}_{u}^{\mathrm{T}} \overrightarrow{\boldsymbol{e}}_{i}, p\right)\right)
|
||||
\end{aligned}
|
||||
$$
|
||||
首先这里的$\overrightarrow{\boldsymbol{e}}_{i}$表示当前的商品向量，$V_u$表示用户的多兴趣向量组合，里面有$K$个向量，表示用户的$K$的兴趣。用户的各个兴趣向量与目标商品做内积，然后softmax转成权重，然后反乘到多个兴趣向量进行加权求和。 但是这里需要注意的一个小点，就是这里做内积求完相似性之后，先做了一个指数操作，**这个操作其实能放大或缩小相似程度**，至于放大或者缩小的程度，由$p$控制。 比如某个兴趣向量与当前商品非常相似，那么再进行指数操作之后，如果$p$也很大，那么显然这个兴趣向量就占了主导作用。$p$是一个可调节的参数来调整注意力分布。当$p$接近0，每一个兴趣胶囊都得到相同的关注。当$p$大于1时，随着$p$的增加，具有较大值的点积将获得越来越多的权重。考虑极限情况，当$p$趋近于无穷大时，注意机制就变成了一种硬注意，选关注最大的值而忽略其他值。在实验中，发现使用硬注意导致更快的收敛。
|
||||
>理解：$p$小意味着所有的相似程度都缩小了， 使得之间的差距会变小，所以相当于每个胶囊都会受到关注，而越大的话，使得各个相似性差距拉大，相似程度越大的会更大，就类似于贫富差距， 最终使得只关注于比较大的胶囊。
|
||||
|
||||
### 训练与服务
|
||||
得到用户向量$\overrightarrow{\boldsymbol{v}}_{u}$和标签物品embedding$\vec{e}_{i}$后，计算用户$u$与标签物品$i$交互的概率：
|
||||
$$
|
||||
\operatorname{Pr}(i \mid u)=\operatorname{Pr}\left(\vec{e}_{i} \mid \vec{v}_{u}\right)=\frac{\exp \left(\vec{v}_{u}^{\mathrm{T} \rightarrow}\right)}{\sum_{j \in I} \exp \left(\vec{v}_{u}^{\mathrm{T}} \vec{e}_{j}\right)}
|
||||
$$
|
||||
目标函数是：
|
||||
$$
|
||||
L=\sum_{(u, i) \in \mathcal{D}} \log \operatorname{Pr}(i \mid u)
|
||||
$$
|
||||
其中$\mathcal{D}$是训练数据包含用户物品交互的集合。因为物品的数量可伸缩到数十亿，所以不能直接算。因此。使用采样的softmax技术，并且选择Adam优化来训练MIND。
|
||||
|
||||
训练结束后，抛开label-aware注意力层，MIND网络得到一个用户表示映射函数$f_{user}$。在服务期间，用户的历史序列与自身属性喂入到$f_{user}$，每个用户得到多兴趣向量。然后这个表示向量通过一个近似邻近方法来检索top N物品。
|
||||
|
||||
这就是整个MIND模型的细节了。
|
||||
|
||||
## MIND模型之简易代码复现
|
||||
下面参考Deepctr，用简易的代码实现下MIND，并在新闻推荐的数据集上进行召回任务。
|
||||
|
||||
### 整个代码架构
|
||||
|
||||
整个MIND模型算是参考deepmatch修改的一个简易版本：
|
||||
|
||||
```python
|
||||
def MIND(user_feature_columns, item_feature_columns, num_sampled=5, k_max=2, p=1.0, dynamic_k=False, user_dnn_hidden_units=(64, 32),
|
||||
dnn_activation='relu', dnn_use_bn=False, l2_reg_dnn=0, l2_reg_embedding=1e-6, dnn_dropout=0, output_activation='linear', seed=1024):
|
||||
"""
|
||||
:param k_max: 用户兴趣胶囊的最大个数
|
||||
"""
|
||||
# 目前这里只支持item_feature_columns为1的情况，即只能转入item_id
|
||||
if len(item_feature_columns) > 1:
|
||||
raise ValueError("Now MIND only support 1 item feature like item_id")
|
||||
|
||||
# 获取item相关的配置参数
|
||||
item_feature_column = item_feature_columns[0]
|
||||
item_feature_name = item_feature_column.name
|
||||
item_vocabulary_size = item_feature_column.vocabulary_size
|
||||
item_embedding_dim = item_feature_column.embedding_dim
|
||||
|
||||
behavior_feature_list = [item_feature_name]
|
||||
|
||||
# 为用户特征创建Input层
|
||||
user_input_layer_dict = build_input_layers(user_feature_columns)
|
||||
item_input_layer_dict = build_input_layers(item_feature_columns)
|
||||
# 将Input层转化成列表的形式作为model的输入
|
||||
user_input_layers = list(user_input_layer_dict.values())
|
||||
item_input_layers = list(item_input_layer_dict.values())
|
||||
|
||||
# 筛选出特征中的sparse特征和dense特征，方便单独处理
|
||||
sparse_feature_columns = list(filter(lambda x: isinstance(x, SparseFeat), user_feature_columns)) if user_feature_columns else []
|
||||
dense_feature_columns = list(filter(lambda x: isinstance(x, DenseFeat), user_feature_columns)) if user_feature_columns else []
|
||||
varlen_feature_columns = list(filter(lambda x: isinstance(x, VarLenSparseFeat), user_feature_columns)) if user_feature_columns else []
|
||||
|
||||
# 由于这个变长序列里面只有历史点击文章，没有类别啥的，所以这里直接可以用varlen_feature_columns
|
||||
# deepctr这里单独把点击文章这个放到了history_feature_columns
|
||||
seq_max_len = varlen_feature_columns[0].maxlen
|
||||
|
||||
# 构建embedding字典
|
||||
embedding_layer_dict = build_embedding_layers(user_feature_columns+item_feature_columns)
|
||||
|
||||
# 获取当前的行为特征(doc)的embedding，这里面可能又多个类别特征，所以需要pooling下
|
||||
query_embed_list = embedding_lookup(behavior_feature_list, item_input_layer_dict, embedding_layer_dict) # 长度为1
|
||||
# 获取行为序列(doc_id序列, hist_doc_id) 对应的embedding，这里有可能有多个行为产生了行为序列，所以需要使用列表将其放在一起
|
||||
keys_embed_list = embedding_lookup([varlen_feature_columns[0].name], user_input_layer_dict, embedding_layer_dict) # 长度为1
|
||||
|
||||
# 用户离散特征的输入层与embedding层拼接
|
||||
dnn_input_emb_list = embedding_lookup([col.name for col in sparse_feature_columns], user_input_layer_dict, embedding_layer_dict)
|
||||
|
||||
# 获取dense
|
||||
dnn_dense_input = []
|
||||
for fc in dense_feature_columns:
|
||||
if fc.name != 'hist_len': # 连续特征不要这个
|
||||
dnn_dense_input.append(user_input_layer_dict[fc.name])
|
||||
|
||||
# 把keys_emb_list和query_emb_listpooling操作， 这是因为可能每个商品不仅有id，还可能用类别，品牌等多个embedding向量，这种需要pooling成一个
|
||||
history_emb = PoolingLayer()(NoMask()(keys_embed_list)) # (None, 50, 8)
|
||||
target_emb = PoolingLayer()(NoMask()(query_embed_list)) # (None, 1, 8)
|
||||
|
||||
hist_len = user_input_layer_dict['hist_len']
|
||||
# 胶囊网络
|
||||
# (None, 2, 8) 得到了两个兴趣胶囊
|
||||
high_capsule = CapsuleLayer(input_units=item_embedding_dim, out_units=item_embedding_dim,
|
||||
max_len=seq_max_len, k_max=k_max)((history_emb, hist_len))
|
||||
|
||||
|
||||
# 把用户的其他特征拼接到胶囊网络上来
|
||||
if len(dnn_input_emb_list) > 0 or len(dnn_dense_input) > 0:
|
||||
user_other_feature = combined_dnn_input(dnn_input_emb_list, dnn_dense_input)
|
||||
# (None, 2, 32) 这里会发现其他的用户特征是每个胶囊复制了一份，然后拼接起来
|
||||
other_feature_tile = tf.keras.layers.Lambda(tile_user_otherfeat, arguments={'k_max': k_max})(user_other_feature)
|
||||
user_deep_input = Concatenate()([NoMask()(other_feature_tile), high_capsule]) # (None, 2, 40)
|
||||
else:
|
||||
user_deep_input = high_capsule
|
||||
|
||||
# 接下来过一个DNN层，获取最终的用户表示向量 如果是三维输入， 那么最后一个维度与w相乘，所以这里如果不自己写，可以用Dense层的列表也可以
|
||||
user_embeddings = DNN(user_dnn_hidden_units, dnn_activation, l2_reg_dnn,
|
||||
dnn_dropout, dnn_use_bn, output_activation=output_activation, seed=seed,
|
||||
name="user_embedding")(user_deep_input) # (None, 2, 8)
|
||||
|
||||
# 接下来，过Label-aware layer
|
||||
if dynamic_k:
|
||||
user_embedding_final = LabelAwareAttention(k_max=k_max, pow_p=p,)((user_embeddings, target_emb, hist_len))
|
||||
else:
|
||||
user_embedding_final = LabelAwareAttention(k_max=k_max, pow_p=p,)((user_embeddings, target_emb))
|
||||
|
||||
# 接下来
|
||||
item_embedding_matrix = embedding_layer_dict[item_feature_name] # 获取doc_id的embedding层
|
||||
item_index = EmbeddingIndex(list(range(item_vocabulary_size)))(item_input_layer_dict[item_feature_name]) # 所有doc_id的索引
|
||||
item_embedding_weight = NoMask()(item_embedding_matrix(item_index)) # 拿到所有item的embedding
|
||||
pooling_item_embedding_weight = PoolingLayer()([item_embedding_weight]) # 这里依然是当可能不止item_id，或许还有brand_id, cat_id等，需要池化
|
||||
|
||||
# 这里传入的是整个doc_id的embedding， user_embedding, 以及用户点击的doc_id，然后去进行负采样计算损失操作
|
||||
output = SampledSoftmaxLayer(num_sampled)([pooling_item_embedding_weight, user_embedding_final, item_input_layer_dict[item_feature_name]])
|
||||
|
||||
model = Model(inputs=user_input_layers+item_input_layers, outputs=output)
|
||||
|
||||
# 下面是等模型训练完了之后，获取用户和item的embedding
|
||||
model.__setattr__("user_input", user_input_layers)
|
||||
model.__setattr__("user_embedding", user_embeddings)
|
||||
model.__setattr__("item_input", item_input_layers)
|
||||
model.__setattr__("item_embedding", get_item_embedding(pooling_item_embedding_weight, item_input_layer_dict[item_feature_name]))
|
||||
|
||||
return model
|
||||
```
|
||||
简单说下流程， 函数式API搭建模型的方式，首先我们需要传入封装好的用户特征描述以及item特征描述，比如：
|
||||
|
||||
```python
|
||||
# 建立模型
|
||||
user_feature_columns = [
|
||||
SparseFeat('user_id', feature_max_idx['user_id'], embedding_dim),
|
||||
VarLenSparseFeat(SparseFeat('hist_doc_ids', feature_max_idx['article_id'], embedding_dim,
|
||||
embedding_name="click_doc_id"), his_seq_maxlen, 'mean', 'hist_len'),
|
||||
DenseFeat('hist_len', 1),
|
||||
SparseFeat('u_city', feature_max_idx['city'], embedding_dim),
|
||||
SparseFeat('u_age', feature_max_idx['age'], embedding_dim),
|
||||
SparseFeat('u_gender', feature_max_idx['gender'], embedding_dim),
|
||||
]
|
||||
doc_feature_columns = [
|
||||
SparseFeat('click_doc_id', feature_max_idx['article_id'], embedding_dim)
|
||||
# 这里后面也可以把文章的类别画像特征加入
|
||||
]
|
||||
```
|
||||
首先， 函数会对传入的这种特征建立模型的Input层，主要是`build_input_layers`函数。建立完了之后，获取到Input层列表，这个是为了最终定义模型用的，keras要求定义模型的时候是列表的形式。
|
||||
|
||||
接下来是选出sparse特征和Dense特征来，这个也是常规操作了，因为不同的特征后面处理方式不一样，对于sparse特征，后面要接embedding层，Dense特征的话，直接可以拼接起来。这就是筛选特征的3行代码。
|
||||
|
||||
接下来，是为所有的离散特征建立embedding层，通过函数`build_embedding_layers`。建立完了之后，把item相关的embedding层与对应的Input层接起来，作为query_embed_list， 而用户历史行为序列的embedding层与Input层接起来作为keys_embed_list，这两个有单独的用户。而Input层与embedding层拼接是通过`embedding_lookup`函数完成的。 这样完成了之后，就能通过Input层-embedding层拿到item的系列embedding，以及历史序列里面item系列embedding，之所以这里是系列embedding，是有可能不止item_id这一个特征，还可能有品牌id, 类别id等好几个，所以接下来把系列embedding通过pooling操作，得到最终表示item的向量。 就是这两行代码：
|
||||
|
||||
```python
|
||||
# 把keys_emb_list和query_emb_listpooling操作， 这是因为可能每个商品不仅有id，还可能用类别，品牌等多个embedding向量，这种需要pooling成一个
|
||||
history_emb = PoolingLayer()(NoMask()(keys_embed_list)) # (None, 50, 8)
|
||||
target_emb = PoolingLayer()(NoMask()(query_embed_list)) # (None, 1, 8)
|
||||
```
|
||||
而像其他的输入类别特征， 依然是Input层与embedding层拼起来，留着后面用，这个存到了dnn_input_emb_list中。 而dense特征， 不需要embedding层，直接通过Input层获取到，然后存到列表里面，留着后面用。
|
||||
|
||||
上面得到的history_emb，就是用户的历史行为序列，这个东西接下来要过兴趣提取层，去学习用户的多兴趣，当然这里还需要传入行为序列的真实长度。因为每个用户行为序列不一样长，通过mask让其等长了，但是真实在胶囊网络计算的时候，这些填充的序列是要被mask掉的。所以必须要知道真实长度。
|
||||
|
||||
```python
|
||||
# 胶囊网络
|
||||
# (None, 2, 8) 得到了两个兴趣胶囊
|
||||
high_capsule = CapsuleLayer(input_units=item_embedding_dim, out_units=item_embedding_dim,max_len=seq_max_len, k_max=k_max)((history_emb, hist_len))
|
||||
```
|
||||
通过这步操作，就得到了两个兴趣胶囊。 至于具体细节，下一节看。 然后把用户的其他特征拼接上来，这里有必要看下代码究竟是怎么拼接的：
|
||||
|
||||
```python
|
||||
# 把用户的其他特征拼接到胶囊网络上来
|
||||
if len(dnn_input_emb_list) > 0 or len(dnn_dense_input) > 0:
|
||||
user_other_feature = combined_dnn_input(dnn_input_emb_list, dnn_dense_input)
|
||||
# (None, 2, 32) 这里会发现其他的用户特征是每个胶囊复制了一份，然后拼接起来
|
||||
other_feature_tile = tf.keras.layers.Lambda(tile_user_otherfeat, arguments={'k_max': k_max})(user_other_feature)
|
||||
user_deep_input = Concatenate()([NoMask()(other_feature_tile), high_capsule]) # (None, 2, 40)
|
||||
else:
|
||||
user_deep_input = high_capsule
|
||||
```
|
||||
这里会发现，使用了一个Lambda层，这个东西的作用呢，其实是将用户的其他特征在胶囊个数的维度上复制了一份，再拼接，这就相当于在每个胶囊的后面都拼接上了用户的基础特征。这样得到的维度就成了(None, 2, 40)，2是胶囊个数， 40是兴趣胶囊的维度+其他基础特征维度总和。这样拼完了之后，接下来过全连接层
|
||||
|
||||
```python
|
||||
# 接下来过一个DNN层，获取最终的用户表示向量 如果是三维输入， 那么最后一个维度与w相乘，所以这里如果不自己写，可以用Dense层的列表也可以
|
||||
user_embeddings = DNN(user_dnn_hidden_units, dnn_activation, l2_reg_dnn,
|
||||
dnn_dropout, dnn_use_bn, output_activation=output_activation, seed=seed,
|
||||
name="user_embedding")(user_deep_input) # (None, 2, 8)
|
||||
```
|
||||
最终得到的是(None, 2, 8)的向量，这样就解决了之前的那个疑问， 最终得到的兴趣向量个数并不是1个，而是多个兴趣向量了，因为上面用户特征拼接，是每个胶囊后面都拼接一份同样的特征。另外，就是原来DNN这里的输入还可以是3维的，这样进行运算的话，是最后一个维度与W进行运算，相当于只在第3个维度上进行了降维操作后者非线性操作，这样得到的兴趣个数是不变的。
|
||||
|
||||
这样，有了两个兴趣的输出之后，接下来，就是过LabelAwareAttention层了，对这两个兴趣向量与当前item的相关性加注意力权重，最后变成1个用户的最终向量。
|
||||
|
||||
```python
|
||||
user_embedding_final = LabelAwareAttention(k_max=k_max, pow_p=p,)((user_embeddings, target_emb))
|
||||
```
|
||||
这样，就得到了用户的最终表示向量，当然这个操作仅是训练的时候，服务的时候是拿的上面DNN的输出，即多个兴趣，这里注意一下。
|
||||
|
||||
拿到了最终的用户向量，如何计算损失呢？ 这里用了负采样层进行操作。关于这个层具体的原理，后面我们可能会出一篇文章总结。
|
||||
|
||||
接下来有几行代码也需要注意：
|
||||
|
||||
```python
|
||||
# 下面是等模型训练完了之后，获取用户和item的embedding
|
||||
model.__setattr__("user_input", user_input_layers)
|
||||
model.__setattr__("user_embedding", user_embeddings)
|
||||
model.__setattr__("item_input", item_input_layers)
|
||||
model.__setattr__("item_embedding", get_item_embedding(pooling_item_embedding_weight, item_input_layer_dict[item_feature_name]))
|
||||
```
|
||||
这几行代码是为了模型训练完，我们给定输入之后，拿embedding用的，设置好了之后，通过：
|
||||
|
||||
```python
|
||||
user_embedding_model = Model(inputs=model.user_input, outputs=model.user_embedding)
|
||||
item_embedding_model = Model(inputs=model.item_input, outputs=model.item_embedding)
|
||||
|
||||
user_embs = user_embedding_model.predict(test_user_model_input, batch_size=2 ** 12)
|
||||
# user_embs = user_embs[:, i, :] # i in [0,k_max) if MIND
|
||||
item_embs = item_embedding_model.predict(all_item_model_input, batch_size=2 ** 12)
|
||||
```
|
||||
这样就能拿到用户和item的embedding， 接下来近邻检索完成召回过程。 注意，MIND的话，这里是拿到的多个兴趣向量的。
|
||||
|
||||
## 总结
|
||||
今天这篇文章整理的MIND，这是一个多兴趣的召回模型，核心是兴趣提取层，该层通过动态路由机制能够自动的对用户的历史行为序列进行聚类，得到多个兴趣向量，这样能在召回阶段捕获到用户的广泛兴趣，从而召回更好的候选商品。
|
||||
|
||||
|
||||
**参考**：
|
||||
* Multi-Interest Network with Dynamic Routing for Recommendation at Tmall
|
||||
* [ AI上推荐 之 MIND(动态路由与胶囊网络的奇光异彩)](https://blog.csdn.net/wuzhongqiang/article/details/123696462?spm=1001.2014.3001.5501)
|
||||
* [Dynamic Routing Between Capsule ](https://arxiv.org/pdf/1710.09829.pdf)
|
||||
* [CIKM2019｜MIND---召回阶段的多兴趣模型](https://zhuanlan.zhihu.com/p/262638999)
|
||||
* [B站胶囊网络课程](https://www.bilibili.com/video/BV1eW411Q7CE?p=2)
|
||||
* [胶囊网络识别交通标志](https://blog.csdn.net/shebao3333/article/details/79008688)
|
||||
|
||||
|
||||
404
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.4/SDM.md
Normal file
404
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.4/SDM.md
Normal file
@@ -0,0 +1,404 @@
|
||||
## 写在前面
|
||||
SDM模型(Sequential Deep Matching Model)，是阿里团队在2019年CIKM上的一篇paper。和MIND模型一样，是一种序列召回模型，研究的依然是如何通过用户的历史行为序列去学习到用户的丰富兴趣。 对于MIND，我们已经知道是基于胶囊网络的动态路由机制，设计了一个动态兴趣提取层，把用户的行为序列通过路由机制聚类，然后映射成了多个兴趣胶囊，以此来获取到用户的广泛兴趣。而SDM模型，是先把用户的历史序列根据交互的时间分成了短期和长期两类，然后从**短期会话**和**长期行为**中分别采取**相应的措施(短期的RNN+多头注意力， 长期的Att Net)** 去学习到用户的短期兴趣和长期行为偏好，并**巧妙的设计了一个门控网络==有选择==的将长短期兴趣进行融合**，以此得到用户的最终兴趣向量。 这篇paper中的一些亮点，比如长期偏好的行为表示，多头注意力机制学习多兴趣，长短期兴趣的融合机制等，又给了一些看待问题的新角度，同时，给出了我们一种利用历史行为序列去捕捉用户动态偏好的新思路。
|
||||
|
||||
这篇paper依然是从引言开始， 介绍SDM模型提出的动机以及目前方法存在的不足(why)， 接下来就是SDM的网络模型架构(what)， 这里面的关键是如何从短期会话和长期行为两个方面学习到用户的短期长期偏好(how)，最后，依然是简易代码实现。
|
||||
|
||||
大纲如下：
|
||||
* 背景与动机
|
||||
* SDM的网络结构与细节
|
||||
* SDM模型代码复现
|
||||
|
||||
## 背景与动机
|
||||
这里要介绍该模型提出的动机，即why要有这样的一个模型？
|
||||
|
||||
一个好的推荐系统应该是能精确的捕捉用户兴趣偏好以及能对他们当前需求进行快速响应的，往往工业上的推荐系统，为了能快速响应， 一般会把整个推荐流程分成召回和排序两个阶段，先通过召回，从海量商品中得到一个小的候选集，然后再给到排序模型做精确的筛选操作。 这也是目前推荐系统的一个范式了。在这个过程中，召回模块所检索到的候选对象的质量在整个系统中起着至关重要的作用。
|
||||
|
||||
淘宝目前的召回模型是一些基于协同过滤的模型， 这些模型是通过用户与商品的历史交互建模，从而得到用户的物品的表示向量，但这个过程是**静态的**，而用户的行为或者兴趣是时刻变化的， 对于协同过滤的模型来说，并不能很好的捕捉到用户整个行为序列的动态变化。
|
||||
|
||||
那我们知道了学习用户历史行为序列很重要， 那么假设序列很长呢？这时候直接用模型学习长序列之间的演进可能不是很好，因为很长的序列里面可能用户的兴趣发生过很大的转变，很多商品压根就没有啥关系，这样硬学，反而会导致越学越乱，就别提这个演进了。所以这里是以会话为单位，对长序列进行切分。作者这里的依据就是用户在同一个Session下，其需求往往是很明确的， 这时候，交互的商品也往往都非常类似。 但是Session与Session之间，可能需求改变，那么商品类型可能骤变。 所以以Session为单位来学习商品之间的序列信息，感觉要比整个长序列学习来的靠谱。
|
||||
|
||||
作者首先是先把长序列分成了多个会话， 然后**把最近的一次会话，和之前的会话分别视为了用户短期行为和长期行为分别进行了建模，并采用不同的措施学习用户的短期兴趣和长期兴趣，然后通过一个门控机制融合得到用户最终的表示向量**。这就是SDM在做的事情，
|
||||
|
||||
|
||||
长短期行为序列联合建模，其实是在给我们提供一种新的学习用户兴趣的新思路， 那么究竟是怎么做的呢？以及为啥这么做呢？
|
||||
* 对于短期用户行为， 首先作者使用了LSTM来学习序列关系， 而接下来是用一个Multi-head attention机制，学习用户的多兴趣。
|
||||
|
||||
先分析分析作者为啥用多头注意力机制，作者这里依然是基于实际的场景出发，作者发现，**用户的兴趣点在一个会话里面其实也是多重的**。这个可能之前的很多模型也是没考虑到的，但在商品购买的场景中，这确实也是个事实， 顾客在买一个商品的时候，往往会进行多方比较， 考虑品牌，颜色，商店等各种因素。作者认为用普通的注意力机制是无法反映广泛的兴趣了，所以用多头注意力网络。
|
||||
|
||||
多头注意力机制从某个角度去看，也有类似聚类的功效，首先它接收了用户的行为序列，然后从多个角度学习到每个商品与其他商品的相关性，然后根据与其他商品的相关性加权融合，这样，相似的item向量大概率就融合到了一块组成一个向量，所谓用户的多兴趣，可能是因为这些行为商品之间，可以从多个空间或者角度去get彼此之间的相关性，这里面有着用户多兴趣的表达信息。
|
||||
|
||||
* 用户的长期行为也会影响当前的决策，作者在这里举了一个NBA粉丝的例子，说如果一个是某个NBA球星的粉丝，那么他可能在之前会买很多有关这个球星的商品，如果现在这个时刻想买鞋的时候，大概率会考虑和球星相关的。所以作者说**长期偏好和短期行为都非常关键**。但是长期偏好或者行为往往是复杂广泛的，就像刚才这个例子里面，可能长期行为里面，买的与这个球星相关商品只占一小部分，而就只有这一小部分对当前决策有用。
|
||||
这个也是之前的模型利用长期偏好方面存在的问题，那么如何选择出长期偏好里面对于当前决策有用的那部分呢？ 作者这里设计了一个门控的方式融合短期和长期，这个想法还是很巧妙的，后面介绍这个东西的时候说下我的想法。
|
||||
|
||||
所以下面总结动机以及本篇论文的亮点：
|
||||
* 动机： 召回模型需要捕获用户的动态兴趣变化，这个过程中利用好用户的长期行为和短期偏好非常关键，而以往的模型有下面几点不足：
|
||||
* 协同过滤模型： 基于用户的交互进行静态建模，无法感知用户的兴趣变化过程，易召回同质性的商品
|
||||
* 早期的一些序列推荐模型: 要么是对整个长序列直接建模，但这样太暴力，没法很好的学习商品之间的序列信息，有些是把长序列分成会话，但忽视了一个会话中用户的多重兴趣
|
||||
* 有些方法在考虑用户的长期行为方面，只是简单的拼接或者加权求和，而实际上用户长期行为中只有很少一小部分对当前的预测有用，这样暴力融合反而会适得其反，起不到效果。另外还有一些多任务或者对抗方法， 在工业场景中不适用等。
|
||||
* 这些我只是通过我的理解简单总结，详细内容看原论文相关工作部分。
|
||||
* 亮点:
|
||||
* SDM模型， 考虑了用户的短期行为和长期兴趣，以会话的形式进行分割，并对这两方面分别建模
|
||||
* 短期会话由于对当前决策影响比较大，那么我们就学习的全面一点， 首先RNN学习序列关系，其次通过多头注意力机制捕捉多兴趣，然后通过一个Attention Net加权得到短期兴趣表示
|
||||
* 长期会话通过Attention Net融合，然后过DNN，得到用户的长期表示
|
||||
* 我们设计了一个门控机制，类似于LSTM的那种门控，能巧妙的融合这两种兴趣，得到用户最终的表示向量
|
||||
|
||||
这就是动机与背景总结啦。 那么接下来，SDM究竟是如何学习短期和长期表示，又是如何融合的？ 为什么要这么玩？
|
||||
|
||||
## SDM的网络结构与细节剖析
|
||||
### 问题定义
|
||||
这里本来直接看模型结构，但感觉还是先过一下问题定义吧，毕竟这次涉及到了会话，还有几个小规则。
|
||||
|
||||
$\mathcal{U}$表示用户集合，$\mathcal{I}$表示item集合，模型考虑在时间$t$，是否用户$u$会对$i$产生交互。 对于$u$， 我们能够得到它的历史行为序列，那么先说一下如何进行会话的划分， 这里有三个规则：
|
||||
1. 相同会话ID的商品(后台能获取)算是一个会话
|
||||
2. 相邻的商品，时间间隔小于10分钟(业务自己调整)算一个会话
|
||||
3. 同一个会话中的商品不能超过50个，多出来的放入下一个会话
|
||||
|
||||
这样划分开会话之后， 对于用户$u$的短期行为定义是离目前最近的这次会话， 用$\mathcal{S}^{u}=\left[i_{1}^{u}, \ldots, i_{t}^{u}, \ldots, i_{m}^{u}\right]$表示，$m$是序列长度。 而长期的用户行为是过去一周内的会话，但不包括短期的这次会话， 这个用$\mathcal{L}^{u}$表示。网络推荐架构如下：
|
||||
|
||||
这个感觉并不用过多解释。看过召回的应该都能懂， 接收了用户的短期行为和长期行为，然后分别通过两个盲盒得到表示向量，再通过门控融合就得到了最终的用户表示。
|
||||
|
||||
下面要开那三个盲盒操作，即短期行为学习，长期行为学习以及门控融合机制。但在这之前，得先说一个东西，就是输入层这里， 要带物品的side infomation，比如物品的item ID, 物品的品牌ID，商铺ID， 类别ID等等， 那你说，为啥要单独说呢？ 之前的模型不也有， 但是这里在利用方式上有些不一样需要注意。
|
||||
|
||||
### Input Embedding with side Information
|
||||
在淘宝的推荐场景中，作者发现， 顾客与物品产生交互行为的时候，不仅考虑特定的商品本身，还考虑产品， 商铺，价格等，这个显然。所以，这里对于一个商品来说，不仅要用到Item ID，还用了更多的side info信息，包括`leat category, fist level category, brand,shop`。
|
||||
|
||||
所以，假设用户的短期行为是$\mathcal{S}^{u}=\left[i_{1}^{u}, \ldots, i_{t}^{u}, \ldots, i_{m}^{u}\right]$， 这里面的每个商品$i_t^u$其实有5个属性表示了，每个属性本质是ID，但转成embedding之后，就得到了5个embedding， 所以这里就涉及到了融合问题。 这里用$\boldsymbol{e}_{{i}^u_t} \in \mathbb{R}^{d \times 1}$来表示每个$i_t^u$，但这里不是embedding的pooling操作，而是Concat
|
||||
$$
|
||||
\boldsymbol{e}_{i_{t}^{u}}=\operatorname{concat}\left(\left\{\boldsymbol{e}_{i}^{f} \mid f \in \mathcal{F}\right\}\right)
|
||||
$$
|
||||
其中，$\boldsymbol{e}_{i}^{f}=\boldsymbol{W}^{f} \boldsymbol{x}_{i}^{f} \in \mathbb{R}^{d_{f} \times 1}$， 这个公式看着负责，其实就是每个side info的id过embedding layer得到各自的embedding。这里embedding的维度是$d_f$， 等拼接起来之后，就是$d$维了。这个点要注意。
|
||||
|
||||
另外就是用户的base表示向量了，这个很简单， 就是用户的基础画像，得到embedding，直接也是Concat，这个常规操作不解释：
|
||||
$$
|
||||
\boldsymbol{e}_{u}=\operatorname{concat}\left(\left\{\boldsymbol{e}_{u}^{p} \mid p \in \mathcal{P}\right\}\right)
|
||||
$$
|
||||
$e_u^p$是特征$p$的embedding。
|
||||
|
||||
Ok，输入这里说完了之后，就直接开盲盒， 不按照论文里面的顺序来了。想看更多细节的就去看原论文吧，感觉那里面说的有些啰嗦。不如直接上图解释来的明显：
|
||||
|
||||
|
||||
这里正好三个框把盒子框住了，下面剖析出每个来就行啦。
|
||||
### 短期用户行为建模
|
||||
这里短期用户行为是下面的那个框， 接收的输入，首先是用户最近的那次会话，里面各个商品加入了side info信息之后，有了最终的embedding表示$\left[\boldsymbol{e}_{i_{1}^{u}}, \ldots, \boldsymbol{e}_{i_{t}^{u}}\right]$。
|
||||
|
||||
这个东西，首先要过LSTM，学习序列信息，这个感觉不用多说，直接上公式：
|
||||
$$
|
||||
\begin{aligned}
|
||||
\boldsymbol{i} \boldsymbol{n}_{t}^{u} &=\sigma\left(\boldsymbol{W}_{i n}^{1} \boldsymbol{e}_{i_{t}^{u}}+\boldsymbol{W}_{i n}^{2} \boldsymbol{h}_{t-1}^{u}+b_{i n}\right) \\
|
||||
f_{t}^{u} &=\sigma\left(\boldsymbol{W}_{f}^{1} \boldsymbol{e}_{i_{t}^{u}}+\boldsymbol{W}_{f}^{2} \boldsymbol{h}_{t-1}^{u}+b_{f}\right) \\
|
||||
\boldsymbol{o}_{t}^{u} &=\sigma\left(\boldsymbol{W}_{o}^{1} \boldsymbol{e}_{i}^{u}+\boldsymbol{W}_{o}^{2} \boldsymbol{h}_{t-1}^{u}+b_{o}\right) \\
|
||||
\boldsymbol{c}_{t}^{u} &=\boldsymbol{f}_{t} \boldsymbol{c}_{t-1}^{u}+\boldsymbol{i} \boldsymbol{n}_{t}^{u} \tanh \left(\boldsymbol{W}_{c}^{1} \boldsymbol{e}_{i_{t}^{u}}+\boldsymbol{W}_{c}^{2} \boldsymbol{h}_{t-1}^{u}+b_{c}\right) \\
|
||||
\boldsymbol{h}_{t}^{u} &=\boldsymbol{o}_{t}^{u} \tanh \left(\boldsymbol{c}_{t}^{u}\right)
|
||||
\end{aligned}
|
||||
$$
|
||||
这里采用的是多输入多输出， 即每个时间步都会有一个隐藏状态$h_t^u$输出出来，那么经过LSTM之后，原始的序列就有了序列相关信息，得到了$\left[\boldsymbol{h}_{1}^{u}, \ldots, \boldsymbol{h}_{t}^{u}\right]$, 把这个记为$\boldsymbol{X}^{u}$。这里的$\boldsymbol{h}_{t}^{u} \in \mathbb{R}^{d \times 1}$表示时间$t$的序列偏好表示。
|
||||
|
||||
接下来， 这个东西要过Multi-head self-attention层，这个东西的原理我这里就不多讲了，这个东西可以学习到$h_i^u$系列之间的相关性，这个操作从某种角度看，也很像聚类， 因为我们这里是先用多头矩阵把$h_i^u$系列映射到多个空间，然后从各个空间中互求相关性
|
||||
$$
|
||||
\text { head }{ }_{i}^{u}=\operatorname{Attention}\left(\boldsymbol{W}_{i}^{Q} \boldsymbol{X}^{u}, \boldsymbol{W}_{i}^{K} \boldsymbol{X}^{u}, \boldsymbol{W}_{i}^{V} \boldsymbol{X}^{u}\right)
|
||||
$$
|
||||
得到权重后，对原始的向量加权融合。 让$Q_{i}^{u}=W_{i}^{Q} X^{u}$， $K_{i}^{u}=W_{i}^{K} \boldsymbol{X}^{u}$，$V_{i}^{u}=W_{i}^{V} X^{u}$， 背后计算是：
|
||||
$$
|
||||
\begin{aligned}
|
||||
&f\left(Q_{i}^{u}, K_{i}^{u}\right)=Q_{i}^{u T} K_{i}^{u} \\
|
||||
&A_{i}^{u}=\operatorname{softmax}\left(f\left(Q_{i}^{u}, K_{i}^{u}\right)\right)
|
||||
\end{aligned} \\ \operatorname{head}_{i}^{u}=V_{i}^{u} A_{i}^{u T}
|
||||
$$
|
||||
|
||||
这里如果有多头注意力基础的话非常好理解啊，不多解释，可以看我[这篇文章](https://blog.csdn.net/wuzhongqiang/article/details/104414239?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522164872966516781683952272%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=164872966516781683952272&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_ecpm_v1~rank_v31_ecpm-1-104414239.nonecase&utm_term=Attention+is+all&spm=1018.2226.3001.4450)补一下。
|
||||
|
||||
这是一个头的计算， 接下来每个头都这么算，假设有$h$个头，这里会通过上面的映射矩阵$W$系列，先把原始的$h_i^u$向量映射到$d_{k}=\frac{1}{h} d$维度，然后计算$head_i^u$也是$d_k$维，这样$h$个head进行拼接，正好是$d$维， 接下来过一个全连接或者线性映射得到MultiHead的输出。
|
||||
$$
|
||||
\hat{X}^{u}=\text { MultiHead }\left(X^{u}\right)=W^{O} \text { concat }\left(\text { head }_{1}^{u}, \ldots, \text { head }_{h}^{u}\right)
|
||||
$$
|
||||
|
||||
这样就相当于更相似的$h_i^u$融合到了一块，而这个更相似又是从多个角度得到的，于是乎， 作者认为，这样就能学习到用户的多兴趣。
|
||||
|
||||
得到这个东西之后，接下来再过一个User Attention， 因为作者发现，对于相似历史行为的不同用户，其兴趣偏好也不太一样。
|
||||
所以加入这个用户Attention层，想挖掘更细粒度的用户个性化信息。 当然，这个就是普通的embedding层了， 用户的base向量$e_u$作为query，与$\hat{X}^{u}$的每个向量做Attention，然后加权求和得最终向量：
|
||||
$$
|
||||
\begin{aligned}
|
||||
\alpha_{k} &=\frac{\exp \left(\hat{\boldsymbol{h}}_{k}^{u T} \boldsymbol{e}_{u}\right)}{\sum_{k=1}^{t} \exp \left(\hat{\boldsymbol{h}}_{k}^{u T} \boldsymbol{e}_{u}\right)} \\
|
||||
\boldsymbol{s}_{t}^{u} &=\sum_{k=1}^{t} \alpha_{k} \hat{\boldsymbol{h}}_{k}^{u}
|
||||
\end{aligned}
|
||||
$$
|
||||
其中$s_{t}^{u} \in \mathbb{R}^{d \times 1}$，这样短期行为兴趣就修成了正果。
|
||||
|
||||
### 用户长期行为建模
|
||||
从长期的视角来看，用户在不同的维度上可能积累了广泛的兴趣，用户可能经常访问一组类似的商店，并反复购买属于同一类别的商品。 所以长期行为$\mathcal{L}^{u}$来自于不同的特征尺度。
|
||||
$$
|
||||
\mathcal{L}^{u}=\left\{\mathcal{L}_{f}^{u} \mid f \in \mathcal{F}\right\}
|
||||
$$
|
||||
这里面包含了各种side特征。这里就和短期行为那里不太一样了，长期行为这里，是从特征的维度进行聚合，也就是把用户的历史长序列分成了多个特征，比如用户历史点击过的商品，历史逛过的店铺，历史看过的商品的类别，品牌等，分成了多个特征子集，然后这每个特征子集里面有对应的id，比如商品有商品id, 店铺有店铺id等，对于每个子集，过user Attention layer，和用户的base向量求Attention， 相当于看看用户喜欢逛啥样的商店， 喜欢啥样的品牌，啥样的商品类别等等，得到每个子集最终的表示向量。每个子集的计算过程如下：
|
||||
$$
|
||||
\begin{aligned}
|
||||
\alpha_{k} &=\frac{\exp \left(\boldsymbol{g}_{k}^{u T} \boldsymbol{e}_{u}\right)}{\sum_{k=1}^{\left|\mathcal{L}_{f}^{u}\right|} \exp \left(\boldsymbol{g}_{k}^{u T} \boldsymbol{e}_{u}\right)} \\
|
||||
z_{f}^{u} &=\sum_{k=1}^{\left|\mathcal{L}_{f}^{u}\right|} \alpha_{k} \boldsymbol{g}_{k}^{u}
|
||||
\end{aligned}
|
||||
$$
|
||||
每个子集都会得到一个加权的向量，把这个东西拼起来，然后过DNN。
|
||||
$$
|
||||
\begin{aligned}
|
||||
&z^{u}=\operatorname{concat}\left(\left\{z_{f}^{u} \mid f \in \mathcal{F}\right\}\right) \\
|
||||
&\boldsymbol{p}^{u}=\tanh \left(\boldsymbol{W}^{p} z^{u}+b\right)
|
||||
\end{aligned}
|
||||
$$
|
||||
这里的$\boldsymbol{p}^{u} \in \mathbb{R}^{d \times 1}$， 这样就得到了用户的长期兴趣表示。
|
||||
### 短长期兴趣融合
|
||||
长短期兴趣融合这里，作者发现之前模型往往喜欢直接拼接起来，或者加和，注意力加权等，但作者认为这样不能很好的将两类兴趣融合起来，因为长期序列里面，其实只有很少的一部分行为和当前有关。那么这样的话，直接无脑融合是有问题的。所以这里作者用了一种较为巧妙的方式，即门控机制：
|
||||
$$
|
||||
G_{t}^{u}=\operatorname{sigmoid}\left(\boldsymbol{W}^{1} \boldsymbol{e}_{u}+\boldsymbol{W}^{2} s_{t}^{u}+\boldsymbol{W}^{3} \boldsymbol{p}^{u}+b\right) \\
|
||||
o_{t}^{u}=\left(1-G_{t}^{u}\right) \odot p^{u}+G_{t}^{u} \odot s_{t}^{u}
|
||||
$$
|
||||
这个和LSTM的这种门控机制很像，首先门控接收的输入有用户画像$e_u$，用户短期兴趣$s_t^u$， 用户长期兴趣$p^u$，经过sigmoid函数得到了$G_{t}^{u} \in \mathbb{R}^{d \times 1}$，用来决定在$t$时刻短期和长期兴趣的贡献程度。然后根据这个贡献程度对短期和长期偏好加权进行融合。
|
||||
|
||||
为啥这东西就有用了呢？ 实验中证明了这个东西有用，但这里给出我的理解哈，我们知道最终得到的短期或者长期兴趣都是$d$维的向量， 每一个维度可能代表着不同的兴趣偏好，比如第一维度代表品牌，第二个维度代表类别，第三个维度代表价格，第四个维度代表商店等等，当然假设哈，真实的向量不可解释。
|
||||
|
||||
那么如果我们是直接相加或者是加权相加，其实都意味着长短期兴趣这每个维度都有很高的保留， 但其实上，万一长期兴趣和短期兴趣维度冲突了呢？ 比如短期兴趣里面可能用户喜欢这个品牌，长期用户里面用户喜欢那个品牌，那么听谁的？ 你可能说短期兴趣这个占更大权重呗，那么普通加权可是所有向量都加的相同的权重，品牌这个维度听短期兴趣的，其他维度比如价格，商店也都听短期兴趣的？本身存在不合理性。那么反而直接相加或者加权效果会不好。
|
||||
|
||||
而门控机制的巧妙就在于，我会给每个维度都学习到一个权重，而这个权重非0即1(近似哈)， 那么接下来融合的时候，我通过这个门控机制，取长期和短期兴趣向量每个维度上的其中一个。比如在品牌方面听谁的，类别方面听谁的，价格方面听谁的，只会听短期和长期兴趣的其中一个的。这样就不会有冲突发生，而至于具体听谁的，交给网络自己学习。这样就使得用户长期兴趣和短期兴趣融合的时候，每个维度上的信息保留变得**有选择**。使得兴趣的融合方式更加的灵活。
|
||||
|
||||
==这其实又给我们提供了一种两个向量融合的一种新思路，并不一定非得加权或者拼接或者相加了，还可以通过门控机制让网络自己学==
|
||||
|
||||
|
||||
## SDM模型的简易复现
|
||||
下面参考DeepMatch，用简易的代码实现下SDM，并在新闻推荐的数据集上进行召回任务。
|
||||
|
||||
首先，下面分析SDM的整体架构，从代码层面看运行流程， 然后就这里面几个关键的细节进行说明。
|
||||
|
||||
### 模型的输入
|
||||
对于SDM模型，由于它是将用户的行为序列分成了会话的形式，所以在构造SDM模型输入方面和前面的MIND以及YouTubeDNN有很大的不同了，所以这里需要先重点强调下输入。
|
||||
|
||||
在为SDM产生数据集的时候， 需要传入短期会话的长度以及长期会话的长度， 这样， 对于一个行为序列，构造数据集的时候要按照两个长度分成短期行为和长期行为两种，并且每一种都需要指明真实的序列长度。另外，由于这里用到了文章的side info信息，所以我这里在之前列的基础上加入了文章的两个类别特征分别是cat_1和cat_2，作为文章的side info。 这个产生数据集的代码如下：
|
||||
|
||||
```python
|
||||
"""构造sdm数据集"""
|
||||
def get_data_set(click_data, seq_short_len=5, seq_prefer_len=50):
|
||||
"""
|
||||
:param: seq_short_len: 短期会话的长度
|
||||
:param: seq_prefer_len: 会话的最长长度
|
||||
"""
|
||||
click_data.sort_values("expo_time", inplace=True)
|
||||
|
||||
train_set, test_set = [], []
|
||||
for user_id, hist_click in tqdm(click_data.groupby('user_id')):
|
||||
pos_list = hist_click['article_id'].tolist()
|
||||
cat1_list = hist_click['cat_1'].tolist()
|
||||
cat2_list = hist_click['cat_2'].tolist()
|
||||
|
||||
# 滑动窗口切分数据
|
||||
for i in range(1, len(pos_list)):
|
||||
hist = pos_list[:i]
|
||||
cat1_hist = cat1_list[:i]
|
||||
cat2_hist = cat2_list[:i]
|
||||
# 序列长度只够短期的
|
||||
if i <= seq_short_len and i != len(pos_list) - 1:
|
||||
train_set.append((
|
||||
# 用户id, 用户短期历史行为序列， 用户长期历史行为序列， 当前行为文章， label，
|
||||
user_id, hist[::-1], [0]*seq_prefer_len, pos_list[i], 1,
|
||||
# 用户短期历史序列长度， 用户长期历史序列长度，
|
||||
len(hist[::-1]), 0,
|
||||
# 用户短期历史序列对应类别1， 用户长期历史行为序列对应类别1
|
||||
cat1_hist[::-1], [0]*seq_prefer_len,
|
||||
# 历史短期历史序列对应类别2， 用户长期历史行为序列对应类别2
|
||||
cat2_hist[::-1], [0]*seq_prefer_len
|
||||
))
|
||||
# 序列长度够长期的
|
||||
elif i != len(pos_list) - 1:
|
||||
train_set.append((
|
||||
# 用户id, 用户短期历史行为序列，用户长期历史行为序列， 当前行为文章， label
|
||||
user_id, hist[::-1][:seq_short_len], hist[::-1][seq_short_len:], pos_list[i], 1,
|
||||
# 用户短期行为序列长度，用户长期行为序列长度，
|
||||
seq_short_len, len(hist[::-1])-seq_short_len,
|
||||
# 用户短期历史行为序列对应类别1， 用户长期历史行为序列对应类别1
|
||||
cat1_hist[::-1][:seq_short_len], cat1_hist[::-1][seq_short_len:],
|
||||
# 用户短期历史行为序列对应类别2， 用户长期历史行为序列对应类别2
|
||||
cat2_hist[::-1][:seq_short_len], cat2_hist[::-1][seq_short_len:]
|
||||
))
|
||||
# 测试集保留最长的那一条
|
||||
elif i <= seq_short_len and i == len(pos_list) - 1:
|
||||
test_set.append((
|
||||
user_id, hist[::-1], [0]*seq_prefer_len, pos_list[i], 1,
|
||||
len(hist[::-1]), 0,
|
||||
cat1_hist[::-1], [0]*seq_perfer_len,
|
||||
cat2_hist[::-1], [0]*seq_prefer_len
|
||||
))
|
||||
else:
|
||||
test_set.append((
|
||||
user_id, hist[::-1][:seq_short_len], hist[::-1][seq_short_len:], pos_list[i], 1,
|
||||
seq_short_len, len(hist[::-1])-seq_short_len,
|
||||
cat1_hist[::-1][:seq_short_len], cat1_hist[::-1][seq_short_len:],
|
||||
cat2_list[::-1][:seq_short_len], cat2_hist[::-1][seq_short_len:]
|
||||
))
|
||||
|
||||
random.shuffle(train_set)
|
||||
random.shuffle(test_set)
|
||||
|
||||
return train_set, test_set
|
||||
```
|
||||
思路和之前的是一样的，无非就是根据会话的长短，把之前的一个长行为序列划分成了短期和长期两个，然后加入两个新的side info特征。
|
||||
|
||||
### 模型的代码架构
|
||||
整个SDM模型算是参考deepmatch修改的一个简易版本：
|
||||
|
||||
```python
|
||||
def SDM(user_feature_columns, item_feature_columns, history_feature_list, num_sampled=5, units=32, rnn_layers=2,
|
||||
dropout_rate=0.2, rnn_num_res=1, num_head=4, l2_reg_embedding=1e-6, dnn_activation='tanh', seed=1024):
|
||||
"""
|
||||
:param rnn_num_res: rnn的残差层个数
|
||||
:param history_feature_list: short和long sequence field
|
||||
"""
|
||||
# item_feature目前只支持doc_id， 再加别的就不行了，其实这里可以改造下
|
||||
if (len(item_feature_columns)) > 1:
|
||||
raise ValueError("SDM only support 1 item feature like doc_id")
|
||||
|
||||
# 获取item_feature的一些属性
|
||||
item_feature_column = item_feature_columns[0]
|
||||
item_feature_name = item_feature_column.name
|
||||
item_vocabulary_size = item_feature_column.vocabulary_size
|
||||
|
||||
# 为用户特征创建Input层
|
||||
user_input_layer_dict = build_input_layers(user_feature_columns)
|
||||
item_input_layer_dict = build_input_layers(item_feature_columns)
|
||||
|
||||
# 将Input层转化成列表的形式作为model的输入
|
||||
user_input_layers = list(user_input_layer_dict.values())
|
||||
item_input_layers = list(item_input_layer_dict.values())
|
||||
|
||||
# 筛选出特征中的sparse特征和dense特征，方便单独处理
|
||||
sparse_feature_columns = list(filter(lambda x: isinstance(x, SparseFeat), user_feature_columns)) if user_feature_columns else []
|
||||
dense_feature_columns = list(filter(lambda x: isinstance(x, DenseFeat), user_feature_columns)) if user_feature_columns else []
|
||||
if len(dense_feature_columns) != 0:
|
||||
raise ValueError("SDM dont support dense feature") # 目前不支持Dense feature
|
||||
varlen_feature_columns = list(filter(lambda x: isinstance(x, VarLenSparseFeat), user_feature_columns)) if user_feature_columns else []
|
||||
|
||||
# 构建embedding字典
|
||||
embedding_layer_dict = build_embedding_layers(user_feature_columns+item_feature_columns)
|
||||
|
||||
# 拿到短期会话和长期会话列 之前的命名规则在这里起作用
|
||||
sparse_varlen_feature_columns = []
|
||||
prefer_history_columns = []
|
||||
short_history_columns = []
|
||||
|
||||
prefer_fc_names = list(map(lambda x: "prefer_" + x, history_feature_list))
|
||||
short_fc_names = list(map(lambda x: "short_" + x, history_feature_list))
|
||||
|
||||
for fc in varlen_feature_columns:
|
||||
if fc.name in prefer_fc_names:
|
||||
prefer_history_columns.append(fc)
|
||||
elif fc.name in short_fc_names:
|
||||
short_history_columns.append(fc)
|
||||
else:
|
||||
sparse_varlen_feature_columns.append(fc)
|
||||
|
||||
# 获取用户的长期行为序列列表 L^u
|
||||
# [<tf.Tensor 'emb_prefer_doc_id_2/Identity:0' shape=(None, 50, 32) dtype=float32>, <tf.Tensor 'emb_prefer_cat1_2/Identity:0' shape=(None, 50, 32) dtype=float32>, <tf.Tensor 'emb_prefer_cat2_2/Identity:0' shape=(None, 50, 32) dtype=float32>]
|
||||
prefer_emb_list = embedding_lookup(prefer_fc_names, user_input_layer_dict, embedding_layer_dict)
|
||||
# 获取用户的短期序列列表 S^u
|
||||
# [<tf.Tensor 'emb_short_doc_id_2/Identity:0' shape=(None, 5, 32) dtype=float32>, <tf.Tensor 'emb_short_cat1_2/Identity:0' shape=(None, 5, 32) dtype=float32>, <tf.Tensor 'emb_short_cat2_2/Identity:0' shape=(None, 5, 32) dtype=float32>]
|
||||
short_emb_list = embedding_lookup(short_fc_names, user_input_layer_dict, embedding_layer_dict)
|
||||
|
||||
# 用户离散特征的输入层与embedding层拼接 e^u
|
||||
user_emb_list = embedding_lookup([col.name for col in sparse_feature_columns], user_input_layer_dict, embedding_layer_dict)
|
||||
user_emb = concat_func(user_emb_list)
|
||||
user_emb_output = Dense(units, activation=dnn_activation, name='user_emb_output')(user_emb) # (None, 1, 32)
|
||||
|
||||
# 长期序列行为编码
|
||||
# 过AttentionSequencePoolingLayer --> Concat --> DNN
|
||||
prefer_sess_length = user_input_layer_dict['prefer_sess_length']
|
||||
prefer_att_outputs = []
|
||||
# 遍历长期行为序列
|
||||
for i, prefer_emb in enumerate(prefer_emb_list):
|
||||
prefer_attention_output = AttentionSequencePoolingLayer(dropout_rate=0)([user_emb_output, prefer_emb, prefer_sess_length])
|
||||
prefer_att_outputs.append(prefer_attention_output)
|
||||
prefer_att_concat = concat_func(prefer_att_outputs) # (None, 1, 64) <== Concat(item_embedding，cat1_embedding,cat2_embedding)
|
||||
prefer_output = Dense(units, activation=dnn_activation, name='prefer_output')(prefer_att_concat)
|
||||
# print(prefer_output.shape) # (None, 1, 32)
|
||||
|
||||
# 短期行为序列编码
|
||||
short_sess_length = user_input_layer_dict['short_sess_length']
|
||||
short_emb_concat = concat_func(short_emb_list) # (None, 5, 64) 这里注意下， 对于短期序列，描述item的side info信息进行了拼接
|
||||
short_emb_input = Dense(units, activation=dnn_activation, name='short_emb_input')(short_emb_concat) # (None, 5, 32)
|
||||
# 过rnn 这里的return_sequence=True， 每个时间步都需要输出h
|
||||
short_rnn_output = DynamicMultiRNN(num_units=units, return_sequence=True, num_layers=rnn_layers,
|
||||
num_residual_layers=rnn_num_res, # 这里竟然能用到残差
|
||||
dropout_rate=dropout_rate)([short_emb_input, short_sess_length])
|
||||
# print(short_rnn_output) # (None, 5, 32)
|
||||
# 过MultiHeadAttention # (None, 5, 32)
|
||||
short_att_output = MultiHeadAttention(num_units=units, head_num=num_head, dropout_rate=dropout_rate)([short_rnn_output, short_sess_length]) # (None, 5, 64)
|
||||
# user_attention # (None, 1, 32)
|
||||
short_output = UserAttention(num_units=units, activation=dnn_activation, use_res=True, dropout_rate=dropout_rate)([user_emb_output, short_att_output, short_sess_length])
|
||||
|
||||
# 门控融合
|
||||
gated_input = concat_func([prefer_output, short_output, user_emb_output])
|
||||
gate = Dense(units, activation='sigmoid')(gated_input) # (None, 1, 32)
|
||||
|
||||
# temp = tf.multiply(gate, short_output) + tf.multiply(1-gate, prefer_output) 感觉这俩一样？
|
||||
gated_output = Lambda(lambda x: tf.multiply(x[0], x[1]) + tf.multiply(1-x[0], x[2]))([gate, short_output, prefer_output]) # [None, 1,32]
|
||||
gated_output_reshape = Lambda(lambda x: tf.squeeze(x, 1))(gated_output) # (None, 32) 这个维度必须要和docembedding层的维度一样，否则后面没法sortmax_loss
|
||||
|
||||
# 接下来
|
||||
item_embedding_matrix = embedding_layer_dict[item_feature_name] # 获取doc_id的embedding层
|
||||
item_index = EmbeddingIndex(list(range(item_vocabulary_size)))(item_input_layer_dict[item_feature_name]) # 所有doc_id的索引
|
||||
item_embedding_weight = NoMask()(item_embedding_matrix(item_index)) # 拿到所有item的embedding
|
||||
pooling_item_embedding_weight = PoolingLayer()([item_embedding_weight]) # 这里依然是当可能不止item_id，或许还有brand_id, cat_id等，需要池化
|
||||
|
||||
# 这里传入的是整个doc_id的embedding， user_embedding, 以及用户点击的doc_id，然后去进行负采样计算损失操作
|
||||
output = SampledSoftmaxLayer(num_sampled)([pooling_item_embedding_weight, gated_output_reshape, item_input_layer_dict[item_feature_name]])
|
||||
|
||||
model = Model(inputs=user_input_layers+item_input_layers, outputs=output)
|
||||
|
||||
# 下面是等模型训练完了之后，获取用户和item的embedding
|
||||
model.__setattr__("user_input", user_input_layers)
|
||||
model.__setattr__("user_embedding", gated_output_reshape) # 用户embedding是取得门控融合的用户向量
|
||||
model.__setattr__("item_input", item_input_layers)
|
||||
# item_embedding取得pooling_item_embedding_weight, 这个会发现是负采样操作训练的那个embedding矩阵
|
||||
model.__setattr__("item_embedding", get_item_embedding(pooling_item_embedding_weight, item_input_layer_dict[item_feature_name]))
|
||||
return model
|
||||
```
|
||||
函数式API搭建模型的方式，首先我们需要传入封装好的用户特征描述以及item特征描述，比如：
|
||||
|
||||
```python
|
||||
# 建立模型
|
||||
user_feature_columns = [
|
||||
SparseFeat('user_id', feature_max_idx['user_id'], 16),
|
||||
SparseFeat('gender', feature_max_idx['gender'], 16),
|
||||
SparseFeat('age', feature_max_idx['age'], 16),
|
||||
SparseFeat('city', feature_max_idx['city'], 16),
|
||||
|
||||
VarLenSparseFeat(SparseFeat('short_doc_id', feature_max_idx['article_id'], embedding_dim, embedding_name="doc_id"), SEQ_LEN_short, 'mean', 'short_sess_length'),
|
||||
VarLenSparseFeat(SparseFeat('prefer_doc_id', feature_max_idx['article_id'], embedding_dim, embedding_name='doc_id'), SEQ_LEN_prefer, 'mean', 'prefer_sess_length'),
|
||||
VarLenSparseFeat(SparseFeat('short_cat1', feature_max_idx['cat_1'], embedding_dim, embedding_name='cat_1'), SEQ_LEN_short, 'mean', 'short_sess_length'),
|
||||
VarLenSparseFeat(SparseFeat('prefer_cat1', feature_max_idx['cat_1'], embedding_dim, embedding_name='cat_1'), SEQ_LEN_prefer, 'mean', 'prefer_sess_length'),
|
||||
VarLenSparseFeat(SparseFeat('short_cat2', feature_max_idx['cat_2'], embedding_dim, embedding_name='cat_2'), SEQ_LEN_short, 'mean', 'short_sess_length'),
|
||||
VarLenSparseFeat(SparseFeat('prefer_cat2', feature_max_idx['cat_2'], embedding_dim, embedding_name='cat_2'), SEQ_LEN_prefer, 'mean', 'prefer_sess_length'),
|
||||
]
|
||||
|
||||
item_feature_columns = [SparseFeat('doc_id', feature_max_idx['article_id'], embedding_dim)]
|
||||
```
|
||||
这里需要注意的一个点是短期和长期序列的名字，必须严格的`short_， prefer_`进行标识，因为在模型搭建的时候就是靠着这个去找到短期和长期序列特征的。
|
||||
|
||||
逻辑其实也比较清晰，首先是建立Input层，然后是embedding层， 接下来，根据命名选择出用户的base特征列， 短期行为序列和长期行为序列。长期序列的话是过`AttentionPoolingLayer`层进行编码，这里本质上注意力然后融合，但这里注意的一个点就是for循环，也就是长期序列行为里面的特征列，比如商品，cat_1, cat_2是for循环的形式求融合向量，再拼接起来过DNN，和论文图保持一致。
|
||||
|
||||
短期序列编码部分，是`item_embedding,cat_1embedding， cat_2embedding`拼接起来，过`DynamicMultiRNN`层学习序列信息， 过`MultiHeadAttention`学习多兴趣，最后过`UserAttentionLayer`进行向量融合。 接下来，长期兴趣向量和短期兴趣向量以及用户base向量，过门控融合机制，得到最终的`user_embedding`。
|
||||
|
||||
而后面的那块是为了模型训练完之后，拿用户embedding和item embedding用的， 这个在MIND那篇文章里作了解释。
|
||||
|
||||
## 总结
|
||||
今天整理的是SDM，这也是一个标准的序列推荐召回模型，主要还是研究用户的序列，不过这篇paper里面一个有意思的点就是把用户的行为训练以会话的形式进行切分，然后再根据时间，分成了短期会话和长期会话，然后分别采用不同的策略去学习用户的短期兴趣和长期兴趣。
|
||||
* 对于短期会话，可能和当前预测相关性较大，所以首先用RNN来学习序列信息，然后采用多头注意力机制得到用户的多兴趣， 隐隐约约感觉多头注意力机制还真有种能聚类的功效，接下来就是和用户的base向量进行注意力融合得到短期兴趣
|
||||
* 长期会话序列中，每个side info信息进行分开，然后分别进行注意力编码融合得到
|
||||
|
||||
为了使得长期会话中对当前预测有用的部分得以体现，在融合短期兴趣和长期兴趣的时候，采用了门控的方式，而不是普通的拼接或者加和等操作，使得兴趣保留信息变得**有选择**。
|
||||
|
||||
这其实就是这篇paper的故事了，借鉴的地方首先是多头注意力机制也能学习到用户的多兴趣， 这样对于多兴趣，就有了胶囊网络与多头注意力机制两种思路。 而对于两个向量融合，这里又给我们提供了一种门控融合机制。
|
||||
|
||||
|
||||
**参考**：
|
||||
|
||||
* SDM原论文
|
||||
* [AI上推荐 之 SDM模型(建模用户长短期兴趣的Match模型)](https://blog.csdn.net/wuzhongqiang/article/details/123856954?spm=1001.2014.3001.5501)
|
||||
* [一文读懂Attention机制](https://zhuanlan.zhihu.com/p/129316415)
|
||||
* [【推荐系统经典论文(十)】阿里SDM模型](https://zhuanlan.zhihu.com/p/137775247?from_voters_page=true)
|
||||
* [SDM-深度序列召回模型](https://zhuanlan.zhihu.com/p/395673080)
|
||||
* [推荐广告中的序列建模](https://blog.csdn.net/qq_41010971/article/details/123762312?spm=1001.2014.3001.5501)
|
||||
65
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.5/TDM.md
Normal file
65
2023旧版内容/4.人工智能/ch02/ch2.1/ch2.1.5/TDM.md
Normal file
@@ -0,0 +1,65 @@
|
||||
# 背景和目的
|
||||
|
||||
召回早前经历的第一代协同过滤技术，让模型可以在数量级巨大的item集中找到用户潜在想要看到的商品。这种方式有很明显的缺点，一个是对于用户而言，只能通过他历史行为去构建候选集，并且会基于算力的局限做截断。所以推荐结果的多样性和新颖性比较局限，导致推荐的有可能都是用户看过的或者买过的商品。之后在Facebook开源了FASSI库之后，基于内积模型的向量检索方案得到了广泛应用，也就是第二代召回技术。这种技术通过将用户和物品用向量表示，然后用内积的大小度量兴趣，借助向量索引实现大规模的全量检索。这里虽然改善了第一代的无法全局检索的缺点，然而这种模式下存在索引构建和模型优化目标不一致的问题，索引优化是基于向量的近似误差，而召回问题的目标是最大化topK召回率。且这类方法也不方便在用户和物品之间做特征组合。
|
||||
|
||||
所以阿里开发了一种可以承载各种深度模型来检索用户潜在兴趣的推荐算法解决方案。这个TDM模型是基于树结构，利用树结构对全量商品进行检索，将复杂度由O(N)下降到O(logN)。
|
||||
|
||||
# 模型结构
|
||||
|
||||
**树结构**
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220420213149324.png" alt="image-20210308142624189" style="zoom: 15%;" />
|
||||
</div>
|
||||
|
||||
如上图，树中的每一个叶子节点对应一个商品item，非叶子结点表示的是item的集合**（这里的树不限于二叉树）**。这种层次化结构体现了粒度从粗到细的item架构。
|
||||
|
||||
**整体结构**
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220420200433442.png" alt="image-20210308142624189" style="zoom: 70%;" />
|
||||
</div>
|
||||
|
||||
# 算法详解
|
||||
|
||||
1. 基于树的高效检索
|
||||
|
||||
算法通常采用beam-search的方法，根据用户对每层节点挑选出topK，将挑选出来的这几个topK节点的子节点作为下一层的候选集，最终会落到叶子节点上。
|
||||
这么做的理论依据是当前层的最有优topK节点的父亲必然属于上次的父辈节点的最优topK：
|
||||
$$
|
||||
p^{(j)}(n|u) = {{max \atop{n_{c}\in{\{n's children nodes in level j+1\}}}}p^{(j+1)}(n_{c}|u) \over {\alpha^{j}}}
|
||||
$$
|
||||
其中$p^{(j)}(n|u)$表示用户u对j层节点n感兴趣的概率，$\alpha^{j}$表示归一化因子。
|
||||
|
||||
2. 对兴趣进行建模
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220420214040264.png" alt="image-20210308142624189" style="zoom: 50%;" />
|
||||
</div>
|
||||
|
||||
如上图，用户对叶子层item6感兴趣，可以认为它的兴趣是1，同层别的候选节点的兴趣为0，顺着着绿色线路上去的节点都标记为1，路线上的同层别的候选节点都标记为0。这样的操作就可以根据1和0构建用于每一层的正负样本。
|
||||
|
||||
样本构建完成后，可以在模型结构左侧采用任意的深度学习模型来承担用户兴趣判别器的角色，输入就是当前层构造的正负样本，输出则是（用户，节点）对的兴趣度，这个将被用作检索过程中选取topK的评判指标。**在整体结构图中，我们可以看到节点特征方面，使用的是node embedding**，说明在进入模型前已经向量化了。
|
||||
|
||||
3. 训练过程
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20220420220831318.png" alt="image-20210308142624189" style="zoom: 15%;" />
|
||||
</div>
|
||||
|
||||
整体联合训练的方式如下：
|
||||
|
||||
1. 构造随机二叉树
|
||||
2. 基于树模型生成样本
|
||||
3. 训练DNN模型直到收敛
|
||||
4. 基于DNN模型得到样本的Embedding，重新构造聚类二叉树
|
||||
5. 循环上述2～4过程
|
||||
|
||||
具体的，在初始化树结构的时候，首先借助商品的类别信息进行排序，将相同类别的商品放到一起，然后递归的将同类别中的商品等量的分到两个子类中，直到集合中只包含一项，利用这种自顶向下的方式来初始化一棵树。基于该树采样生成深度模型训练所需的样本，然后进一步训练模型，训练结束之后可以得到每个树节点对应的Embedding向量，利用节点的Embedding向量，采用K-Means聚类方法来重新构建一颗树，最后基于这颗新生成的树，重新训练深层网络。
|
||||
|
||||
**参考资料**
|
||||
|
||||
- [阿里妈妈深度树检索技术(TDM) 及应用框架的探索实践](https://mp.weixin.qq.com/s/sw16_sUsyYuzpqqy39RsdQ)
|
||||
- [阿里TDM：Tree-based Deep Model](https://zhuanlan.zhihu.com/p/78941783)
|
||||
- [阿里妈妈TDM模型详解](https://zhuanlan.zhihu.com/p/93201318)
|
||||
- [Paddle TDM 模型实现](https://github.com/PaddlePaddle/PaddleRec/blob/master/models/treebased/README.md)
|
||||
352
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.1.md
Normal file
352
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.1.md
Normal file
@@ -0,0 +1,352 @@
|
||||
### GBDT+LR简介
|
||||
|
||||
前面介绍的协同过滤和矩阵分解存在的劣势就是仅利用了用户与物品相互行为信息进行推荐， 忽视了用户自身特征， 物品自身特征以及上下文信息等，导致生成的结果往往会比较片面。 而这次介绍的这个模型是2014年由Facebook提出的GBDT+LR模型， 该模型利用GBDT自动进行特征筛选和组合， 进而生成新的离散特征向量， 再把该特征向量当做LR模型的输入， 来产生最后的预测结果， 该模型能够综合利用用户、物品和上下文等多种不同的特征， 生成较为全面的推荐结果， 在CTR点击率预估场景下使用较为广泛。
|
||||
|
||||
下面首先会介绍逻辑回归和GBDT模型各自的原理及优缺点， 然后介绍GBDT+LR模型的工作原理和细节。
|
||||
|
||||
### 逻辑回归模型
|
||||
|
||||
逻辑回归模型非常重要， 在推荐领域里面， 相比于传统的协同过滤， 逻辑回归模型能够综合利用用户、物品、上下文等多种不同的特征生成较为“全面”的推荐结果， 关于逻辑回归的更多细节， 可以参考下面给出的链接，这里只介绍比较重要的一些细节和在推荐中的应用。
|
||||
|
||||
逻辑回归是在线性回归的基础上加了一个 Sigmoid 函数（非线形）映射，使得逻辑回归成为了一个优秀的分类算法， 学习逻辑回归模型， 首先应该记住一句话：**逻辑回归假设数据服从伯努利分布,通过极大化似然函数的方法，运用梯度下降来求解参数，来达到将数据二分类的目的。**
|
||||
|
||||
相比于协同过滤和矩阵分解利用用户的物品“相似度”进行推荐， 逻辑回归模型将问题看成了一个分类问题， 通过预测正样本的概率对物品进行排序。这里的正样本可以是用户“点击”了某个商品或者“观看”了某个视频， 均是推荐系统希望用户产生的“正反馈”行为， 因此**逻辑回归模型将推荐问题转化成了一个点击率预估问题**。而点击率预测就是一个典型的二分类， 正好适合逻辑回归进行处理， 那么逻辑回归是如何做推荐的呢？ 过程如下：
|
||||
1. 将用户年龄、性别、物品属性、物品描述、当前时间、当前地点等特征转成数值型向量
|
||||
2. 确定逻辑回归的优化目标，比如把点击率预测转换成二分类问题， 这样就可以得到分类问题常用的损失作为目标， 训练模型
|
||||
3. 在预测的时候， 将特征向量输入模型产生预测， 得到用户“点击”物品的概率
|
||||
4. 利用点击概率对候选物品排序， 得到推荐列表
|
||||
|
||||
推断过程可以用下图来表示：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20200909215410263.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="在这里插入图片描述" style="zoom:55%;" />
|
||||
</div>
|
||||
|
||||
这里的关键就是每个特征的权重参数$w$， 我们一般是使用梯度下降的方式， 首先会先随机初始化参数$w$， 然后将特征向量（也就是我们上面数值化出来的特征）输入到模型， 就会通过计算得到模型的预测概率， 然后通过对目标函数求导得到每个$w$的梯度， 然后进行更新$w$
|
||||
|
||||
这里的目标函数长下面这样：
|
||||
|
||||
$$
|
||||
J(w)=-\frac{1}{m}\left(\sum_{i=1}^{m}\left(y^{i} \log f_{w}\left(x^{i}\right)+\left(1-y^{i}\right) \log \left(1-f_{w}\left(x^{i}\right)\right)\right)\right.
|
||||
$$
|
||||
求导之后的方式长这样：
|
||||
$$
|
||||
w_{j} \leftarrow w_{j}-\gamma \frac{1}{m} \sum_{i=1}^{m}\left(f_{w}\left(x^{i}\right)-y^{i}\right) x_{j}^{i}
|
||||
$$
|
||||
这样通过若干次迭代， 就可以得到最终的$w$了， 关于这些公式的推导，可以参考下面给出的文章链接， 下面我们分析一下逻辑回归模型的优缺点。
|
||||
|
||||
**优点：**
|
||||
1. LR模型形式简单，可解释性好，从特征的权重可以看到不同的特征对最后结果的影响。
|
||||
2. 训练时便于并行化，在预测时只需要对特征进行线性加权，所以**性能比较好**，往往适合处理**海量id类特征**，用id类特征有一个很重要的好处，就是**防止信息损失**（相对于范化的 CTR 特征），对于头部资源会有更细致的描述
|
||||
3. 资源占用小,尤其是内存。在实际的工程应用中只需要存储权重比较大的特征及特征对应的权重。
|
||||
4. 方便输出结果调整。逻辑回归可以很方便的得到最后的分类结果，因为输出的是每个样本的概率分数，我们可以很容易的对这些概率分数进行cutoff，也就是划分阈值(大于某个阈值的是一类，小于某个阈值的是一类)
|
||||
|
||||
**当然， 逻辑回归模型也有一定的局限性**
|
||||
1. 表达能力不强， 无法进行特征交叉， 特征筛选等一系列“高级“操作（这些工作都得人工来干， 这样就需要一定的经验， 否则会走一些弯路）， 因此可能造成信息的损失
|
||||
2. 准确率并不是很高。因为这毕竟是一个线性模型加了个sigmoid， 形式非常的简单(非常类似线性模型)，很难去拟合数据的真实分布
|
||||
3. 处理非线性数据较麻烦。逻辑回归在不引入其他方法的情况下，只能处理线性可分的数据， 如果想处理非线性， 首先对连续特征的处理需要先进行**离散化**（离散化的目的是为了引入非线性），如上文所说，人工分桶的方式会引入多种问题。
|
||||
4. LR 需要进行**人工特征组合**，这就需要开发者有非常丰富的领域经验，才能不走弯路。这样的模型迁移起来比较困难，换一个领域又需要重新进行大量的特征工程。
|
||||
|
||||
所以如何**自动发现有效的特征、特征组合，弥补人工经验不足，缩短LR特征实验周期**，是亟需解决的问题， 而GBDT模型， 正好可以**自动发现特征并进行有效组合**
|
||||
|
||||
### GBDT模型
|
||||
|
||||
GBDT全称梯度提升决策树，在传统机器学习算法里面是对真实分布拟合的最好的几种算法之一，在前几年深度学习还没有大行其道之前，gbdt在各种竞赛是大放异彩。原因大概有几个，一是效果确实挺不错。二是即可以用于分类也可以用于回归。三是可以筛选特征， 所以这个模型依然是一个非常重要的模型。
|
||||
|
||||
GBDT是通过采用加法模型(即基函数的线性组合），以及不断减小训练过程产生的误差来达到将数据分类或者回归的算法， 其训练过程如下：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20200908202508786.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" style="zoom:65%;" />
|
||||
</div>
|
||||
gbdt通过多轮迭代， 每轮迭代会产生一个弱分类器， 每个分类器在上一轮分类器的残差基础上进行训练。 gbdt对弱分类器的要求一般是足够简单， 并且低方差高偏差。 因为训练的过程是通过降低偏差来不断提高最终分类器的精度。 由于上述高偏差和简单的要求，每个分类回归树的深度不会很深。最终的总分类器是将每轮训练得到的弱分类器加权求和得到的（也就是加法模型）。
|
||||
|
||||
关于GBDT的详细细节，依然是可以参考下面给出的链接。这里想分析一下GBDT如何来进行二分类的，因为我们要明确一点就是**gbdt 每轮的训练是在上一轮的训练的残差基础之上进行训练的**， 而这里的残差指的就是当前模型的负梯度值， 这个就要求每轮迭代的时候，弱分类器的输出的结果相减是有意义的， 而**gbdt 无论用于分类还是回归一直都是使用的CART 回归树**， 那么既然是回归树， 是如何进行二分类问题的呢？
|
||||
|
||||
GBDT 来解决二分类问题和解决回归问题的本质是一样的，都是通过不断构建决策树的方式，使预测结果一步步的接近目标值， 但是二分类问题和回归问题的损失函数是不同的， 关于GBDT在回归问题上的树的生成过程， 损失函数和迭代原理可以参考给出的链接， 回归问题中一般使用的是平方损失， 而二分类问题中， GBDT和逻辑回归一样， 使用的下面这个：
|
||||
|
||||
$$
|
||||
L=\arg \min \left[\sum_{i}^{n}-\left(y_{i} \log \left(p_{i}\right)+\left(1-y_{i}\right) \log \left(1-p_{i}\right)\right)\right]
|
||||
$$
|
||||
其中， $y_i$是第$i$个样本的观测值， 取值要么是0要么是1， 而$p_i$是第$i$个样本的预测值， 取值是0-1之间的概率，由于我们知道GBDT拟合的残差是当前模型的负梯度， 那么我们就需要求出这个模型的导数， 即$\frac{dL}{dp_i}$， 对于某个特定的样本， 求导的话就可以只考虑它本身， 去掉加和号， 那么就变成了$\frac{dl}{dp_i}$， 其中$l$如下：
|
||||
$$
|
||||
\begin{aligned}
|
||||
l &=-y_{i} \log \left(p_{i}\right)-\left(1-y_{i}\right) \log \left(1-p_{i}\right) \\
|
||||
&=-y_{i} \log \left(p_{i}\right)-\log \left(1-p_{i}\right)+y_{i} \log \left(1-p_{i}\right) \\
|
||||
&=-y_{i}\left(\log \left(\frac{p_{i}}{1-p_{i}}\right)\right)-\log \left(1-p_{i}\right)
|
||||
\end{aligned}
|
||||
$$
|
||||
如果对逻辑回归非常熟悉的话， $\left(\log \left(\frac{p_{i}}{1-p_{i}}\right)\right)$一定不会陌生吧， 这就是对几率比取了个对数， 并且在逻辑回归里面这个式子会等于$\theta X$， 所以才推出了$p_i=\frac{1}{1+e^-{\theta X}}$的那个形式。 这里令$\eta_i=\frac{p_i}{1-p_i}$, 即$p_i=\frac{\eta_i}{1+\eta_i}$, 则上面这个式子变成了：
|
||||
|
||||
$$
|
||||
\begin{aligned}
|
||||
l &=-y_{i} \log \left(\eta_{i}\right)-\log \left(1-\frac{e^{\log \left(\eta_{i}\right)}}{1+e^{\log \left(\eta_{i}\right)}}\right) \\
|
||||
&=-y_{i} \log \left(\eta_{i}\right)-\log \left(\frac{1}{1+e^{\log \left(\eta_{i}\right)}}\right) \\
|
||||
&=-y_{i} \log \left(\eta_{i}\right)+\log \left(1+e^{\log \left(\eta_{i}\right)}\right)
|
||||
\end{aligned}
|
||||
$$
|
||||
这时候，我们对$log(\eta_i)$求导， 得
|
||||
$$
|
||||
\frac{d l}{d \log (\eta_i)}=-y_{i}+\frac{e^{\log \left(\eta_{i}\right)}}{1+e^{\log \left(\eta_{i}\right)}}=-y_i+p_i
|
||||
$$
|
||||
这样， 我们就得到了某个训练样本在当前模型的梯度值了， 那么残差就是$y_i-p_i$。GBDT二分类的这个思想，其实和逻辑回归的思想一样，**逻辑回归是用一个线性模型去拟合$P(y=1|x)$这个事件的对数几率$log\frac{p}{1-p}=\theta^Tx$**， GBDT二分类也是如此， 用一系列的梯度提升树去拟合这个对数几率， 其分类模型可以表达为：
|
||||
$$
|
||||
P(Y=1 \mid x)=\frac{1}{1+e^{-F_{M}(x)}}
|
||||
$$
|
||||
|
||||
下面我们具体来看GBDT的生成过程， 构建分类GBDT的步骤有两个：
|
||||
1. 初始化GBDT
|
||||
和回归问题一样， 分类 GBDT 的初始状态也只有一个叶子节点，该节点为所有样本的初始预测值，如下：
|
||||
$$
|
||||
F_{0}(x)=\arg \min _{\gamma} \sum_{i=1}^{n} L(y, \gamma)
|
||||
$$
|
||||
上式里面， $F$代表GBDT模型， $F_0$是模型的初识状态， 该式子的意思是找到一个$\gamma$，使所有样本的 Loss 最小，在这里及下文中，$\gamma$都表示节点的输出，即叶子节点， 且它是一个 $log(\eta_i)$ 形式的值(回归值)，在初始状态，$\gamma =F_0$。
|
||||
|
||||
下面看例子(该例子来自下面的第二个链接)， 假设我们有下面3条样本：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20200910095539432.png#pic_center" alt="在这里插入图片描述" style="zoom:80%;" />
|
||||
</div>
|
||||
|
||||
我们希望构建 GBDT 分类树，它能通过「喜欢爆米花」、「年龄」和「颜色偏好」这 3 个特征来预测某一个样本是否喜欢看电影。我们把数据代入上面的公式中求Loss:
|
||||
$$
|
||||
\operatorname{Loss}=L(1, \gamma)+L(1, \gamma)+L(0, \gamma)
|
||||
$$
|
||||
为了令其最小， 我们求导， 且让导数为0， 则：
|
||||
$$
|
||||
\operatorname{Loss}=p-1 + p-1+p=0
|
||||
$$
|
||||
于是， 就得到了初始值$p=\frac{2}{3}=0.67, \gamma=log(\frac{p}{1-p})=0.69$, 模型的初识状态$F_0(x)=0.69$
|
||||
|
||||
2. 循环生成决策树
|
||||
这里回忆一下回归树的生成步骤， 其实有4小步， 第一就是计算负梯度值得到残差， 第二步是用回归树拟合残差， 第三步是计算叶子节点的输出值， 第四步是更新模型。 下面我们一一来看：
|
||||
|
||||
1. 计算负梯度得到残差
|
||||
$$
|
||||
r_{i m}=-\left[\frac{\partial L\left(y_{i}, F\left(x_{i}\right)\right)}{\partial F\left(x_{i}\right)}\right]_{F(x)=F_{m-1}(x)}
|
||||
$$
|
||||
此处使用$m-1$棵树的模型， 计算每个样本的残差$r_{im}$, 就是上面的$y_i-pi$, 于是例子中， 每个样本的残差：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20200910101154282.png#pic_center" alt="在这里插入图片描述" style="zoom:80%;" />
|
||||
</div>
|
||||
|
||||
2. 使用回归树来拟合$r_{im}$， 这里的$i$表示样本哈，回归树的建立过程可以参考下面的链接文章，简单的说就是遍历每个特征， 每个特征下遍历每个取值， 计算分裂后两组数据的平方损失， 找到最小的那个划分节点。 假如我们产生的第2棵决策树如下：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20200910101558282.png#pic_center" alt="在这里插入图片描述" style="zoom:80%;" />
|
||||
</div>
|
||||
|
||||
3. 对于每个叶子节点$j$, 计算最佳残差拟合值
|
||||
$$
|
||||
\gamma_{j m}=\arg \min _{\gamma} \sum_{x \in R_{i j}} L\left(y_{i}, F_{m-1}\left(x_{i}\right)+\gamma\right)
|
||||
$$
|
||||
意思是， 在刚构建的树$m$中， 找到每个节点$j$的输出$\gamma_{jm}$, 能使得该节点的loss最小。 那么我们看一下这个$\gamma$的求解方式， 这里非常的巧妙。 首先， 我们把损失函数写出来， 对于左边的第一个样本， 有
|
||||
$$
|
||||
L\left(y_{1}, F_{m-1}\left(x_{1}\right)+\gamma\right)=-y_{1}\left(F_{m-1}\left(x_{1}\right)+\gamma\right)+\log \left(1+e^{F_{m-1}\left(x_{1}\right)+\gamma}\right)
|
||||
$$
|
||||
这个式子就是上面推导的$l$， 因为我们要用回归树做分类， 所以这里把分类的预测概率转换成了对数几率回归的形式， 即$log(\eta_i)$， 这个就是模型的回归输出值。而如果求这个损失的最小值， 我们要求导， 解出令损失最小的$\gamma$。 但是上面这个式子求导会很麻烦， 所以这里介绍了一个技巧就是**使用二阶泰勒公式来近似表示该式， 再求导**， 还记得伟大的泰勒吗？
|
||||
$$
|
||||
f(x+\Delta x) \approx f(x)+\Delta x f^{\prime}(x)+\frac{1}{2} \Delta x^{2} f^{\prime \prime}(x)+O(\Delta x)
|
||||
$$
|
||||
这里就相当于把$L(y_1, F_{m-1}(x_1))$当做常量$f(x)$， $\gamma$作为变量$\Delta x$， 将$f(x)$二阶展开：
|
||||
$$
|
||||
L\left(y_{1}, F_{m-1}\left(x_{1}\right)+\gamma\right) \approx L\left(y_{1}, F_{m-1}\left(x_{1}\right)\right)+L^{\prime}\left(y_{1}, F_{m-1}\left(x_{1}\right)\right) \gamma+\frac{1}{2} L^{\prime \prime}\left(y_{1}, F_{m-1}\left(x_{1}\right)\right) \gamma^{2}
|
||||
$$
|
||||
这时候再求导就简单了
|
||||
$$
|
||||
\frac{d L}{d \gamma}=L^{\prime}\left(y_{1}, F_{m-1}\left(x_{1}\right)\right)+L^{\prime \prime}\left(y_{1}, F_{m-1}\left(x_{1}\right)\right) \gamma
|
||||
$$
|
||||
Loss最小的时候， 上面的式子等于0， 就可以得到$\gamma$:
|
||||
$$
|
||||
\gamma_{11}=\frac{-L^{\prime}\left(y_{1}, F_{m-1}\left(x_{1}\right)\right)}{L^{\prime \prime}\left(y_{1}, F_{m-1}\left(x_{1}\right)\right)}
|
||||
$$
|
||||
**因为分子就是残差(上述已经求到了)， 分母可以通过对残差求导，得到原损失函数的二阶导：**
|
||||
$$
|
||||
\begin{aligned}
|
||||
L^{\prime \prime}\left(y_{1}, F(x)\right) &=\frac{d L^{\prime}}{d \log (\eta_1)} \\
|
||||
&=\frac{d}{d \log (\eta_1)}\left[-y_{i}+\frac{e^{\log (\eta_1)}}{1+e^{\log (\eta_1)}}\right] \\
|
||||
&=\frac{d}{d \log (\eta_1)}\left[e^{\log (\eta_1)}\left(1+e^{\log (\eta_1)}\right)^{-1}\right] \\
|
||||
&=e^{\log (\eta_1)}\left(1+e^{\log (\eta_1)}\right)^{-1}-e^{2 \log (\eta_1)}\left(1+e^{\log (\eta_1)}\right)^{-2} \\
|
||||
&=\frac{e^{\log (\eta_1)}}{\left(1+e^{\log (\eta_1)}\right)^{2}} \\
|
||||
&=\frac{\eta_1}{(1+\eta_1)}\frac{1}{(1+\eta_1)} \\
|
||||
&=p_1(1-p_1)
|
||||
\end{aligned}
|
||||
$$
|
||||
这时候， 就可以算出该节点的输出：
|
||||
$$
|
||||
\gamma_{11}=\frac{r_{11}}{p_{10}\left(1-p_{10}\right)}=\frac{0.33}{0.67 \times 0.33}=1.49
|
||||
$$
|
||||
这里的下面$\gamma_{jm}$表示第$m$棵树的第$j$个叶子节点。 接下来是右边节点的输出， 包含样本2和样本3， 同样使用二阶泰勒公式展开：
|
||||
$$
|
||||
\begin{array}{l}
|
||||
L\left(y_{2}, F_{m-1}\left(x_{2}\right)+\gamma\right)+L\left(y_{3}, F_{m-1}\left(x_{3}\right)+\gamma\right) \\
|
||||
\approx L\left(y_{2}, F_{m-1}\left(x_{2}\right)\right)+L^{\prime}\left(y_{2}, F_{m-1}\left(x_{2}\right)\right) \gamma+\frac{1}{2} L^{\prime \prime}\left(y_{2}, F_{m-1}\left(x_{2}\right)\right) \gamma^{2} \\
|
||||
+L\left(y_{3}, F_{m-1}\left(x_{3}\right)\right)+L^{\prime}\left(y_{3}, F_{m-1}\left(x_{3}\right)\right) \gamma+\frac{1}{2} L^{\prime \prime}\left(y_{3}, F_{m-1}\left(x_{3}\right)\right) \gamma^{2}
|
||||
\end{array}
|
||||
$$
|
||||
求导， 令其结果为0，就会得到， 第1棵树的第2个叶子节点的输出：
|
||||
$$
|
||||
\begin{aligned}
|
||||
\gamma_{21} &=\frac{-L^{\prime}\left(y_{2}, F_{m-1}\left(x_{2}\right)\right)-L^{\prime}\left(y_{3}, F_{m-1}\left(x_{3}\right)\right)}{L^{\prime \prime}\left(y_{2}, F_{m-1}\left(x_{2}\right)\right)+L^{\prime \prime}\left(y_{3}, F_{m-1}\left(x_{3}\right)\right)} \\
|
||||
&=\frac{r_{21}+r_{31}}{p_{20}\left(1-p_{20}\right)+p_{30}\left(1-p_{30}\right)} \\
|
||||
&=\frac{0.33-0.67}{0.67 \times 0.33+0.67 \times 0.33} \\
|
||||
&=-0.77
|
||||
\end{aligned}
|
||||
$$
|
||||
可以看出， 对于任意叶子节点， 我们可以直接计算其输出值：
|
||||
$$
|
||||
\gamma_{j m}=\frac{\sum_{i=1}^{R_{i j}} r_{i m}}{\sum_{i=1}^{R_{i j}} p_{i, m-1}\left(1-p_{i, m-1}\right)}
|
||||
$$
|
||||
|
||||
4. 更新模型$F_m(x)$
|
||||
$$
|
||||
F_{m}(x)=F_{m-1}(x)+\nu \sum_{j=1}^{J_{m}} \gamma_{m}
|
||||
$$
|
||||
|
||||
这样， 通过多次循环迭代， 就可以得到一个比较强的学习器$F_m(x)$
|
||||
|
||||
<br>
|
||||
|
||||
**下面分析一下GBDT的优缺点：**
|
||||
|
||||
我们可以把树的生成过程理解成**自动进行多维度的特征组合**的过程，从根结点到叶子节点上的整个路径(多个特征值判断)，才能最终决定一棵树的预测值， 另外，对于**连续型特征**的处理，GBDT 可以拆分出一个临界阈值，比如大于 0.027 走左子树，小于等于 0.027（或者 default 值）走右子树，这样很好的规避了人工离散化的问题。这样就非常轻松的解决了逻辑回归那里**自动发现特征并进行有效组合**的问题， 这也是GBDT的优势所在。
|
||||
|
||||
但是GBDT也会有一些局限性， 对于**海量的 id 类特征**，GBDT 由于树的深度和棵树限制（防止过拟合），不能有效的存储；另外海量特征在也会存在性能瓶颈，当 GBDT 的 one hot 特征大于 10 万维时，就必须做分布式的训练才能保证不爆内存。所以 GBDT 通常配合少量的反馈 CTR 特征来表达，这样虽然具有一定的范化能力，但是同时会有**信息损失**，对于头部资源不能有效的表达。
|
||||
|
||||
所以， 我们发现其实**GBDT和LR的优缺点可以进行互补**。
|
||||
|
||||
### GBDT+LR模型
|
||||
2014年， Facebook提出了一种利用GBDT自动进行特征筛选和组合， 进而生成新的离散特征向量， 再把该特征向量当做LR模型的输入， 来产生最后的预测结果， 这就是著名的GBDT+LR模型了。GBDT+LR 使用最广泛的场景是CTR点击率预估，即预测当给用户推送的广告会不会被用户点击。
|
||||
|
||||
有了上面的铺垫， 这个模型解释起来就比较容易了， 模型的总体结构长下面这样：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20200910161923481.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="在这里插入图片描述" style="zoom:67%;" />
|
||||
</div>
|
||||
**训练时**，GBDT 建树的过程相当于自动进行的特征组合和离散化，然后从根结点到叶子节点的这条路径就可以看成是不同特征进行的特征组合，用叶子节点可以唯一的表示这条路径，并作为一个离散特征传入 LR 进行**二次训练**。
|
||||
|
||||
比如上图中， 有两棵树，x为一条输入样本，遍历两棵树后，x样本分别落到两颗树的叶子节点上，每个叶子节点对应LR一维特征，那么通过遍历树，就得到了该样本对应的所有LR特征。构造的新特征向量是取值0/1的。 比如左树有三个叶子节点，右树有两个叶子节点，最终的特征即为五维的向量。对于输入x，假设他落在左树第二个节点，编码[0,1,0]，落在右树第二个节点则编码[0,1]，所以整体的编码为[0,1,0,0,1]，这类编码作为特征，输入到线性分类模型（LR or FM）中进行分类。
|
||||
|
||||
**预测时**，会先走 GBDT 的每棵树，得到某个叶子节点对应的一个离散特征(即一组特征组合)，然后把该特征以 one-hot 形式传入 LR 进行线性加权预测。
|
||||
|
||||
这个方案应该比较简单了， 下面有几个关键的点我们需要了解：
|
||||
1. **通过GBDT进行特征组合之后得到的离散向量是和训练数据的原特征一块作为逻辑回归的输入， 而不仅仅全是这种离散特征**
|
||||
2. 建树的时候用ensemble建树的原因就是一棵树的表达能力很弱，不足以表达多个有区分性的特征组合，多棵树的表达能力更强一些。GBDT每棵树都在学习前面棵树尚存的不足，迭代多少次就会生成多少棵树。
|
||||
3. RF也是多棵树，但从效果上有实践证明不如GBDT。且GBDT前面的树，特征分裂主要体现对多数样本有区分度的特征；后面的树，主要体现的是经过前N颗树，残差仍然较大的少数样本。优先选用在整体上有区分度的特征，再选用针对少数样本有区分度的特征，思路更加合理，这应该也是用GBDT的原因。
|
||||
4. 在CRT预估中， GBDT一般会建立两类树(非ID特征建一类， ID类特征建一类)， AD，ID类特征在CTR预估中是非常重要的特征，直接将AD，ID作为feature进行建树不可行，故考虑为每个AD，ID建GBDT树。
|
||||
1. 非ID类树：不以细粒度的ID建树，此类树作为base，即便曝光少的广告、广告主，仍可以通过此类树得到有区分性的特征、特征组合
|
||||
2. ID类树：以细粒度 的ID建一类树，用于发现曝光充分的ID对应有区分性的特征、特征组合
|
||||
|
||||
### 编程实践
|
||||
|
||||
下面我们通过kaggle上的一个ctr预测的比赛来看一下GBDT+LR模型部分的编程实践， [数据来源](https://github.com/zhongqiangwu960812/AI-RecommenderSystem/tree/master/Rank/GBDT%2BLR/data)
|
||||
|
||||
我们回顾一下上面的模型架构， 首先是要训练GBDT模型， GBDT的实现一般可以使用xgboost， 或者lightgbm。训练完了GBDT模型之后， 我们需要预测出每个样本落在了哪棵树上的哪个节点上， 然后通过one-hot就会得到一些新的离散特征， 这和原来的特征进行合并组成新的数据集， 然后作为逻辑回归的输入，最后通过逻辑回归模型得到结果。
|
||||
|
||||
根据上面的步骤， 我们看看代码如何实现：
|
||||
|
||||
假设我们已经有了处理好的数据x_train, y_train。
|
||||
|
||||
1. **训练GBDT模型**
|
||||
|
||||
GBDT模型的搭建我们可以通过XGBOOST， lightgbm等进行构建。比如：
|
||||
|
||||
```python
|
||||
gbm = lgb.LGBMRegressor(objective='binary',
|
||||
subsample= 0.8,
|
||||
min_child_weight= 0.5,
|
||||
colsample_bytree= 0.7,
|
||||
num_leaves=100,
|
||||
max_depth = 12,
|
||||
learning_rate=0.05,
|
||||
n_estimators=10,
|
||||
)
|
||||
|
||||
gbm.fit(x_train, y_train,
|
||||
eval_set = [(x_train, y_train), (x_val, y_val)],
|
||||
eval_names = ['train', 'val'],
|
||||
eval_metric = 'binary_logloss',
|
||||
# early_stopping_rounds = 100,
|
||||
)
|
||||
```
|
||||
|
||||
2. **特征转换并构建新的数据集**
|
||||
|
||||
通过上面我们建立好了一个gbdt模型， 我们接下来要用它来预测出样本会落在每棵树的哪个叶子节点上， 为后面的离散特征构建做准备， 由于不是用gbdt预测结果而是预测训练数据在每棵树上的具体位置， 就需要用到下面的语句：
|
||||
|
||||
```python
|
||||
model = gbm.booster_ # 获取到建立的树
|
||||
|
||||
# 每个样本落在每个树的位置 ， 下面两个是矩阵 (样本个数, 树的棵树) ， 每一个数字代表某个样本落在了某个数的哪个叶子节点
|
||||
gbdt_feats_train = model.predict(train, pred_leaf = True)
|
||||
gbdt_feats_test = model.predict(test, pred_leaf = True)
|
||||
|
||||
# 把上面的矩阵转成新的样本-特征的形式， 与原有的数据集合并
|
||||
gbdt_feats_name = ['gbdt_leaf_' + str(i) for i in range(gbdt_feats_train.shape[1])]
|
||||
df_train_gbdt_feats = pd.DataFrame(gbdt_feats_train, columns = gbdt_feats_name)
|
||||
df_test_gbdt_feats = pd.DataFrame(gbdt_feats_test, columns = gbdt_feats_name)
|
||||
|
||||
# 构造新数据集
|
||||
train = pd.concat([train, df_train_gbdt_feats], axis = 1)
|
||||
test = pd.concat([test, df_test_gbdt_feats], axis = 1)
|
||||
train_len = train.shape[0]
|
||||
data = pd.concat([train, test])
|
||||
```
|
||||
|
||||
3. **离散特征的独热编码，并划分数据集**
|
||||
|
||||
```python
|
||||
# 新数据的新特征进行读入编码
|
||||
for col in gbdt_feats_name:
|
||||
onehot_feats = pd.get_dummies(data[col], prefix = col)
|
||||
data.drop([col], axis = 1, inplace = True)
|
||||
data = pd.concat([data, onehot_feats], axis = 1)
|
||||
|
||||
# 划分数据集
|
||||
train = data[: train_len]
|
||||
test = data[train_len:]
|
||||
|
||||
x_train, x_val, y_train, y_val = train_test_split(train, target, test_size = 0.3, random_state = 2018)
|
||||
```
|
||||
|
||||
4. **训练逻辑回归模型作最后的预测**
|
||||
|
||||
```python
|
||||
# 训练逻辑回归模型
|
||||
lr = LogisticRegression()
|
||||
lr.fit(x_train, y_train)
|
||||
tr_logloss = log_loss(y_train, lr.predict_proba(x_train)[:, 1])
|
||||
print('tr-logloss: ', tr_logloss)
|
||||
val_logloss = log_loss(y_val, lr.predict_proba(x_val)[:, 1])
|
||||
print('val-logloss: ', val_logloss)
|
||||
|
||||
# 预测
|
||||
y_pred = lr.predict_proba(test)[:, 1]
|
||||
```
|
||||
|
||||
上面我们就完成了GBDT+LR模型的基本训练步骤， 具体详细的代码可以参考链接。
|
||||
|
||||
### 思考
|
||||
1. **为什么使用集成的决策树？ 为什么使用GBDT构建决策树而不是随机森林？**
|
||||
2. **面对高维稀疏类特征的时候(比如ID类特征)， 逻辑回归一般要比GBDT这种非线性模型好， 为什么？**
|
||||
|
||||
|
||||
**参考资料**
|
||||
|
||||
* 王喆 - 《深度学习推荐系统》
|
||||
* [决策树之 GBDT 算法 - 分类部分](https://www.jianshu.com/p/f5e5db6b29f2)
|
||||
* [深入理解GBDT二分类算法](https://zhuanlan.zhihu.com/p/89549390?utm_source=zhihu)
|
||||
* [逻辑回归、优化算法和正则化的幕后细节补充](https://blog.csdn.net/wuzhongqiang/article/details/108456051)
|
||||
* [梯度提升树GBDT的理论学习与细节补充](https://blog.csdn.net/wuzhongqiang/article/details/108471107)
|
||||
* [推荐系统遇上深度学习(十)--GBDT+LR融合方案实战](https://zhuanlan.zhihu.com/p/37522339)
|
||||
* [CTR预估中GBDT与LR融合方案](https://blog.csdn.net/lilyth_lilyth/article/details/48032119)
|
||||
* [GBDT+LR算法解析及Python实现](https://www.cnblogs.com/wkang/p/9657032.html)
|
||||
* [常见计算广告点击率预估算法总结](https://zhuanlan.zhihu.com/p/29053940)
|
||||
* [GBDT--分类篇](https://blog.csdn.net/On_theway10/article/details/83576715?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-5.channel_param&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-5.channel_param)
|
||||
|
||||
**论文**
|
||||
|
||||
* [http://quinonero.net/Publications/predicting-clicks-facebook.pdf 原论文](http://quinonero.net/Publications/predicting-clicks-facebook.pdf)
|
||||
* [Predicting Clicks: Estimating the Click-Through Rate for New Ads](https://www.microsoft.com/en-us/research/publication/predicting-clicks-estimating-the-click-through-rate-for-new-ads/)\
|
||||
* [Greedy Fun tion Approximation : A Gradient Boosting](https://www.semanticscholar.org/paper/Greedy-Fun-tion-Approximation-%3A-A-Gradient-Boosting-Friedman/0d97ee4888506beb30a3f3b6552d88a9b0ca11f0?p2df)
|
||||
|
||||
277
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.2/AutoInt.md
Normal file
277
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.2/AutoInt.md
Normal file
@@ -0,0 +1,277 @@
|
||||
## 写在前面
|
||||
AutoInt(Automatic Feature Interaction)，这是2019年发表在CIKM上的文章，这里面提出的模型，重点也是在特征交互上，而所用到的结构，就是大名鼎鼎的transformer结构了，也就是通过多头的自注意力机制来显示的构造高阶特征，有效的提升了模型的效果。所以这个模型的提出动机比较简单，和xdeepFM这种其实是一样的，就是针对目前很多浅层模型无法学习高阶的交互， 而DNN模型能学习高阶交互，但确是隐性学习，缺乏可解释性，并不知道好不好使。而transformer的话，我们知道， 有着天然的全局意识，在NLP里面的话，各个词通过多头的自注意力机制，就能够使得各个词从不同的子空间中学习到与其它各个词的相关性，汇聚其它各个词的信息。 而放到推荐系统领域，同样也是这个道理，无非是把词换成了这里的离散特征而已， 而如果通过多个这样的交叉块堆积，就能学习到任意高阶的交互啦。这其实就是本篇文章的思想核心。
|
||||
|
||||
## AutoInt模型的理论及论文细节
|
||||
### 动机和原理
|
||||
这篇文章的前言部分依然是说目前模型的不足，以引出模型的动机所在， 简单的来讲，就是两句话：
|
||||
1. 浅层的模型会受到交叉阶数的限制，没法完成高阶交叉
|
||||
2. 深层模型的DNN在学习高阶隐性交叉的效果并不是很好， 且不具有可解释性
|
||||
|
||||
于是乎：
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/60f5f213f34d4e2b9bdb800e6f029b34.png#pic_center" alt="image-20210308142624189" style="zoom: 80%;" />
|
||||
</div>
|
||||
|
||||
那么是如何做到的呢？ 引入了transformer， 做成了一个特征交互层， 原理如下：
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/d05a80906b484ab7a026e52ed2d8f9d4.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBATWlyYWNsZTgwNzA=,size_1,color_FFFFFF,t_70,g_se,x_16#pic_center" alt="image-20210308142624189" style="zoom: 80%;" />
|
||||
</div>
|
||||
|
||||
### AutoInt模型的前向过程梳理
|
||||
下面看下AutoInt模型的结构了，并不是很复杂
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/1aeabdd3cee74cbf814d7eed3147be4e.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBATWlyYWNsZTgwNzA=,size_1,color_FFFFFF,t_70,g_se,x_1#pic_center" alt="image-20210308142624189" style="zoom: 85%;" />
|
||||
</div>
|
||||
|
||||
#### Input Layer
|
||||
输入层这里， 用到的特征主要是离散型特征和连续性特征， 这里不管是哪一类特征，都会过embedding层转成低维稠密的向量，是的， **连续性特征，这里并没有经过分桶离散化，而是直接走embedding**。这个是怎么做到的呢？就是就是类似于预训练时候的思路，先通过item_id把连续型特征与类别特征关联起来，最简单的，就是把item_id拿过来，过完embedding层取出对应的embedding之后，再乘上连续值即可， 所以这个连续值事先一定要是归一化的。 当然，这个玩法，我也是第一次见。 学习到了， 所以模型整体的输入如下：
|
||||
|
||||
$$
|
||||
\mathbf{x}=\left[\mathbf{x}_{1} ; \mathbf{x}_{2} ; \ldots ; \mathbf{x}_{\mathbf{M}}\right]
|
||||
$$
|
||||
这里的$M$表示特征的个数, $X_1, X_2$这是离散型特征， one-hot的形式， 而$X_M$在这里是连续性特征。过embedding层的细节应该是我上面说的那样。
|
||||
#### Embedding Layer
|
||||
embedding层的作用是把高维稀疏的特征转成低维稠密， 离散型的特征一般是取出对应的embedding向量即可， 具体计算是这样：
|
||||
$$
|
||||
\mathbf{e}_{\mathbf{i}}=\mathbf{V}_{\mathbf{i}} \mathbf{x}_{\mathbf{i}}
|
||||
$$
|
||||
对于第$i$个离散特征，直接第$i$个嵌入矩阵$V_i$乘one-hot向量就取出了对应位置的embedding。 当然，如果输入的时候不是个one-hot， 而是个multi-hot的形式，那么对应的embedding输出是各个embedding求平均得到的。
|
||||
|
||||
$$
|
||||
\mathbf{e}_{\mathbf{i}}=\frac{1}{q} \mathbf{V}_{\mathbf{i}} \mathbf{x}_{\mathbf{i}}
|
||||
$$
|
||||
比如， 推荐里面用户的历史行为item。过去点击了多个item，最终的输出就是这多个item的embedding求平均。
|
||||
而对于连续特征， 我上面说的那样， 也是过一个embedding矩阵取相应的embedding， 不过，最后要乘一个连续值
|
||||
$$
|
||||
\mathbf{e}_{\mathbf{m}}=\mathbf{v}_{\mathbf{m}} x_{m}
|
||||
$$
|
||||
这样，不管是连续特征，离散特征还是变长的离散特征，经过embedding之后，都能得到等长的embedding向量。 我们把这个向量拼接到一块，就得到了交互层的输入。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/089b846a7f5c4125bc99a5a60e03d1ff.png#pic_center" alt="image-20210308142624189" style="zoom: 60%;" />
|
||||
</div>
|
||||
|
||||
#### Interacting Layer
|
||||
这个是本篇论文的核心了，其实这里说的就是transformer块的前向传播过程，所以这里我就直接用比较白话的语言简述过程了，不按照论文中的顺序展开了。
|
||||
|
||||
通过embedding层， 我们会得到M个向量$e_1, ...e_M$，假设向量的维度是$d$维， 那么这个就是一个$d\times M$的矩阵， 我们定一个符号$X$。 接下来我们基于这个矩阵$X$，做三次变换，也就是分别乘以三个矩阵$W_k^{(h)}, W_q^{(h)},W_v^{(h)}$， 这三个矩阵的维度是$d'\times d$的话， 那么我们就会得到三个结果：
|
||||
$$Q^{(h)}=W_q^{(h)}\times X \\ K^{(h)} = W_k^{(h)} \times X \\ V^{(h)} = W_v^{(h)} \times X$$
|
||||
这三个矩阵都是$d'\times M$的。这其实就完成了一个Head的操作。所谓的自注意力， 就是$X$通过三次变换得到的结果之间，通过交互得到相关性，并通过相关性进行加权汇总，全是$X$自发的。 那么是怎么做到的呢？首先， 先进行这样的操作：
|
||||
$$Score(Q^h,K^h)=Q^h \times {K^h}^T$$
|
||||
这个结果得到的是一个$d'\times d'$的矩阵， 那么这个操作到底是做了一个什么事情呢？
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20200220195022623.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="image-20210308142624189" style="zoom: 90%;" />
|
||||
</div>
|
||||
|
||||
假设这里的$c_1..c_6$是我们的6个特征， 而每一行代表每个特征的embedding向量，这样两个矩阵相乘，相当于得到了当前特征与其它特征两两之间的內积值， 而內积可以表示两个向量之间的相似程度。所以得到的结果每一行，就代表当前这个特征与其它特征的相似性程度。
|
||||
|
||||
接下来，我们对$Score(Q^h,K^h)$， 在最后一个维度上进行softmax，就根据相似性得到了权重信息，这其实就是把相似性分数归一化到了0-1之间
|
||||
|
||||
$$Attention(Q^h,K^h)=Softmax(Score(Q^h,K^h))$$
|
||||
接下来， 我们再进行这样的一步操作
|
||||
$$E^{(h)}=Attention(Q^h,K^h) \times V$$
|
||||
这样就得到了$d'\times M$的矩阵$E$， 这步操作，其实就是一个加权汇总的过程， 对于每个特征， 先求与其它特征的相似度，然后得到一个权重，再回乘到各自的特征向量再求和。 只不过这里的特征是经过了一次线性变化的过程，降维到了$d'$。
|
||||
|
||||
上面是我从矩阵的角度又过了一遍， 这个是直接针对所有的特征向量一部到位。 论文里面的从单个特征的角度去描述的，只说了一个矩阵向量过多头注意力的操作。
|
||||
$$
|
||||
\begin{array}{c}
|
||||
\alpha_{\mathbf{m}, \mathbf{k}}^{(\mathbf{h})}=\frac{\exp \left(\psi^{(h)}\left(\mathbf{e}_{\mathbf{m}}, \mathbf{e}_{\mathbf{k}}\right)\right)}{\sum_{l=1}^{M} \exp \left(\psi^{(h)}\left(\mathbf{e}_{\mathbf{m}}, \mathbf{e}_{1}\right)\right)} \\
|
||||
\psi^{(h)}\left(\mathbf{e}_{\mathbf{m}}, \mathbf{e}_{\mathbf{k}}\right)=\left\langle\mathbf{W}_{\text {Query }}^{(\mathbf{h})} \mathbf{e}_{\mathbf{m}}, \mathbf{W}_{\text {Key }}^{(\mathbf{h})} \mathbf{e}_{\mathbf{k}}\right\rangle
|
||||
\end{array} \\
|
||||
\widetilde{\mathbf{e}}_{\mathrm{m}}^{(\mathbf{h})}=\sum_{k=1}^{M} \alpha_{\mathbf{m}, \mathbf{k}}^{(\mathbf{h})}\left(\mathbf{W}_{\text {Value }}^{(\mathbf{h})} \mathbf{e}_{\mathbf{k}}\right)
|
||||
$$
|
||||
|
||||
这里会更好懂一些， 就是相当于上面矩阵的每一行操作拆开了， 首先，整个拼接起来的embedding矩阵还是过三个参数矩阵得到$Q,K,V$， 然后是每一行单独操作的方式，对于某个特征向量$e_k$，与其它的特征两两內积得到权重，然后在softmax，回乘到对应向量，然后进行求和就得到了融合其它特征信息的新向量。 具体过程如图：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/700bf353ce2f4c229839761e7815515d.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBATWlyYWNsZTgwNzA=,size_1,color_FFFFFF,t_70,g_se,x_16#pic_center" alt="image-20210308142624189" style="zoom: 80%;" />
|
||||
</div>
|
||||
|
||||
上面的过程是用了一个头，理解的话就类似于从一个角度去看特征之间的相关关系，用论文里面的话讲，这是从一个子空间去看， 如果是想从多个角度看，这里可以用多个头，即换不同的矩阵$W_q,W_k,W_v$得到不同的$Q,K,V$然后得到不同的$e_m$， 每个$e_m$是$d'\times 1$的。
|
||||
|
||||
然后，多个头的结果concat起来
|
||||
$$
|
||||
\widetilde{\mathbf{e}}_{\mathrm{m}}=\widetilde{\mathbf{e}}_{\mathrm{m}}^{(1)} \oplus \widetilde{\mathbf{e}}_{\mathrm{m}}^{(2)} \oplus \cdots \oplus \widetilde{\mathbf{e}}_{\mathbf{m}}^{(\mathbf{H})}
|
||||
$$
|
||||
这是一个$d'\times H$的向量， 假设有$H$个头。
|
||||
|
||||
接下来， 过一个残差网络层，这是为了保留原始的特征信息
|
||||
$$
|
||||
\mathbf{e}_{\mathbf{m}}^{\mathrm{Res}}=\operatorname{ReL} U\left(\widetilde{\mathbf{e}}_{\mathbf{m}}+\mathbf{W}_{\text {Res }} \mathbf{e}_{\mathbf{m}}\right)
|
||||
$$
|
||||
这里的$e_m$是$d\times 1$的向量， $W_{Res}$是$d'H\times d$的矩阵， 最后得到的$e_m^{Res}$是$d'H\times 1$的向量， 这是其中的一个特征，如果是$M$个特征堆叠的话，最终就是$d'HM\times 1$的矩阵， 这个就是Interacting Layer的结果输出。
|
||||
#### Output Layer
|
||||
输出层就非常简单了，加一层全连接映射出输出值即可：
|
||||
$$
|
||||
\hat{y}=\sigma\left(\mathbf{w}^{\mathrm{T}}\left(\mathbf{e}_{1}^{\mathbf{R e s}} \oplus \mathbf{e}_{2}^{\mathbf{R e s}} \oplus \cdots \oplus \mathbf{e}_{\mathbf{M}}^{\text {Res }}\right)+b\right)
|
||||
$$
|
||||
这里的$W$是$d'HM\times 1$的， 这样最终得到的是一个概率值了， 接下来交叉熵损失更新模型参数即可。
|
||||
|
||||
AutoInt的前向传播过程梳理完毕。
|
||||
|
||||
### AutoInt的分析
|
||||
这里论文里面分析了为啥AutoInt能建模任意的高阶交互以及时间复杂度和空间复杂度的分析。我们一一来看。
|
||||
|
||||
关于建模任意的高阶交互， 我们这里拿一个transformer块看下， 对于一个transformer块， 我们发现特征之间完成了一个2阶的交互过程，得到的输出里面我们还保留着1阶的原始特征。
|
||||
|
||||
那么再经过一个transformer块呢？ 这里面就会有2阶和1阶的交互了， 也就是会得到3阶的交互信息。而此时的输出，会保留着第一个transformer的输出信息特征。再过一个transformer块的话，就会用4阶的信息交互信息， 其实就相当于， 第$n$个transformer里面会建模出$n+1$阶交互来， 这个与CrossNet其实有异曲同工之妙的，无法是中间交互时的方式不一样。 前者是bit-wise级别的交互，而后者是vector-wise的交互。
|
||||
|
||||
所以， AutoInt是可以建模任意高阶特征的交互的，并且这种交互还是显性。
|
||||
|
||||
关于时间复杂度和空间复杂度，空间复杂度是$O(Ldd'H)$级别的， 这个也很好理解，看参数量即可， 3个W矩阵， H个head，再假设L个transformer块的话，参数量就达到这了。 时间复杂度的话是$O(MHd'(M+d))$的，论文说如果d和d'很小的话，其实这个模型不算复杂。
|
||||
### 3.4 更多细节
|
||||
这里整理下实验部分的细节，主要是对于一些超参的实验设置，在实验里面，作者首先指出了logloss下降多少算是有效呢？
|
||||
>It is noticeable that a slightly higher AUC or lower Logloss at 0.001-level is regarded significant for CTR prediction task, which has also been pointed out in existing works
|
||||
|
||||
这个和在fibinet中auc说的意思差不多。
|
||||
|
||||
在这一块，作者还写到了几个观点：
|
||||
1. NFM use the deep neural network as a core component to learning high-order feature interactions, they do not guarantee improvement over FM and AFM.
|
||||
2. AFM准确的说是二阶显性交互基础上加了交互重要性选择的操作， 这里应该是没有在上面加全连接
|
||||
3. xdeepFM这种CIN网络，在实际场景中非常难部署，不实用
|
||||
4. AutoInt的交互层2-3层差不多， embedding维度16-24
|
||||
5. 在AutoInt上面加2-3层的全连接会有点提升，但是提升效果并不是很大
|
||||
|
||||
所以感觉AutoInt这篇paper更大的价值，在于给了我们一种特征高阶显性交叉与特征选择性的思路，就是transformer在这里起的功效。所以后面用的时候， 更多的应该考虑如何用这种思路或者这个交互模块，而不是直接搬模型。
|
||||
|
||||
## AutoInt模型的简单复现及结构解释
|
||||
经过上面的分析， AutoInt模型的核心其实还是Transformer，所以代码部分呢？ 主要还是Transformer的实现过程， 这个之前在整理DSIN的时候也整理过，由于Transformer特别重要，所以这里再重新复习一遍， 依然是基于Deepctr，写成一个简版的形式。
|
||||
|
||||
```python
|
||||
def AutoInt(linear_feature_columns, dnn_feature_columns, att_layer_num=3, att_embedding_size=8, att_head_num=2, att_res=True):
|
||||
"""
|
||||
:param att_layer_num: transformer块的数量，一个transformer块里面是自注意力计算 + 残差计算
|
||||
:param att_embedding_size: 文章里面的d', 自注意力时候的att的维度
|
||||
:param att_head_num: 头的数量或者自注意力子空间的数量
|
||||
:param att_res: 是否使用残差网络
|
||||
"""
|
||||
# 构建输入层，即所有特征对应的Input()层，这里使用字典的形式返回，方便后续构建模型
|
||||
dense_input_dict, sparse_input_dict = build_input_layers(linear_feature_columns+dnn_feature_columns)
|
||||
|
||||
# 构建模型的输入层，模型的输入层不能是字典的形式，应该将字典的形式转换成列表的形式
|
||||
# 注意：这里实际的输入预Input层对应，是通过模型输入时候的字典数据的key与对应name的Input层
|
||||
input_layers = list(dense_input_dict.values()) + list(sparse_input_dict.values())
|
||||
|
||||
# 线性部分的计算逻辑 -- linear
|
||||
linear_logits = get_linear_logits(dense_input_dict, sparse_input_dict, linear_feature_columns)
|
||||
|
||||
# 构建维度为k的embedding层，这里使用字典的形式返回，方便后面搭建模型
|
||||
# 线性层和dnn层统一的embedding层
|
||||
embedding_layer_dict = build_embedding_layers(linear_feature_columns+dnn_feature_columns, sparse_input_dict, is_linear=False)
|
||||
|
||||
# 构造self-att的输入
|
||||
att_sparse_kd_embed = concat_embedding_list(dnn_feature_columns, sparse_input_dict, embedding_layer_dict, flatten=False)
|
||||
att_input = Concatenate(axis=1)(att_sparse_kd_embed) # (None, field_num, embed_num)
|
||||
|
||||
# 下面的循环，就是transformer的前向传播，多个transformer块的计算逻辑
|
||||
for _ in range(att_layer_num):
|
||||
att_input = InteractingLayer(att_embedding_size, att_head_num, att_res)(att_input)
|
||||
att_output = Flatten()(att_input)
|
||||
att_logits = Dense(1)(att_output)
|
||||
|
||||
# DNN侧的计算逻辑 -- Deep
|
||||
# 将dnn_feature_columns里面的连续特征筛选出来，并把相应的Input层拼接到一块
|
||||
dnn_dense_feature_columns = list(filter(lambda x: isinstance(x, DenseFeat), dnn_feature_columns)) if dnn_feature_columns else []
|
||||
dnn_dense_feature_columns = [fc.name for fc in dnn_dense_feature_columns]
|
||||
dnn_concat_dense_inputs = Concatenate(axis=1)([dense_input_dict[col] for col in dnn_dense_feature_columns])
|
||||
|
||||
# 将dnn_feature_columns里面的离散特征筛选出来，相应的embedding层拼接到一块
|
||||
dnn_sparse_kd_embed = concat_embedding_list(dnn_feature_columns, sparse_input_dict, embedding_layer_dict, flatten=True)
|
||||
dnn_concat_sparse_kd_embed = Concatenate(axis=1)(dnn_sparse_kd_embed)
|
||||
|
||||
# DNN层的输入和输出
|
||||
dnn_input = Concatenate(axis=1)([dnn_concat_dense_inputs, dnn_concat_sparse_kd_embed, att_output])
|
||||
dnn_out = get_dnn_output(dnn_input)
|
||||
dnn_logits = Dense(1)(dnn_out)
|
||||
|
||||
# 三边的结果stack
|
||||
stack_output = Add()([linear_logits, dnn_logits])
|
||||
|
||||
# 输出层
|
||||
output_layer = Dense(1, activation='sigmoid')(stack_output)
|
||||
|
||||
model = Model(input_layers, output_layer)
|
||||
|
||||
return model
|
||||
```
|
||||
这里由于大部分都是之前见过的模块，唯一改变的地方，就是加了一个`InteractingLayer`， 这个是一个transformer块，在这里面实现特征交互。而这个的结果输出，最终和DNN的输出结合到一起了。 而这个层，主要就是一个transformer块的前向传播过程。这应该算是最简单的一个版本了:
|
||||
|
||||
```python
|
||||
class InteractingLayer(Layer):
|
||||
"""A layer user in AutoInt that model the correction between different feature fields by multi-head self-att mechanism
|
||||
input: 3维张量, (none, field_num, embedding_size)
|
||||
output: 3维张量, (none, field_num, att_embedding_size * head_num)
|
||||
"""
|
||||
def __init__(self, att_embedding_size=8, head_num=2, use_res=True, seed=2021):
|
||||
super(InteractingLayer, self).__init__()
|
||||
self.att_embedding_size = att_embedding_size
|
||||
self.head_num = head_num
|
||||
self.use_res = use_res
|
||||
self.seed = seed
|
||||
|
||||
|
||||
def build(self, input_shape):
|
||||
embedding_size = int(input_shape[-1])
|
||||
|
||||
# 定义三个矩阵Wq, Wk, Wv
|
||||
self.W_query = self.add_weight(name="query", shape=[embedding_size, self.att_embedding_size * self.head_num],
|
||||
dtype=tf.float32, initializer=tf.keras.initializers.TruncatedNormal(seed=self.seed))
|
||||
self.W_key = self.add_weight(name="key", shape=[embedding_size, self.att_embedding_size * self.head_num],
|
||||
dtype=tf.float32, initializer=tf.keras.initializers.TruncatedNormal(seed=self.seed+1))
|
||||
self.W_value = self.add_weight(name="value", shape=[embedding_size, self.att_embedding_size * self.head_num],
|
||||
dtype=tf.float32, initializer=tf.keras.initializers.TruncatedNormal(seed=self.seed+2))
|
||||
|
||||
if self.use_res:
|
||||
self.W_res = self.add_weight(name="res", shape=[embedding_size, self.att_embedding_size * self.head_num],
|
||||
dtype=tf.float32, initializer=tf.keras.initializers.TruncatedNormal(seed=self.seed+3))
|
||||
|
||||
super(InteractingLayer, self).build(input_shape)
|
||||
|
||||
def call(self, inputs):
|
||||
# inputs (none, field_nums, embed_num)
|
||||
|
||||
querys = tf.tensordot(inputs, self.W_query, axes=(-1, 0)) # (None, field_nums, att_emb_size*head_num)
|
||||
keys = tf.tensordot(inputs, self.W_key, axes=(-1, 0))
|
||||
values = tf.tensordot(inputs, self.W_value, axes=(-1, 0))
|
||||
|
||||
# 多头注意力计算 按照头分开 (head_num, None, field_nums, att_embed_size)
|
||||
querys = tf.stack(tf.split(querys, self.head_num, axis=2))
|
||||
keys = tf.stack(tf.split(keys, self.head_num, axis=2))
|
||||
values = tf.stack(tf.split(values, self.head_num, axis=2))
|
||||
|
||||
# Q * K, key的后两维转置，然后再矩阵乘法
|
||||
inner_product = tf.matmul(querys, keys, transpose_b=True) # (head_num, None, field_nums, field_nums)
|
||||
normal_att_scores = tf.nn.softmax(inner_product, axis=-1)
|
||||
|
||||
result = tf.matmul(normal_att_scores, values) # (head_num, None, field_nums, att_embed_size)
|
||||
result = tf.concat(tf.split(result, self.head_num, ), axis=-1) # (1, None, field_nums, att_emb_size*head_num)
|
||||
result = tf.squeeze(result, axis=0) # (None, field_num, att_emb_size*head_num)
|
||||
|
||||
if self.use_res:
|
||||
result += tf.tensordot(inputs, self.W_res, axes=(-1, 0))
|
||||
|
||||
result = tf.nn.relu(result)
|
||||
|
||||
return result
|
||||
```
|
||||
这就是一个Transformer块做的事情，这里只说两个小细节:
|
||||
* 第一个是参数初始化那个地方， 后面的seed一定要指明出参数来，我第一次写的时候， 没有用seed=，结果导致训练有问题。
|
||||
* 第二个就是这里自注意力机制计算的时候，这里的多头计算处理方式， **把多个头分开，采用堆叠的方式进行计算(堆叠到第一个维度上去了)**。只有这样才能使得每个头与每个头之间的自注意力运算是独立不影响的。如果不这么做的话，最后得到的结果会含有当前单词在这个头和另一个单词在另一个头上的关联，这是不合理的。
|
||||
|
||||
OK， 这就是AutoInt比较核心的部分了，当然，上面自注意部分的输出结果与DNN或者Wide部分结合也不一定非得这么一种形式，也可以灵活多变，具体得结合着场景来。详细代码依然是看后面的GitHub啦。
|
||||
|
||||
## 总结
|
||||
这篇文章整理了AutoInt模型，这个模型的重点是引入了transformer来实现特征之间的高阶显性交互， 而transformer的魅力就是多头的注意力机制，相当于在多个子空间中， 根据不同的相关性策略去让特征交互然后融合，在这个交互过程中，特征之间计算相关性得到权重，并加权汇总，使得最终每个特征上都有了其它特征的信息，且其它特征的信息重要性还有了权重标识。 这个过程的自注意力计算以及汇总是一个自动的过程，这是很powerful的。
|
||||
|
||||
所以这篇文章的重要意义是又给我们传授了一个特征交互时候的新思路，就是transformer的多头注意力机制。
|
||||
|
||||
在整理transformer交互层的时候， 这里忽然想起了和一个同学的讨论， 顺便记在这里吧，就是：
|
||||
> 自注意力里面的Q,K能用一个吗？ 也就是类似于只用Q， 算注意力的时候，直接$QQ^T$， 得到的矩阵维度和原来的是一样的，并且在参数量上，由于去掉了$w_k$矩阵， 也会有所减少。
|
||||
|
||||
关于这个问题， 我目前没有尝试用同一个的效果，但总感觉是违背了当时设计自注意力的初衷，最直接的一个结论，就是这里如果直接$QQ^T$，那么得到的注意力矩阵是一个对称的矩阵， 这在汇总信息的时候可能会出现问题。 因为这基于了一个假设就是A特征对于B特征的重要性，和B特征对于A的重要性是一致的， 这个显然是不太符合常规的。 比如"学历"这个特征和"职业"这个特征， 对于计算机行业，高中生和研究生或许都可以做， 但是对于金融类的行业， 对学历就有着很高的要求。 这就说明对于职业这个特征， 学历特征对其影响很大。 而如果是看学历的话，研究生学历或许可以入计算机，也可以入金融， 可能职业特征对学历的影响就不是那么明显。 也就是学历对于职业的重要性可能会比职业对于学历的重要性要大。 所以我感觉直接用同一个矩阵，在表达能力上会受到限制。当然，是自己的看法哈， 这个问题也欢迎一块讨论呀！
|
||||
|
||||
|
||||
**参考资料**：
|
||||
* [AutoInt: Automatic Feature Interaction Learning via Self-Attentive Neural Networks](https://arxiv.org/abs/1810.11921)
|
||||
* [AutoInt：基于Multi-Head Self-Attention构造高阶特征](https://zhuanlan.zhihu.com/p/60185134)
|
||||
155
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.2/DCN.md
Normal file
155
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.2/DCN.md
Normal file
@@ -0,0 +1,155 @@
|
||||
# DCN
|
||||
## 动机
|
||||
Wide&Deep模型的提出不仅综合了“记忆能力”和“泛化能力”， 而且开启了不同网络结构融合的新思路。 所以后面就有各式各样的模型改进Wide部分或者Deep部分， 而Deep&Cross模型(DCN)就是其中比较典型的一个，这是2017年斯坦福大学和谷歌的研究人员在ADKDD会议上提出的， 该模型针对W&D的wide部分进行了改进， 因为Wide部分有一个不足就是需要人工进行特征的组合筛选， 过程繁琐且需要经验， 而2阶的FM模型在线性的时间复杂度中自动进行特征交互，但是这些特征交互的表现能力并不够，并且随着阶数的上升，模型复杂度会大幅度提高。于是乎，作者用一个Cross Network替换掉了Wide部分，来自动进行特征之间的交叉，并且网络的时间和空间复杂度都是线性的。 通过与Deep部分相结合，构成了深度交叉网络（Deep & Cross Network），简称DCN。
|
||||
|
||||
## 模型结构及原理
|
||||
|
||||
这个模型的结构是这个样子的：
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片dcn.png" style="zoom:67%;" />
|
||||
</div>
|
||||
|
||||
这个模型的结构也是比较简洁的， 从下到上依次为：Embedding和Stacking层， Cross网络层与Deep网络层并列， 以及最后的输出层。下面也是一一为大家剖析。
|
||||
|
||||
### Embedding和Stacking 层
|
||||
|
||||
Embedding层我们已经非常的熟悉了吧， 这里的作用依然是把稀疏离散的类别型特征变成低维密集型。
|
||||
$$
|
||||
\mathbf{x}_{\text {embed, } i}=W_{\text {embed, } i} \mathbf{x}_{i}
|
||||
$$
|
||||
其中对于某一类稀疏分类特征（如id），$X_{embed, i}$是第个$i$分类值（id序号）的embedding向量。$W_{embed,i}$是embedding矩阵， $n_e\times n_v$维度， $n_e$是embedding维度， $n_v$是该类特征的唯一取值个数。$x_i$属于该特征的二元稀疏向量(one-hot)编码的。 【实质上就是在训练得到的Embedding参数矩阵中找到属于当前样本对应的Embedding向量】。其实绝大多数基于深度学习的推荐模型都需要Embedding操作，参数学习是通过神经网络进行训练。
|
||||
|
||||
最后，该层需要将所有的密集型特征与通过embedding转换后的特征进行联合（Stacking）：
|
||||
$$
|
||||
\mathbf{x}_{0}=\left[\mathbf{x}_{\text {embed, } 1}^{T}, \ldots, \mathbf{x}_{\text {embed, }, k}^{T}, \mathbf{x}_{\text {dense }}^{T}\right]
|
||||
$$
|
||||
一共$k$个类别特征， dense是数值型特征， 两者在特征维度拼在一块。 上面的这两个操作如果是看了前面的模型的话，应该非常容易理解了。
|
||||
|
||||
### Cross Network
|
||||
|
||||
这个就是本模型最大的亮点了【Cross网络】， 这个思路感觉非常Nice。设计该网络的目的是增加特征之间的交互力度。交叉网络由多个交叉层组成， 假设第$l$层的输出向量$x_l$， 那么对于第$l+1$层的输出向量$x_{l+1}$表示为：
|
||||
|
||||
$$
|
||||
\mathbf{x}_{l+1}=\mathbf{x}_{0} \mathbf{x}_{l}^{T} \mathbf{w}_{l}+\mathbf{b}_{l}+\mathbf{x}_{l}=f\left(\mathbf{x}_{l}, \mathbf{w}_{l}, \mathbf{b}_{l}\right)+\mathbf{x}_{l}
|
||||
$$
|
||||
可以看到， 交叉层的二阶部分非常类似PNN提到的外积操作， 在此基础上增加了外积操作的权重向量$w_l$， 以及原输入向量$x_l$和偏置向量$b_l$。 交叉层的可视化如下：
|
||||
|
||||
<div align=center> <img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片cross.png" style="zoom:67%;" />
|
||||
</div>
|
||||
|
||||
可以看到， 每一层增加了一个$n$维的权重向量$w_l$（n表示输入向量维度）， 并且在每一层均保留了输入向量， 因此输入和输出之间的变化不会特别明显。关于这一层， 原论文里面有个具体的证明推导Cross Network为啥有效， 不过比较复杂，这里我拿一个式子简单的解释下上面这个公式的伟大之处：
|
||||
|
||||
> **我们根据上面这个公式， 尝试的写前面几层看看:**
|
||||
>
|
||||
> $l=0:\mathbf{x}_{1} =\mathbf{x}_{0} \mathbf{x}_{0}^{T} \mathbf{w}_{0}+ \mathbf{b}_{0}+\mathbf{x}_{0}$
|
||||
>
|
||||
> $l=1:\mathbf{x}_{2} =\mathbf{x}_{0} \mathbf{x}_{1}^{T} \mathbf{w}_{1}+ \mathbf{b}_{1}+\mathbf{x}_{1}=\mathbf{x}_{0} [\mathbf{x}_{0} \mathbf{x}_{0}^{T} \mathbf{w}_{0}+ \mathbf{b}_{0}+\mathbf{x}_{0}]^{T}\mathbf{w}_{1}+\mathbf{b}_{1}+\mathbf{x}_{1}$
|
||||
>
|
||||
> $l=2:\mathbf{x}_{3} =\mathbf{x}_{0} \mathbf{x}_{2}^{T} \mathbf{w}_{2}+ \mathbf{b}_{2}+\mathbf{x}_{2}=\mathbf{x}_{0} [\mathbf{x}_{0} [\mathbf{x}_{0} \mathbf{x}_{0}^{T} \mathbf{w}_{0}+ \mathbf{b}_{0}+\mathbf{x}_{0}]^{T}\mathbf{w}_{1}+\mathbf{b}_{1}+\mathbf{x}_{1}]^{T}\mathbf{w}_{2}+\mathbf{b}_{2}+\mathbf{x}_{2}$
|
||||
|
||||
我们暂且写到第3层的计算， 我们会发现什么结论呢？ 给大家总结一下：
|
||||
|
||||
1. $\mathrm{x}_1$中包含了所有的$\mathrm{x}_0$的1,2阶特征的交互， $\mathrm{x}_2$包含了所有的$\mathrm{x}_1, \mathrm{x}_0$的1、2、3阶特征的交互，$\mathrm{x}_3$中包含了所有的$\mathrm{x}_2$, $\mathrm{x}_1$与$\mathrm{x}_0$的交互，$\mathrm{x}_0$的1、2、3、4阶特征交互。 因此， 交叉网络层的叉乘阶数是有限的。 **第$l$层特征对应的最高的叉乘阶数$l+1$**
|
||||
|
||||
2. Cross网络的参数是共享的， 每一层的这个权重特征之间共享， 这个可以使得模型泛化到看不见的特征交互作用， 并且对噪声更具有鲁棒性。 例如两个稀疏的特征$x_i,x_j$， 它们在数据中几乎不发生交互， 那么学习$x_i,x_j$的权重对于预测没有任何的意义。
|
||||
|
||||
3. 计算交叉网络的参数数量。 假设交叉层的数量是$L_c$， 特征$x$的维度是$n$， 那么总共的参数是：
|
||||
|
||||
$$
|
||||
n\times L_c \times 2
|
||||
$$
|
||||
这个就是每一层会有$w$和$b$。且$w$维度和$x$的维度是一致的。
|
||||
|
||||
4. 交叉网络的时间和空间复杂度是线性的。这是因为， 每一层都只有$w$和$b$， 没有激活函数的存在，相对于深度学习网络， 交叉网络的复杂性可以忽略不计。
|
||||
|
||||
5. Cross网络是FM的泛化形式， 在FM模型中， 特征$x_i$的权重$v_i$， 那么交叉项$x_i,x_j$的权重为$<x_i,x_j>$。在DCN中， $x_i$的权重为${W_K^{(i)}}_{k=1}^l$, 交叉项$x_i,x_j$的权重是参数${W_K^{(i)}}_{k=1}^l$和${W_K^{(j)}}_{k=1}^l$的乘积，这个看上面那个例子展开感受下。因此两个模型都各自学习了独立于其他特征的一些参数，并且交叉项的权重是相应参数的某种组合。FM只局限于2阶的特征交叉(一般)，而DCN可以构建更高阶的特征交互， 阶数由网络深度决定，并且交叉网络的参数只依据输入的维度线性增长。
|
||||
|
||||
6. 还有一点我们也要了解，对于每一层的计算中， 都会跟着$\mathrm{x}_0$, 这个是咱们的原始输入， 之所以会乘以一个这个，是为了保证后面不管怎么交叉，都不能偏离我们的原始输入太远，别最后交叉交叉都跑偏了。
|
||||
|
||||
7. $\mathbf{x}_{l+1}=f\left(\mathbf{x}_{l}, \mathbf{w}_{l}, \mathbf{b}_{l}\right)+\mathbf{x}_{l}$, 这个东西其实有点跳远连接的意思，也就是和ResNet也有点相似，无形之中还能有效的缓解梯度消失现象。
|
||||
|
||||
好了， 关于本模型的交叉网络的细节就介绍到这里了。这应该也是本模型的精华之处了，后面就简单了。
|
||||
|
||||
### Deep Network
|
||||
|
||||
这个就和上面的D&W的全连接层原理一样。这里不再过多的赘述。
|
||||
$$
|
||||
\mathbf{h}_{l+1}=f\left(W_{l} \mathbf{h}_{l}+\mathbf{b}_{l}\right)
|
||||
$$
|
||||
具体的可以参考W&D模型。
|
||||
|
||||
### 组合输出层
|
||||
|
||||
这个层负责将两个网络的输出进行拼接， 并且通过简单的Logistics回归完成最后的预测：
|
||||
$$
|
||||
p=\sigma\left(\left[\mathbf{x}_{L_{1}}^{T}, \mathbf{h}_{L_{2}}^{T}\right] \mathbf{w}_{\text {logits }}\right)
|
||||
$$
|
||||
其中$\mathbf{x}_{L_{1}}^{T}$和$\mathbf{h}_{L_{2}}^{T}$分别表示交叉网络和深度网络的输出。
|
||||
最后二分类的损失函数依然是交叉熵损失：
|
||||
$$
|
||||
\text { loss }=-\frac{1}{N} \sum_{i=1}^{N} y_{i} \log \left(p_{i}\right)+\left(1-y_{i}\right) \log \left(1-p_{i}\right)+\lambda \sum_{l}\left\|\mathbf{w}_{i}\right\|^{2}
|
||||
$$
|
||||
|
||||
Cross&Deep模型的原理就是这些了，其核心部分就是Cross Network， 这个可以进行特征的自动交叉， 避免了更多基于业务理解的人工特征组合。 该模型相比于W&D，Cross部分表达能力更强， 使得模型具备了更强的非线性学习能力。
|
||||
|
||||
## 代码实现
|
||||
|
||||
下面我们看下DCN的代码复现，这里主要是给大家说一下这个模型的设计逻辑，参考了deepctr的函数API的编程风格， 具体的代码以及示例大家可以去参考后面的GitHub，里面已经给出了详细的注释， 这里主要分析模型的逻辑这块。关于函数API的编程式风格，我们还给出了一份文档， 大家可以先看这个，再看后面的代码部分，会更加舒服些。
|
||||
|
||||
从上面的结构图我们也可以看出， DCN的模型搭建，其实主要分为几大模块， 首先就是建立输入层，用到的函数式`build_input_layers`，有了输入层之后， 我们接下来是embedding层的搭建，用到的函数是`build_embedding_layers`， 这个层的作用是接收离散特征，变成低维稠密。 接下来就是把连续特征和embedding之后的离散特征进行拼接，分别进入wide端和deep端。 wide端就是交叉网络，而deep端是DNN网络， 这里分别是`CrossNet()`和`get_dnn_output()`, 接下来就是把这两块的输出拼接得到最后的输出了。所以整体代码如下：
|
||||
|
||||
```python
|
||||
def DCN(linear_feature_columns, dnn_feature_columns):
|
||||
# 构建输入层，即所有特征对应的Input()层，这里使用字典的形式返回，方便后续构建模型
|
||||
dense_input_dict, sparse_input_dict = build_input_layers(linear_feature_columns + dnn_feature_columns)
|
||||
|
||||
# 构建模型的输入层，模型的输入层不能是字典的形式，应该将字典的形式转换成列表的形式
|
||||
# 注意：这里实际的输入与Input()层的对应，是通过模型输入时候的字典数据的key与对应name的Input层
|
||||
input_layers = list(dense_input_dict.values()) + list(sparse_input_dict.values())
|
||||
|
||||
# 构建维度为k的embedding层，这里使用字典的形式返回，方便后面搭建模型
|
||||
embedding_layer_dict = build_embedding_layers(dnn_feature_columns, sparse_input_dict, is_linear=False)
|
||||
|
||||
concat_dense_inputs = Concatenate(axis=1)(list(dense_input_dict.values()))
|
||||
|
||||
# 将特征中的sparse特征筛选出来
|
||||
sparse_feature_columns = list(filter(lambda x: isinstance(x, SparseFeat), linear_feature_columns)) if linear_feature_columns else []
|
||||
|
||||
sparse_kd_embed = concat_embedding_list(sparse_feature_columns, sparse_input_dict, embedding_layer_dict, flatten=True)
|
||||
|
||||
concat_sparse_kd_embed = Concatenate(axis=1)(sparse_kd_embed)
|
||||
|
||||
dnn_input = Concatenate(axis=1)([concat_dense_inputs, concat_sparse_kd_embed])
|
||||
|
||||
dnn_output = get_dnn_output(dnn_input)
|
||||
|
||||
cross_output = CrossNet()(dnn_input)
|
||||
|
||||
# stack layer
|
||||
stack_output = Concatenate(axis=1)([dnn_output, cross_output])
|
||||
|
||||
# 这里的激活函数使用sigmoid
|
||||
output_layer = Dense(1, activation='sigmoid')(stack_output)
|
||||
|
||||
model = Model(input_layers, output_layer)
|
||||
return model
|
||||
```
|
||||
|
||||
这个模型的实现过程和DeepFM比较类似，这里不画草图了，如果想看的可以去参考DeepFM草图及代码之间的对应关系。
|
||||
|
||||
下面是一个通过keras画的模型结构图，为了更好的显示，类别特征都只是选择了一小部分，画图的代码也在github中。
|
||||
|
||||
<div align=center> <img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片DCN.png" alt="image-20210308143101261" style="zoom: 50%;" />
|
||||
</div>
|
||||
|
||||
## 思考
|
||||
|
||||
1. 请计算Cross Network的复杂度，需要的变量请自己定义。
|
||||
2. 在实现矩阵计算$x_0*x_l^Tw$的过程中，有人说要先算前两个，有人说要先算后两个，请问那种方式更好？为什么？
|
||||
|
||||
**参考资料**
|
||||
* 《深度学习推荐系统》 --- 王喆
|
||||
* [Deep&Cross模型原论文](https://arxiv.org/abs/1708.05123)
|
||||
* AI上推荐 之 Wide&Deep与Deep&Cross模型（记忆与泛化并存的华丽转身）
|
||||
* [Wide&Deep模型的进阶---Cross&Deep模型](https://mp.weixin.qq.com/s/DkoaMaXhlgQv1NhZHF-7og)
|
||||
|
||||
147
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.2/FM.md
Normal file
147
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.2/FM.md
Normal file
@@ -0,0 +1,147 @@
|
||||
### FM模型的引入
|
||||
|
||||
#### 逻辑回归模型及其缺点
|
||||
|
||||
FM模型其实是一种思路，具体的应用稍少。一般来说做推荐CTR预估时最简单的思路就是将特征做线性组合（逻辑回归LR），传入sigmoid中得到一个概率值，本质上这就是一个线性模型，因为sigmoid是单调增函数不会改变里面的线性模型的CTR预测顺序，因此逻辑回归模型效果会比较差。也就是LR的缺点有：
|
||||
|
||||
* 是一个线性模型
|
||||
* 每个特征对最终输出结果独立，需要手动特征交叉（$x_i*x_j$），比较麻烦
|
||||
|
||||
<br>
|
||||
|
||||
#### 二阶交叉项的考虑及改进
|
||||
|
||||
由于LR模型的上述缺陷（主要是手动做特征交叉比较麻烦），干脆就考虑所有的二阶交叉项，也就是将目标函数由原来的
|
||||
|
||||
$$
|
||||
y = w_0+\sum_{i=1}^nw_ix_i
|
||||
$$
|
||||
变为
|
||||
|
||||
$$
|
||||
y = w_0+\sum_{i=1}^nw_ix_i+\sum_{i=1}^{n-1}\sum_{i+1}^nw_{ij}x_ix_j
|
||||
$$
|
||||
但这个式子有一个问题，**只有当$x_i$与$x_j$均不为0时这个二阶交叉项才会生效**，后面这个特征交叉项本质是和多项式核SVM等价的，为了解决这个问题，我们的FM登场了！
|
||||
|
||||
FM模型使用了如下的优化函数：
|
||||
|
||||
$$
|
||||
y = w_0+\sum_{i=1}^nw_ix_i+\sum_{i=1}^{n}\sum_{i+1}^n\lt v_i,v_j\gt x_ix_j
|
||||
$$
|
||||
事实上做的唯一改动就是把$w_{ij}$替换成了$\lt v_i,v_j\gt$，大家应该就看出来了，这实际上就有深度学习的意味在里面了，实质上就是给每个$x_i$计算一个embedding，然后将两个向量之间的embedding做内积得到之前所谓的$w_{ij}$好处就是这个模型泛化能力强 ，即使两个特征之前从未在训练集中**同时**出现，我们也不至于像之前一样训练不出$w_{ij}$，事实上只需要$x_i$和其他的$x_k$同时出现过就可以计算出$x_i$的embedding！
|
||||
|
||||
<br>
|
||||
|
||||
### FM公式的理解
|
||||
|
||||
从公式来看，模型前半部分就是普通的LR线性组合，后半部分的交叉项：特征组合。首先，单从模型表达能力上来看，FM是要强于LR的，至少它不会比LR弱，当交叉项参数$w_{ij}$全为0的时候，整个模型就退化为普通的LR模型。对于有$n$个特征的模型，特征组合的参数数量共有$1+2+3+\cdots + n-1=\frac{n(n-1)}{2}$个，并且任意两个参数之间是独立的。所以说特征数量比较多的时候，特征组合之后，维度自然而然就高了。
|
||||
|
||||
> 定理：任意一个实对称矩阵（正定矩阵）$W$都存在一个矩阵$V$，使得 $W=V.V^{T}$成立。
|
||||
|
||||
类似地，所有二次项参数$\omega_{ij}$可以组成一个对称阵$W$（为了方便说明FM的由来，对角元素可以设置为正实数），那么这个矩阵就可以分解为$W=V^TV$，$V$ 的第$j$列($v_{j}$)便是第$j$维特征($x_{j}$)的隐向量。
|
||||
|
||||
$$
|
||||
\hat{y}(X) = \omega_{0}+\sum_{i=1}^{n}{\omega_{i}x_{i}}+\sum_{i=1}^{n-1}{\sum_{j=i+1}^{n} \color{red}{<v_{i},v_{j}>x_{i}x_{j}}}
|
||||
$$
|
||||
|
||||
需要估计的参数有$\omega_{0}∈ R$，$\omega_{i}∈ R$，$V∈ R$，$< \cdot, \cdot>$是长度为$k$的两个向量的点乘，公式如下：
|
||||
|
||||
$$
|
||||
<v_{i},v_{j}> = \sum_{f=1}^{k}{v_{i,f}\cdot v_{j,f}}
|
||||
$$
|
||||
|
||||
上面的公式中：
|
||||
|
||||
- $\omega_{0}$为全局偏置；
|
||||
- $\omega_{i}$是模型第$i$个变量的权重;
|
||||
- $\omega_{ij} = < v_{i}, v_{j}>$特征$i$和$j$的交叉权重;
|
||||
- $v_{i} $是第$i$维特征的隐向量;
|
||||
- $<\cdot, \cdot>$代表向量点积;
|
||||
- $k(k<<n)$为隐向量的长度，包含 $k$ 个描述特征的因子。
|
||||
|
||||
FM模型中二次项的参数数量减少为 $kn $个，远少于多项式模型的参数数量。另外，参数因子化使得 $x_{h}x_{i}$ 的参数和 $x_{i}x_{j}$ 的参数不再是相互独立的，因此我们可以在样本稀疏的情况下相对合理地估计FM的二次项参数。具体来说，$x_{h}x_{i}$ 和 $x_{i}x_{j}$的系数分别为 $\lt v_{h},v_{i}\gt$ 和 $\lt v_{i},v_{j}\gt$ ，它们之间有共同项 $v_{i}$ 。也就是说，所有包含“ $x_{i}$ 的非零组合特征”（存在某个 $j \ne i$ ，使得 $x_{i}x_{j}\neq 0$ ）的样本都可以用来学习隐向量$v_{i}$，这很大程度上避免了数据稀疏性造成的影响。而在多项式模型中,$w_{hi}$ 和 $w_{ij}$ 是相互独立的。
|
||||
|
||||
显而易见，FM的公式是一个通用的拟合方程，可以采用不同的损失函数用于解决regression、classification等问题，比如可以采用MSE（Mean Square Error）loss function来求解回归问题，也可以采用Hinge/Cross-Entropy loss来求解分类问题。当然，在进行二元分类时，FM的输出需要使用sigmoid函数进行变换，该原理与LR是一样的。直观上看，FM的复杂度是 $O(kn^2)$ 。但是FM的二次项可以化简，其复杂度可以优化到 $O(kn)$ 。由此可见，FM可以在线性时间对新样本作出预测。
|
||||
|
||||
**证明**：
|
||||
$$
|
||||
\begin{aligned}
|
||||
\sum_{i=1}^{n-1}{\sum_{j=i+1}^{n}{<v_i,v_j>x_ix_j}}
|
||||
&= \frac{1}{2}\sum_{i=1}^{n}{\sum_{j=1}^{n}{<v_i,v_j>x_ix_j}} - \frac{1}{2} {\sum_{i=1}^{n}{<v_i,v_i>x_ix_i}} \\
|
||||
&= \frac{1}{2} \left( \sum_{i=1}^{n}{\sum_{j=1}^{n}{\sum_{f=1}^{k}{v_{i,f}v_{j,f}x_ix_j}}} - \sum_{i=1}^{n}{\sum_{f=1}^{k}{v_{i,f}v_{i,f}x_ix_i}} \right) \\
|
||||
&= \frac{1}{2}\sum_{f=1}^{k}{\left[ \left( \sum_{i=1}^{n}{v_{i,f}x_i} \right) \cdot \left( \sum_{j=1}^{n}{v_{j,f}x_j} \right) - \sum_{i=1}^{n}{v_{i,f}^2 x_i^2} \right]} \\
|
||||
&= \frac{1}{2}\sum_{f=1}^{k}{\left[ \left( \sum_{i=1}^{n}{v_{i,f}x_i} \right)^2 - \sum_{i=1}^{n}{v_{i,f}^2 x_i^2} \right]}
|
||||
\end{aligned}
|
||||
$$
|
||||
**解释**：
|
||||
|
||||
- $v_{i,f}$ 是一个具体的值；
|
||||
- 第1个等号：对称矩阵 $W$ 对角线上半部分；
|
||||
- 第2个等号：把向量内积 $v_{i}$,$v_{j}$ 展开成累加和的形式；
|
||||
- 第3个等号：提出公共部分；
|
||||
- 第4个等号： $i$ 和 $j$ 相当于是一样的，表示成平方过程。
|
||||
|
||||
<br>
|
||||
|
||||
### FM优缺点
|
||||
|
||||
**优点**
|
||||
1. 通过向量内积作为交叉特征的权重，可以在数据非常稀疏的情况下还能有效的训练处交叉特征的权重（因为不需要两个特征同时不为零）
|
||||
2. 可以通过公式上的优化，得到O(nk)的计算复杂度，k一般比较小，所以基本上和n是正相关的，计算效率非常高
|
||||
3. 尽管推荐场景下的总体特征空间非常大，但是FM的训练和预测只需要处理样本中的非零特征，这也提升了模型训练和线上预测的速度
|
||||
4. 由于模型的计算效率高，并且在稀疏场景下可以自动挖掘长尾低频物料。所以在召回、粗排和精排三个阶段都可以使用。应用在不同阶段时，样本构造、拟合目标及线上服务都有所不同（注意FM用于召回时对于user和item相似度的优化）
|
||||
5. 其他优点及工程经验参考石塔西的文章
|
||||
|
||||
**缺点**
|
||||
1. 只能显示的做特征的二阶交叉，对于更高阶的交叉无能为力。对于此类问题，后续就提出了各类显示、隐式交叉的模型，来充分挖掘特征之间的关系
|
||||
|
||||
### 代码实现
|
||||
|
||||
```python
|
||||
class FM(Layer):
|
||||
"""显示特征交叉，直接按照优化后的公式实现即可
|
||||
注意：
|
||||
1. 传入进来的参数看起来是一个Embedding权重，没有像公式中出现的特征，那是因
|
||||
为，输入的id特征本质上都是onehot编码，取出对应的embedding就等价于特征乘以
|
||||
权重。所以后续的操作直接就是对特征进行操作
|
||||
2. 在实现过程中，对于公式中的平方的和与和的平方两部分，需要留意是在哪个维度
|
||||
上计算，这样就可以轻松实现FM特征交叉模块
|
||||
"""
|
||||
def __init__(self, **kwargs):
|
||||
super(FM, self).__init__(**kwargs)
|
||||
|
||||
def build(self, input_shape):
|
||||
if not isinstance(input_shape, list) or len(input_shape) < 2:
|
||||
raise ValueError('`FM` layer should be called \
|
||||
on a list of at least 2 inputs')
|
||||
super(FM, self).build(input_shape) # Be sure to call this somewhere!
|
||||
|
||||
def call(self, inputs, **kwargs):
|
||||
"""
|
||||
inputs: 是一个列表，列表中每个元素的维度为：(None, 1, emb_dim)， 列表长度
|
||||
为field_num
|
||||
"""
|
||||
concated_embeds_value = Concatenate(axis=1)(inputs) #(None,field_num,emb_dim)
|
||||
# 根据最终优化的公式计算即可，需要注意的是计算过程中是沿着哪个维度计算的，将代码和公式结合起来看会更清晰
|
||||
square_of_sum = tf.square(tf.reduce_sum(
|
||||
concated_embeds_value, axis=1, keepdims=True)) # (None, 1, emb_dim)
|
||||
sum_of_square = tf.reduce_sum(
|
||||
concated_embeds_value * concated_embeds_value,
|
||||
axis=1, keepdims=True) # (None, 1, emb_dim)
|
||||
cross_term = square_of_sum - sum_of_square
|
||||
cross_term = 0.5 * tf.reduce_sum(cross_term, axis=2, keepdims=False)#(None,1)
|
||||
return cross_term
|
||||
|
||||
def compute_output_shape(self, input_shape):
|
||||
return (None, 1)
|
||||
|
||||
def get_config(self):
|
||||
return super().get_config()
|
||||
```
|
||||
|
||||
|
||||
**参考资料**
|
||||
* [FM：推荐算法中的瑞士军刀](https://zhuanlan.zhihu.com/p/343174108)
|
||||
* [FM算法解析](https://zhuanlan.zhihu.com/p/37963267)
|
||||
* [FM论文原文](https://www.csie.ntu.edu.tw/~b97053/paper/Rendle2010FM.pdf)
|
||||
* [AI上推荐 之 FM和FFM](https://blog.csdn.net/wuzhongqiang/article/details/108719417)
|
||||
451
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.2/FiBiNet.md
Normal file
451
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.2/FiBiNet.md
Normal file
@@ -0,0 +1,451 @@
|
||||
## 写在前面
|
||||
FiBiNET(Feature Importance and Bilinear feature Interaction)是2019年发表在RecSys的一个模型，来自新浪微博张俊林老师的团队。这个模型如果从模型演化的角度来看， 主要是在特征重要性以及特征之间交互上做出了探索。所以，如果想掌握FiBiNet的话，需要掌握两大核心模块：
|
||||
* 模型的特征重要性选择 --- SENET网络
|
||||
* 特征之间的交互 --- 双线性交叉层(组合了内积和哈达玛积)
|
||||
|
||||
|
||||
## FiBiNet？ 我们先需要先了解这些
|
||||
|
||||
FiBiNet的提出动机是因为在特征交互这一方面， 目前的ctr模型要么是简单的两两embedding内积(这里针对离散特征)， 比如FM，FFM。 或者是两两embedding进行哈达玛积(NFM这种)， 作者认为这两种交互方式还是过于简单， 另外像NFM这种，FM这种，也忽视了特征之间的重要性程度。
|
||||
|
||||
对于特征重要性，作者在论文中举得例子非常形象
|
||||
>the feature occupation is more important than the feature hobby when we predict a person’s income
|
||||
|
||||
所以要想让模型学习到更多的信息， 从作者的角度来看，首先是离散特征之间的交互必不可少，且需要更细粒度。第二个就是需要考虑不同特征对于预测目标的重要性程度，给不同的特征根据重要性程度进行加权。 写到这里， 如果看过之前的文章的话，这个是不是和某些模型有些像呀， 没错，AFM其实考虑了这一点， 不过那里是用了一个Attention网络对特征进行的加权， 这里采用了另一种思路而已，即SENET， 所以这里我们如果是考虑特征重要性程度的话， 就有了两种思路：
|
||||
* Attention
|
||||
* SENET
|
||||
|
||||
而考虑特征交互的话， 思路应该会更多：
|
||||
* PNN里面的内积和外积
|
||||
* NFM里面的哈达玛积
|
||||
* 这里的双线性函数交互(内积和哈达玛积的组合)
|
||||
|
||||
所以，读论文， 这些思路感觉要比模型本身重要，而读论文还有一个有意思的事情，那就是我们既能了解思路，也能想一下，为啥这些方法会有效果呢？ 我们自己能不能提出新的方法来呢？ 如果读一篇paper，再顺便把后面的这些问题想通了， 那么这篇paper对于我们来说就发挥效用了， 后面就可以用拉马努金式方法训练自己的思维。
|
||||
|
||||
在前面的准备工作中，作者依然是带着我们梳理了整个推荐模型的演化过程， 我们也简单梳理下，就当回忆:
|
||||
* FNN: 下面是经过FM预训练的embedding层， 也就是先把FM训练好，得到各个特征的embedding，用这个embedding初始化FNN下面的embedding层， 上面是DNN。 这个模型用的不是很多，缺点是只能搞隐性高阶交互，并且下面的embedding和高层的DNN配合不是很好。
|
||||
* WDL： 这是一个经典的W&D架构， w逻辑回归维持记忆， DNN保持高阶特征交互。问题是W端依然需要手动特征工程，也就是低阶交互需要手动来搞，需要一定的经验。一般工业上也不用了。
|
||||
* DeepFM：对WDL的逻辑回归进行升级， 把逻辑回归换成FM， 这样能保证低阶特征的自动交互， 兼顾记忆和泛化性能，低阶和高阶交互。 目前这个模型在工业上非常常用，效果往往还不错，SOTA模型。
|
||||
* DCN： 认为DeepFM的W端的FM的交互还不是很彻底，只能到二阶交互。所以就提出了一种交叉性网络，可以在W端完成高阶交互。
|
||||
* xDeepFM: DCN的再次升级，认为DCN的wide端交叉网络这种element-wise的交互方式不行，且不是显性的高阶交互，所以提出了一个专门用户高阶显性交互的CIN网络， vector-wise层次上的特征交互。
|
||||
* NFM: 下层是FM， 中间一个交叉池化层进行两两交互，然后上面接DNN， 工业上用的不多。
|
||||
* AFM: 从NFM的基础上，考虑了交互完毕之后的特征重要性程度， 从NFM的基础上加了一个Attention网络，所以如果用的话，也应该用AFM。
|
||||
|
||||
综上， 这几个网络里面最常用的还是属DeepFM了， 当然对于交互来讲，在我的任务上试过AFM和xDeepFM， 结果是AFM和DeepFM差不多持平， 而xDeepFM要比这俩好一些，但并不多，而考虑完了复杂性， 还是DeepFM或者AFM。
|
||||
|
||||
对于上面模型的问题，作者说了两点，第一个是大部分模型没有考虑特征重要性，也就是交互完事之后，没考虑对于预测目标来讲谁更重要，一视同仁。 第二个是目前的两两特征交互，大部分依然是内积或者哈达玛积， 作者认为还不是细粒度(fine-grained way)交互。
|
||||
|
||||
那么，作者是怎么针对这两个问题进行改进的呢？ 为什么这么改进呢？
|
||||
|
||||
## FiBiNet模型的理论以及论文细节
|
||||
这里我们直接分析模型架构即可， 因为这个模型不是很复杂，也非常好理解前向传播的过程：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210703160140322.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="image-20210308142624189" style="zoom: 80%;" />
|
||||
</div>
|
||||
|
||||
从模型架构上来看，如果把我框出来的两部分去掉， 这个基本上就退化成了最简单的推荐深度模型DeepCrossing，甚至还比不上那个(那个还用了残差网络)。不过，加上了两个框，效果可就不一样了。所以下面重点是剖析下这两个框的结构，其他的简单一过即可。
|
||||
>梳理细节之前， 先说下前向传播的过程。 <br>
|
||||
>首先，我们输入的特征有离散和连续，对于连续的特征，输入完了之后，先不用管，等待后面拼起来进DNN即可，这里也没有刻意处理连续特征。
|
||||
><br>对于离散特征，过embedding转成低维稠密，一般模型的话，这样完了之后，就去考虑embedding之间交互了。 而这个模型不是， 在得到离散特征的embedding之后，分成了两路
|
||||
>* 一路保持原样， 继续往后做两两之间embedding交互，不过这里的交互方式，不是简单的内积或者哈达玛积，而是采用了非线性函数，这个后面会提到。
|
||||
>* 另一路，过一个SENET Layer， 过完了之后得到的输出是和原来embedding有着相同维度的，这个SENET的理解方式和Attention网络差不多，也是根据embedding的重要性不同出来个权重乘到了上面。 这样得到了SENET-like Embedding，就是加权之后的embedding。 这时候再往上两两双线性交互。
|
||||
>
|
||||
>两路embedding都两两交互完事， Flatten展平，和连续特征拼在一块过DNN输出。
|
||||
|
||||
|
||||
### Embedding Layer
|
||||
这个不多讲， 整理这个是为了后面统一符号。
|
||||
|
||||
假设我们有$f$个离散特征，经过embedding层之后，会得到$E=\left[e_{1}, e_{2}, \cdots, e_{i}, \cdots, e_{f}\right]$， 其中$e_{i} \in R^{k}$，表示第$i$个离散特征对应的embedding向量，$k$维。
|
||||
|
||||
### SENET Layer
|
||||
这是第一个重点，首先这个网络接收的输入是上面的$E=\left[e_{1}, e_{2}, \cdots, e_{i}, \cdots, e_{f}\right]$， 网络的输出也是个同样大小的张量`(None, f, k)`矩阵。 结构如下：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210703162008862.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="image-20210308142624189" style="zoom: 80%;" />
|
||||
</div>
|
||||
|
||||
SENet由自动驾驶公司Momenta在2017年提出，在当时，是一种应用于图像处理的新型网络结构。它基于CNN结构，**通过对特征通道间的相关性进行建模，对重要特征进行强化来提升模型准确率，本质上就是针对CNN中间层卷积核特征的Attention操作**。ENet仍然是效果最好的图像处理网络结构之一。
|
||||
>SENet能否用到推荐系统？--- 张俊林老师的知乎(链接在文末)<br>
|
||||
>推荐领域里面的特征有个特点，就是海量稀疏，意思是大量长尾特征是低频的，而这些低频特征，去学一个靠谱的Embedding是基本没希望的，但是你又不能把低频的特征全抛掉，因为有一些又是有效的。既然这样，**如果我们把SENet用在特征Embedding上，类似于做了个对特征的Attention，弱化那些不靠谱低频特征Embedding的负面影响，强化靠谱低频特征以及重要中高频特征的作用，从道理上是讲得通的**
|
||||
|
||||
所以拿来用了再说， 把SENet放在Embedding层之上，通过SENet网络，动态地学习这些特征的重要性。**对于每个特征学会一个特征权重，然后再把学习到的权重乘到对应特征的Embedding里，这样就可以动态学习特征权重，通过小权重抑制噪音或者无效低频特征，通过大权重放大重要特征影响的目的**。在推荐系统里面， 结构长这个样子：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210703161807139.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="image-20210308142624189" style="zoom: 80%;" />
|
||||
</div>
|
||||
|
||||
下面看下这个网络里面的具体计算过程， SENET主要分为三个步骤Squeeze, Excitation, Re-weight。
|
||||
|
||||
* **在Squeeze阶段**，我们对每个特征的Embedding向量进行数据压缩与信息汇总，如下：
|
||||
|
||||
$$
|
||||
z_{i}=F_{s q}\left(e_{i}\right)=\frac{1}{k} \sum_{t=1}^{k} e_{i}^{(t)}
|
||||
$$
|
||||
|
||||
假设某个特征$v_i$是$k$维大小的$Embedding$，那么我们对$Embedding$里包含的$k$维数字求均值，得到能够代表这个特征汇总信息的数值 $z_i$，也就是说，把第$i$个特征的$Embedding$里的信息压缩到一个数值。原始版本的SENet，在这一步是对CNN的二维卷积核进行$Max$操作的，这里等于对某个特征Embedding元素求均值。我们试过，在推荐领域均值效果比$Max$效果好，这也很好理解，因为**图像领域对卷积核元素求$Max$，等于找到最强的那个特征，而推荐领域的特征$Embedding$，每一位的数字都是有意义的，所以求均值能更好地保留和融合信息**。通过Squeeze阶段，对于每个特征$v_i$ ，都压缩成了单个数值$z_i$，假设特征Embedding层有$f$个特征，就形成Squeeze向量$Z$，向量大小$f$。
|
||||
|
||||
* **Excitation阶段**，这个阶段引入了中间层比较窄的两层MLP网络，作用在Squeeze阶段的输出向量$Z$上，如下：
|
||||
|
||||
$$
|
||||
A=F_{e x}(Z)=\sigma_{2}\left(W_{2} \sigma_{1}\left(W_{1} Z\right)\right)
|
||||
$$
|
||||
|
||||
$\sigma$非线性激活函数，一般$relu$。本质上，这是在做特征的交叉，也就是说，每个特征以一个$Bit$来表征，通过MLP来进行交互，通过交互，得出这么个结果：对于当前所有输入的特征，通过相互发生关联，来动态地判断哪些特征重要，哪些特征不重要。
|
||||
|
||||
其中，第一个MLP的作用是做特征交叉，第二个MLP的作用是为了保持输出的大小维度。因为假设Embedding层有$f$个特征，那么我们需要保证输出$f$个权重值，而第二个MLP就是起到将大小映射到$f$个数值大小的作用。<br><br>这样，经过两层MLP映射，就会产生$f$个权重数值，第$i$个数值对应第$i$个特征Embedding的权重$a_i$ 。<br><br>这个东西有没有感觉和自动编码器很像，虽然不是一样的作用， 但网络结构是一样的。这就是知识串联的功效哈哈。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/2021070316343673.png#pic_center" alt="image-20210308142624189" style="zoom: 70%;" />
|
||||
</div>
|
||||
|
||||
瞬间是不是就把SENet这里的网络结构记住了哈哈。下面再分析下维度， SENet的输入是$E$，这个是`(None, f, k)`的维度， 通过Squeeze阶段，得到了`(None, f)`的矩阵，这个也就相当于Layer L1的输入(当然这里没有下面的偏置哈)，接下来过MLP1， 这里的$W_{1} \in R^{f \times \frac{f}{r}}, W_{2} \in R^{\frac{f}{r} \times f}$, 这里的$r$叫做reduction
|
||||
ratio， $\frac{f}{r}$这个就是中间层神经元的个数， $r$表示了压缩的程度。
|
||||
|
||||
* Re-Weight
|
||||
我们把Excitation阶段得到的每个特征对应的权重$a_i$，再乘回到特征对应的Embedding里，就完成了对特征重要性的加权操作。
|
||||
$$V=F_{\text {ReWeight }}(A, E)=\left[a_{1} \cdot e_{1}, \cdots, a_{f} \cdot e_{f}\right]=\left[v_{1}, \cdots, v_{f}\right]$$
|
||||
$a_{i} \in R, e_{i} \in R^{k}$, and $v_{i} \in R^{k}$。$a_i$数值大，说明SENet判断这个特征在当前输入组合里比较重要， $a_i$数值小，说明SENet判断这个特征在当前输入组合里没啥用。如果非线性函数用Relu，会发现大量特征的权重会被Relu搞成0，也就是说，其实很多特征是没啥用的。
|
||||
|
||||
|
||||
这样，就可以将SENet引入推荐系统，用来对特征重要性进行动态判断。注意，**所谓动态，指的是比如对于某个特征，在某个输入组合里可能是没用的，但是换一个输入组合，很可能是重要特征。它重要不重要，不是静态的，而是要根据当前输入，动态变化的**。
|
||||
|
||||
这里正确的理解，算是一种特征重要性选择的思路， SENET和AFM的Attention网络是起着同样功效的一个网络。只不过那个是在特征交互之后进行特征交互重要性的选择，而这里是从embedding这里先压缩，再交互，再选择，去掉不太重要的特征。 **考虑特征重要性上的两种考虑思路，难以说孰好孰坏，具体看应用场景**。 不过如果分析下这个东西为啥会有效果， 就像张俊林老师提到的那样， 在Excitation阶段， 各个特征过了一个MLP进行了特征组合， 这样就真有可能过滤掉对于当前的交互不太重要的特征。 至于是不是， 那神经网络这东西就玄学了，让网络自己去学吧。
|
||||
|
||||
### Bilinear-Interaction Layer
|
||||
特征重要性选择完事， 接下来就是研究特征交互， 这里作者直接就列出了目前的两种常用交互以及双线性交互:
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210703165031369.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="image-20210308142624189" style="zoom: 70%;" />
|
||||
</div>
|
||||
|
||||
这个图其实非常了然了。以往模型用的交互， 内积的方式(FM,FFM)这种或者哈达玛积的方式(NFM,AFM)这种。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210703165221794.png#pic_center" alt="image-20210308142624189" style="zoom: 70%;" >
|
||||
</div>
|
||||
|
||||
所谓的双线性，其实就是组合了内积和哈达玛积的操作，看上面的右图。就是在$v_i$和$v_j$之间先加一个$W$矩阵， 这个$W$矩阵的维度是$(f,f)$, $v_i, v_j$是$(1,f)$的向量。 先让$v_i$与$W$内积，得到$(1,f)$的向量，这时候先仔细体会下这个**新向量的每个元素，相当于是原来向量$v_i$在每个维度上的线性组合了**。这时候再与$v_j$进行哈达玛积得到结果。
|
||||
|
||||
这里我不由自主的考虑了下双线性的功效，也就是为啥作者会说双线性是细粒度，下面是我自己的看法哈。
|
||||
* 如果我们单独先看内积操作，特征交互如果是两个向量直接内积，这时候， 结果大的，说明两个向量相似或者特征相似， 但向量内积，其实是相当于向量的各个维度先对应位置元素相乘再相加求和。 这个过程中认为的是向量的各个维度信息的重要性是一致的。类似于$v_1+v_2+..v_k$， 但真的一致吗？ --- **内积操作没有考虑向量各个维度的重要性**
|
||||
* 如果我们单独看哈达玛积操作， 特征交互如果是两个向量哈达玛积，这时候，是各个维度对应位置元素相乘得到一个向量， 而这个向量往往后面会进行线性或者非线性交叉的操作， 最后可能也会得到具体某个数值，但是这里经过了线性或者非线性交叉操作之后， 有没有感觉把向量各个维度信息的重要性考虑了进来？ 就类似于$w_1v_{i1j1}+w_2k_{v2j2},...w_kv_{vkjk}$。 如果模型认为重要性相同，那么哈达玛积还有希望退化成内积，所以哈达玛积感觉考虑的比内积就多了一些。 --- **哈达玛积操作自身也没有考虑各个维度重要性，但通过后面的线性或者非线性操作，有一定的维度重要性在里面**
|
||||
* 再看看这个双线性， 是先内积再哈达玛积。这个内积操作不是直接$v_i$和$v_j$内积，而是中间引入了个$W$矩阵，参数可学习。 那么$v_i$和$W$做内积之后，虽然得到了同样大小的向量，但是这个向量是$v_i$各个维度元素的线性组合，相当于$v_i$变成了$[w_{11}v_{i1}+...w_{1k}v_{ik}, w_{21}v_{i1}+..w_{2k}v_{ik}, ...., w_{k1}v_{i1}+...w_{kk}v_{ik}]$， 这时候再与$v_j$哈达玛积的功效，就变成了$[(w_{11}v_{i1}+...w_{1k}v_{ik})v_{j1}, (w_{21}v_{i1}+..w_{2k}v_{ik})v_{j2}, ...., (w_{k1}v_{i1}+...w_{kk}v_{ik})v_{j_k}]$， 这时候，就可以看到，如果这里的$W$是个对角矩阵，那么这里就退化成了哈达玛积。 所以双线性感觉考虑的又比哈达玛积多了一些。如果后面再走一个非线性操作的话，就会发现这里同时考虑了两个交互向量各个维度上的重要性。---**双线性操作同时可以考虑交互的向量各自的各个维度上的重要性信息， 这应该是作者所说的细粒度，各个维度上的重要性**
|
||||
|
||||
**当然思路是思路，双线性并不一定见得一定比哈达玛积有效， SENET也不一定就会比原始embedding要好，一定要辩证看问题**
|
||||
|
||||
这里还有个厉害的地方在于这里的W有三种选择方式，也就是三种类型的双线性交互方式。
|
||||
1. Field-All Type
|
||||
$$
|
||||
p_{i j}=v_{i} \cdot W \odot v_{j}
|
||||
$$
|
||||
也就是所有的特征embedding共用一个$W$矩阵，这也是Field-All的名字来源。$W \in R^{k \times k}, \text { and } v_{i}, v_{j} \in R^{k}$。这种方式最简单
|
||||
2. Field-Each Type
|
||||
$$
|
||||
p_{i j}=v_{i} \cdot W_{i} \odot v_{j}
|
||||
$$
|
||||
每个特征embedding共用一个$W$矩阵， 那么如果有$f$个特征的话，这里的$W_i$需要$f$个。所以这里的参数个数$f-1\times k\times k$， 这里的$f-1$是因为两两组合之后，比如`[0,1,2]`， 两两组合`[0,1], [0,2], [1,2]`。 这里用到的域是0和1。
|
||||
3. Field-Interaction Type
|
||||
$$
|
||||
p_{i j}=v_{i} \cdot W_{i j} \odot v_{j}
|
||||
$$
|
||||
每组特征交互的时候，用一个$W$矩阵， 那么这里如果有$f$个特征的话，需要$W_{ij}$是$\frac{f(f-1)}{2}$个。参数个数$\frac{f(f-1)}{2}\times k\times k$个。
|
||||
|
||||
不知道看到这里，这种操作有没有种似曾相识的感觉， 有没有想起FM和FFM， 反正我是不自觉的想起了哈哈，不知道为啥。总感觉FM的风格和上面的Field-All很像， 而FFM和下面的Field-Interaction很像。
|
||||
|
||||
我们的原始embedding和SKNET-like embedding都需要过这个层，那么得到的就是一个双线性两两组合的矩阵， 维度是$(\frac{f(f-1)}{2}, k)$的矩阵。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210703173830995.png#pic_center" alt="image-20210308142624189" style="zoom: 70%;" >
|
||||
</div>
|
||||
|
||||
### Combination Layer
|
||||
这个层的作用就是把目前得到的特征拼起来
|
||||
$$
|
||||
c=F_{\text {concat }}(p, q)=\left[p_{1}, \cdots, p_{n}, q_{1}, \cdots, q_{n}\right]=\left[c_{1}, \cdots, c_{2 n}\right]
|
||||
$$
|
||||
这里他直拼了上面得到的两个离散特征通过各种交互之后的形式，如果是还有连续特征的话，也可以在这里拼起来，然后过DNN，不过这里其实还省略了一步操作就是Flatten，先展平再拼接。
|
||||
|
||||
### DNN和输出层
|
||||
这里就不多说了， DNN的话普通的全连接网络， 再捕捉一波高阶的隐性交互。
|
||||
$$
|
||||
a^{(l)}=\sigma\left(W^{(l)} a^{(l-1)}+b^{(l)}\right)
|
||||
$$
|
||||
而输出层
|
||||
$$
|
||||
\hat{y}=\sigma\left(w_{0}+\sum_{i=0}^{m} w_{i} x_{i}+y_{d}\right)
|
||||
$$
|
||||
分类问题损失函数：
|
||||
$$
|
||||
\operatorname{loss}=-\frac{1}{N} \sum_{i=1}^{N}\left(y_{i} \log \left(\hat{y}_{i}\right)+\left(1-y_{i}\right) * \log \left(1-\hat{y}_{i}\right)\right)
|
||||
$$
|
||||
这里就不解释了。
|
||||
|
||||
### 其他重要细节
|
||||
实验部分，这里作者也是做了大量的实验来证明提出的模型比其他模型要好，这个就不说了。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/2021070317512940.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="image-20210308142624189" style="zoom: 70%;" >
|
||||
</div>
|
||||
|
||||
竟然比xDeepFM都要好。
|
||||
|
||||
在模型评估指标上，用了AUC和Logloss，这个也是常用的指标，Logloss就是交叉熵损失， 反映了样本的平均偏差，经常作为模型的损失函数来做优化，可是，当训练数据正负样本不平衡时，比如我们经常会遇到正样本很少，负样本很多的情况，此时LogLoss会倾向于偏向负样本一方。 而AUC评估不会受很大影响，具体和AUC的计算原理有关。这个在这里就不解释了。
|
||||
|
||||
其次了解到的一个事情：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210703175052617.png#pic_center" alt="image-20210308142624189" style="zoom: 70%;" >
|
||||
</div>
|
||||
|
||||
接下来，得整理下双线性与哈达玛积的组合类型，因为我们这个地方其实有两路embedding的， 一路是原始embedding， 一路是SKNet侧的embedding。而面临的组合方式，有双线性和哈达玛积两种。那么怎么组合会比较好呢？ 作者做了实验。结论是，作者建议:
|
||||
>深度学习模型中，原始那边依然哈达玛，SE那边双线性， 可能更有效， 不过后面的代码实现里面，都用了双线性。
|
||||
|
||||
|
||||
而具体，在双线性里面，那种W的原则有效呢？ 这个视具体的数据集而定。
|
||||
|
||||
超参数选择，主要是embedding维度以及DNN层数， embedding维度这个10-50， 不同的数据集可能表现不一样， 但尽量不要超过50了。否则在DNN之前的特征维度会很大。
|
||||
|
||||
DNN层数，作者这里建议3层，而每一层神经单元个数，也是没有定数了。
|
||||
|
||||
这里竟然没有说$r$的确定范围。 Deepctr里面默认是3。
|
||||
|
||||
对于实际应用的一些经验:
|
||||
1. SE-FM 在实验数据效果略高于 FFM，优于FM，对于模型处于低阶的团队，升级FM、SE-FM成本比较低
|
||||
|
||||
2. deepSE-FM 效果优于DCN、XDeepFM 这类模型，相当于**XDeepFM这种难上线的模型**来说，很值得尝试，不过大概率怀疑是**增加特征交叉的效果，特征改进比模型改进work起来更稳**
|
||||
3. 实验中增加embeding 长度费力不讨好，效果增加不明显，如果只是增加长度不改变玩法边际效应递减，**不增加长度增加emmbedding 交叉方式类似模型的ensemble更容易有效果**
|
||||
|
||||
|
||||
## FiBiNet模型的代码复现及重要结构解释
|
||||
这里的话，参考deepctr修改的简化版本。
|
||||
### 全貌
|
||||
|
||||
对于输入，就不详细的说了，在xDeepFM那里已经解释了， 首先网络的整体全貌:
|
||||
|
||||
```python
|
||||
def fibinet(linear_feature_columns, dnn_feature_columns, bilinear_type='interaction', reduction_ratio=3, hidden_units=[128, 128]):
|
||||
"""
|
||||
:param linear_feature_columns, dnn_feature_columns: 封装好的wide端和deep端的特征
|
||||
:param bilinear_type: 双线性交互类型， 有'all', 'each', 'interaction'三种
|
||||
:param reduction_ratio: senet里面reduction ratio
|
||||
:param hidden_units: DNN隐藏单元个数
|
||||
"""
|
||||
|
||||
# 构建输出层, 即所有特征对应的Input()层， 用字典的形式返回，方便后续构建模型
|
||||
dense_input_dict, sparse_input_dict = build_input_layers(linear_feature_columns + dnn_feature_columns)
|
||||
|
||||
# 构建模型的输入层，模型的输入层不能是字典的形式，应该将字典的形式转换成列表的形式
|
||||
# 注意：这里实际的输入预Input层对应，是通过模型输入时候的字典数据的key与对应name的Input层
|
||||
input_layers = list(dense_input_dict.values()) + list(sparse_input_dict.values())
|
||||
|
||||
# 线性部分的计算逻辑 -- linear
|
||||
linear_logits = get_linear_logits(dense_input_dict, sparse_input_dict, linear_feature_columns)
|
||||
|
||||
# 构建维度为k的embedding层，这里使用字典的形式返回，方便后面搭建模型
|
||||
# 线性层和dnn层统一的embedding层
|
||||
embedding_layer_dict = build_embedding_layers(linear_feature_columns+dnn_feature_columns, sparse_input_dict, is_linear=False)
|
||||
|
||||
# DNN侧的计算逻辑 -- Deep
|
||||
# 将dnn_feature_columns里面的连续特征筛选出来，并把相应的Input层拼接到一块
|
||||
dnn_dense_feature_columns = list(filter(lambda x: isinstance(x, DenseFeat), dnn_feature_columns)) if dnn_feature_columns else []
|
||||
dnn_dense_feature_columns = [fc.name for fc in dnn_dense_feature_columns]
|
||||
dnn_concat_dense_inputs = Concatenate(axis=1)([dense_input_dict[col] for col in dnn_dense_feature_columns])
|
||||
|
||||
# 将dnn_feature_columns里面的离散特征筛选出来，相应的embedding层拼接到一块,然后过SENet_layer
|
||||
dnn_sparse_kd_embed = concat_embedding_list(dnn_feature_columns, sparse_input_dict, embedding_layer_dict, flatten=False)
|
||||
sparse_embedding_list = Concatenate(axis=1)(dnn_sparse_kd_embed)
|
||||
|
||||
# SENet layer
|
||||
senet_embedding_list = SENETLayer(reduction_ratio)(sparse_embedding_list)
|
||||
|
||||
# 双线性交互层
|
||||
senet_bilinear_out = BilinearInteraction(bilinear_type=bilinear_type)(senet_embedding_list)
|
||||
raw_bilinear_out = BilinearInteraction(bilinear_type=bilinear_type)(sparse_embedding_list)
|
||||
|
||||
bilinear_out = Flatten()(Concatenate(axis=1)([senet_bilinear_out, raw_bilinear_out]))
|
||||
|
||||
# DNN层的输入和输出
|
||||
dnn_input = Concatenate(axis=1)([bilinear_out, dnn_concat_dense_inputs])
|
||||
dnn_out = get_dnn_output(dnn_input, hidden_units=hidden_units)
|
||||
dnn_logits = Dense(1)(dnn_out)
|
||||
|
||||
# 最后的输出
|
||||
final_logits = Add()([linear_logits, dnn_logits])
|
||||
|
||||
# 输出层
|
||||
output_layer = Dense(1, activation='sigmoid')(final_logits)
|
||||
|
||||
model = Model(input_layers, output_layer)
|
||||
|
||||
return model
|
||||
```
|
||||
这里依然是是采用了线性层计算与DNN相结合的方式。 前向传播这里也不详细描述了。这里面重点是SENETLayer和BilinearInteraction层，其他的和之前网络模块基本上一样。
|
||||
|
||||
### SENETLayer
|
||||
这里的输入是`[None, field_num embed_dim]`的维度，也就是离散特征的embedding， 拿到这个输入之后，三个步骤，得到的是一个`[None, feild_num, embed_dim]`的同样维度的矩阵，只不过这里是SKNET-like embedding了。
|
||||
|
||||
```python
|
||||
class SENETLayer(Layer):
|
||||
def __init__(self, reduction_ratio, seed=2021):
|
||||
super(SENETLayer, self).__init__()
|
||||
self.reduction_ratio = reduction_ratio
|
||||
self.seed = seed
|
||||
|
||||
def build(self, input_shape):
|
||||
# input_shape [None, field_nums, embedding_dim]
|
||||
self.field_size = input_shape[1]
|
||||
self.embedding_size = input_shape[-1]
|
||||
|
||||
# 中间层的神经单元个数 f/r
|
||||
reduction_size = max(1, self.field_size // self.reduction_ratio)
|
||||
|
||||
# FC layer1和layer2的参数
|
||||
self.W_1 = self.add_weight(shape=(
|
||||
self.field_size, reduction_size), initializer=glorot_normal(seed=self.seed), name="W_1")
|
||||
self.W_2 = self.add_weight(shape=(
|
||||
reduction_size, self.field_size), initializer=glorot_normal(seed=self.seed), name="W_2")
|
||||
|
||||
self.tensordot = tf.keras.layers.Lambda(
|
||||
lambda x: tf.tensordot(x[0], x[1], axes=(-1, 0)))
|
||||
|
||||
# Be sure to call this somewhere!
|
||||
super(SENETLayer, self).build(input_shape)
|
||||
|
||||
def call(self, inputs):
|
||||
# inputs [None, field_num, embed_dim]
|
||||
|
||||
# Squeeze -> [None, field_num]
|
||||
Z = tf.reduce_mean(inputs, axis=-1)
|
||||
|
||||
# Excitation
|
||||
A_1 = tf.nn.relu(self.tensordot([Z, self.W_1])) # [None, reduction_size]
|
||||
A_2 = tf.nn.relu(self.tensordot([A_1, self.W_2])) # [None, field_num]
|
||||
|
||||
# Re-Weight
|
||||
V = tf.multiply(inputs, tf.expand_dims(A_2, axis=2)) # [None, field_num, embedding_dim]
|
||||
|
||||
return V
|
||||
```
|
||||
三个步骤还是比较好理解的， 这里这种自定义层权重的方式需要学习下。
|
||||
|
||||
### 4.3 BilinearInteraction Layer
|
||||
这里接收的输入同样是`[None, field_num embed_dim]`的维度离散特征的embedding。 输出是来两两交互完毕的矩阵$[None, \frac{f(f-1)}{2}, embed\_dim]$
|
||||
|
||||
这里的双线性交互有三种形式，具体实现的话可以参考下面的代码，我加了注释， 后面两种用到了组合的方式， 感觉人家这种实现方式还是非常巧妙的。
|
||||
```python
|
||||
class BilinearInteraction(Layer):
|
||||
"""BilinearInteraction Layer used in FiBiNET.
|
||||
Input shape
|
||||
- 3D tensor with shape: ``(batch_size,field_size,embedding_size)``.
|
||||
Output shape
|
||||
- 3D tensor with shape: ``(batch_size,filed_size*(filed_size-1)/2,embedding_size)``.
|
||||
"""
|
||||
def __init__(self, bilinear_type="interaction", seed=2021, **kwargs):
|
||||
super(BilinearInteraction, self).__init__(**kwargs)
|
||||
self.bilinear_type = bilinear_type
|
||||
self.seed = seed
|
||||
|
||||
def build(self, input_shape):
|
||||
# input_shape: [None, field_num, embed_num]
|
||||
self.field_size = input_shape[1]
|
||||
self.embedding_size = input_shape[-1]
|
||||
|
||||
if self.bilinear_type == "all": # 所有embedding矩阵共用一个矩阵W
|
||||
self.W = self.add_weight(shape=(self.embedding_size, self.embedding_size), initializer=glorot_normal(
|
||||
seed=self.seed), name="bilinear_weight")
|
||||
elif self.bilinear_type == "each": # 每个field共用一个矩阵W
|
||||
self.W_list = [self.add_weight(shape=(self.embedding_size, self.embedding_size), initializer=glorot_normal(
|
||||
seed=self.seed), name="bilinear_weight" + str(i)) for i in range(self.field_size-1)]
|
||||
elif self.bilinear_type == "interaction": # 每个交互用一个矩阵W
|
||||
self.W_list = [self.add_weight(shape=(self.embedding_size, self.embedding_size), initializer=glorot_normal(
|
||||
seed=self.seed), name="bilinear_weight" + str(i) + '_' + str(j)) for i, j in
|
||||
itertools.combinations(range(self.field_size), 2)]
|
||||
else:
|
||||
raise NotImplementedError
|
||||
|
||||
super(BilinearInteraction, self).build(input_shape) # Be sure to call this somewhere!
|
||||
|
||||
def call(self, inputs):
|
||||
# inputs: [None, field_nums, embed_dims]
|
||||
# 这里把inputs从field_nums处split, 划分成field_nums个embed_dims长向量的列表
|
||||
inputs = tf.split(inputs, self.field_size, axis=1) # [(None, embed_dims), (None, embed_dims), ..]
|
||||
n = len(inputs) # field_nums个
|
||||
|
||||
if self.bilinear_type == "all":
|
||||
# inputs[i] (none, embed_dims) self.W (embed_dims, embed_dims) -> (None, embed_dims)
|
||||
vidots = [tf.tensordot(inputs[i], self.W, axes=(-1, 0)) for i in range(n)] # 点积
|
||||
p = [tf.multiply(vidots[i], inputs[j]) for i, j in itertools.combinations(range(n), 2)] # 哈达玛积
|
||||
elif self.bilinear_type == "each":
|
||||
vidots = [tf.tensordot(inputs[i], self.W_list[i], axes=(-1, 0)) for i in range(n - 1)]
|
||||
# 假设3个域， 则两两组合[(0,1), (0,2), (1,2)] 这里的vidots是第一个维度， inputs是第二个维度 哈达玛积运算
|
||||
p = [tf.multiply(vidots[i], inputs[j]) for i, j in itertools.combinations(range(n), 2)]
|
||||
elif self.bilinear_type == "interaction":
|
||||
# combinations(inputs, 2) 这个得到的是两两向量交互的结果列表
|
||||
# 比如 combinations([[1,2], [3,4], [5,6]], 2)
|
||||
# 得到 [([1, 2], [3, 4]), ([1, 2], [5, 6]), ([3, 4], [5, 6])] (v[0], v[1]) 先v[0]与W点积，然后再和v[1]哈达玛积
|
||||
p = [tf.multiply(tf.tensordot(v[0], w, axes=(-1, 0)), v[1])
|
||||
for v, w in zip(itertools.combinations(inputs, 2), self.W_list)]
|
||||
else:
|
||||
raise NotImplementedError
|
||||
|
||||
output = Concatenate(axis=1)(p)
|
||||
return output
|
||||
```
|
||||
这里第一个是需要学习组合交互的具体实现方式， 人家的代码方式非常巧妙，第二个会是理解下。
|
||||
|
||||
关于FiBiNet网络的代码细节就到这里了，具体代码放到了我的GitHub链接上了。
|
||||
|
||||
## 总结
|
||||
这篇文章主要是整理了一个新模型， 这个模型是在特征重要性选择以及特征交互上做出了新的探索，给了我们两个新思路。 这里面还有两个重要的地方，感觉是作者对于SENET在推荐系统上的使用思考，也就是为啥能把这个东西迁过来，以及为啥双线性会更加细粒度，这种双线性函数的优势在哪儿？我们通常所说的知其然，意思是针对特征交互， 针对特征选择，我又有了两种考虑思路双线性和SENet， 而知其所以然，应该考虑为啥双线性或者SENET会有效呢？ 当然在文章中给出了自己的看法，当然这个可能不对哈，是自己对于问题的一种思考， 欢迎伙伴们一块讨论。
|
||||
|
||||
我现在读论文，一般读完了之后，会刻意逼着自己想这么几个问题：
|
||||
>本篇论文核心是讲了个啥东西？ 是为啥会提出这么个东西？ 为啥这个新东西会有效？ 与这个新东西类似的东西还有啥？ 在工业上通常会怎么用？
|
||||
|
||||
一般经过这样的灵魂5问就能把整篇论文拎起来了，而读完了这篇文章，你能根据这5问给出相应的答案吗？ 欢迎在下方留言呀。
|
||||
|
||||
还有一种读论文的厉害姿势，和张俊林老师学的，就是拉马努金式思维，就是读论文之前，看完题目之后， 不要看正文，先猜测作者在尝试解决什么样的问题，比如
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210703183445412.png#pic_center" alt="image-20210308142624189" style="zoom: 70%;" >
|
||||
</div>
|
||||
|
||||
看到特征重要性和双线性特征交互， 就大体上能猜测到这篇推荐论文讲的应该是和特征选择和特征交互相关的知识。 那么如果是我解决这两方面的话应该怎么解决呢？
|
||||
* 特征选择 --- 联想到Attention
|
||||
* 特征交互 --- 联想到哈达玛积或者内积
|
||||
|
||||
这时候， 就可以读论文了，读完之后， 对比下人家提出的想法和自己的想法的区别，考虑下为啥会有这样的区别？ 然后再就是上面的灵魂5问， 通过这样的方式读论文， 能够理解的更加深刻，就不会再有读完很多论文，依然很虚的感觉，啥也没记住了。 如果再能花点时间总结输出下， 和之前的论文做一个对比串联，再花点时间看看代码，复现下，用到自己的任务上。 那么这样， 就算是真正把握住模型背后的思想了，而不是仅仅会个模型而已， 并且这种读论文方式，只要习惯了之后， 读论文会很快，因为我隐约发现，万变不离其宗， 论文里面抛去实验部分，抛去前言部分， 剩下的精华其实没有几页的。当然整理会花费时间， 但也有相应的价值在里面。 我以后整理，也是以经典思路模型为主， 对于一般的，我会放到论文总结的专栏里面，一下子两三篇的那种整理，只整理大体思路就即可啦。
|
||||
|
||||
下面只整理来自工业大佬的使用经验和反思， 具体参考下面的第二篇参考:
|
||||
* 适用的数据集
|
||||
虽然模型是针对点击率预测的场景提出的，但可以尝试的数据场景也不少，比较适合包含大量categorical feature且这些feature cardinality本身很高，或者因为encode method导致的某些feature维度很高且稀疏的情况。推荐系统的场景因为大量的user/item属性都是符合这些要求的，所以效果格外好，但我们也可以举一反三把它推广到其他相似场景。另外，文字描述类的特征（比如人工标注的主观评价，名字，地址信息……）可以用tokenizer处理成int sequence/matrix作为embedding feature喂进模型，丰富的interaction方法可以很好的学习到这些样本中这些特征的相似之处并挖掘出一些潜在的关系。
|
||||
|
||||
* 回归和分类问题都可以做，无非改一下DNN最后一层的activation函数和objective，没有太大的差别。
|
||||
* 如果dense feature比较多而且是分布存在很多异常值的numeric feature，尽量就不要用FiBiNET了，相比大部分NN没有优势不说，SENET那里的一个最大池化极其容易把特征权重带偏，如果一定要上，可能需要修改一下池化的方法。
|
||||
|
||||
* DeepCTR的实现还把指定的linear feature作为类似于WDL中的wide部分直接输入到DNN的最后一层，以及DNN部分也吸收了一部分指定的dnn feature中的dense feature直接作为输入。毫无疑问，DeepCTR作者在尽可能的保留更多的特征作为输入防止信息的丢失。
|
||||
|
||||
|
||||
* 使用Field-Each方式能够达到最好的预测准确率，而且相比默认的Field-Interaction，参数也减少了不少，训练效率更高。当然，三种方式在准确率方面差异不是非常巨大。
|
||||
* reduce ratio设置到8效果最好，这方面我的经验和不少人达成了共识，SENET用于其他学习任务也可以得到相似的结论。 -- 这个试了下，确实有效果
|
||||
* 使用dropout方法扔掉hidden layer里的部分unit效果会更好，系数大约在0.3时最好，原文用的是0.5,请根据具体使用的网络结构和数据集特点自己调整。-- 这个有效果
|
||||
|
||||
* 在双线性部分引入Layer Norm效果可能会更好些
|
||||
|
||||
* 尝试在DNN部分使用残差防止DNN效果过差
|
||||
* 直接取出Bilinear的输出结果然后上XGBoost，也就是说不用它来训练而是作为一种特征embedding操作去使用， 这个方法可能发生leak
|
||||
* 在WDL上的调优经验： 适当调整DNN hideen layer之间的unit数量的减小比例，防止梯度爆炸/消失。
|
||||
|
||||
后记：
|
||||
>fibinet在我自己的任务上也试了下，确实会效果， 采用默认参数的话， 能和xdeepfm跑到同样的水平，而如果再稍微调调参， 就比xdeepfm要好些了。
|
||||
|
||||
**参考**：
|
||||
* [论文原文](https://arxiv.org/pdf/1905.09433.pdf)
|
||||
* [FiBiNET: paper reading + 实践调优经验](https://zhuanlan.zhihu.com/p/79659557)
|
||||
* [FiBiNET：结合特征重要性和双线性特征交互进行CTR预估](https://zhuanlan.zhihu.com/p/72931811)
|
||||
* [FiBiNET(新浪)](https://zhuanlan.zhihu.com/p/92130353)
|
||||
* [FiBiNet 网络介绍与源码浅析](https://zhuanlan.zhihu.com/p/343572144)
|
||||
* [SENET双塔模型及应用](https://mp.weixin.qq.com/s/Y3A8chyJ6ssh4WLJ8HNQqw)
|
||||
|
||||
|
||||
244
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.2/PNN.md
Normal file
244
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.2/PNN.md
Normal file
@@ -0,0 +1,244 @@
|
||||
# PNN
|
||||
## 动机
|
||||
在特征交叉的相关模型中FM, FFM都证明了特征交叉的重要性，FNN将神经网络的高阶隐式交叉加到了FM的二阶特征交叉上，一定程度上说明了DNN做特征交叉的有效性。但是对于DNN这种“add”操作的特征交叉并不能充分挖掘类别特征的交叉效果。PNN虽然也用了DNN来对特征进行交叉组合，但是并不是直接将低阶特征放入DNN中，而是设计了Product层先对低阶特征进行充分的交叉组合之后再送入到DNN中去。
|
||||
|
||||
PNN模型其实是对IPNN和OPNN的总称，两者分别对应的是不同的Product实现方法，前者采用的是inner product，后者采用的是outer product。在PNN的算法方面，比较重要的部分就是Product Layer的简化实现方法，需要在数学和代码上都能够比较深入的理解。
|
||||
|
||||
## 模型的结构及原理
|
||||
|
||||
> 在学习PNN模型之前，应当对于DNN结构具有一定的了解，同时已经学习过了前面的章节。
|
||||
|
||||
PNN模型的整体架构如下图所示：
|
||||
|
||||
<div align=center> <img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20210308142624189.png" alt="image-20210308142624189" style="zoom: 50%;" /> </div>
|
||||
|
||||
一共分为五层，其中除了Product Layer别的layer都是比较常规的处理方法，均可以从前面的章节进一步了解。模型中最重要的部分就是通过Product层对embedding特征进行交叉组合，也就是上图中红框所显示的部分。
|
||||
|
||||
Product层主要有线性部分和非线性部分组成，分别用$l_z$和$l_p$来表示，
|
||||
|
||||
<div align=center> <img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20210308143101261.png" alt="image-20210308143101261" style="zoom: 50%;" />
|
||||
</div>
|
||||
|
||||
1. 线性模块，一阶特征(未经过显示特征交叉处理)，对应论文中的$l_z=(l_z^1,l_z^2, ..., l_z^{D_1})$
|
||||
2. 非线性模块，高阶特征(经过显示特征交叉处理)，对应论文中的$l_p=(l_p^1,l_p^2, ..., l_p^{D_1})$
|
||||
|
||||
**线性部分**
|
||||
|
||||
先来解释一下$l_z$是如何计算得到的，在介绍计算$l_z$之前先介绍一下矩阵内积计算, 如下公式所示，用一句话来描述就是两个矩阵对应元素相称，然后将相乘之后的所有元素相加
|
||||
$$
|
||||
A \odot{B} = \sum_{i,j}A_{i,j}B_{i,j}
|
||||
$$
|
||||
$l_z^n$的计算就是矩阵内积，而$l_z$是有$D_1$个$l_z^n$组成，所以需要$D1$个矩阵求得，但是在代码实现的时候不一定是定义$D_1$个矩阵，可以将这些矩阵Flatten，具体的细节可以参考给出的代码。
|
||||
$$
|
||||
l_z=(l_z^1,l_z^2, ..., l_z^{D_1})\\
|
||||
l_z^n = W_z^n \odot{z} \\
|
||||
z = (z_1, z_2, ..., z_N)
|
||||
$$
|
||||
总之这一波操作就是将所有的embedding向量中的所有元素都乘以一个矩阵的对应元素，最后相加即可，这一部分比较简单(N表示的是特征的数量，M表示的是所有特征转化为embedding之后维度，也就是N*emb_dim)
|
||||
$$
|
||||
l_z^n = W_z^n \odot{z} = \sum_{i=1}^N \sum_{j=1}^M (W_z^n)_{i,j}z_{i,j}
|
||||
$$
|
||||
|
||||
### Product Layer
|
||||
**非线性部分**
|
||||
|
||||
上面介绍了线性部分$l_p$的计算，非线性部分的计算相比线性部分要复杂很多，先从整体上看$l_p$的计算
|
||||
$$
|
||||
l_p=(l_p^1,l_p^2, ..., l_p^{D_1}) \\
|
||||
l_p^n = W_p^n \odot{p} \\
|
||||
p = \{p_{i,j}\}, i=1,2,...,N,j=1,2,...,N
|
||||
$$
|
||||
从上述公式中可以发现，$l_p^n$和$l_z^n$类似需要$D_1$个$W_p^n$矩阵计算内积得到，重点就是如何求这个$p$，这里作者提出了两种方式，一种是使用内积计算，另一种是使用外积计算。
|
||||
|
||||
#### IPNN
|
||||
|
||||
使用内积实现特征交叉就和FM是类似的(两两向量计算内积)，下面将向量内积操作表示如下表达式
|
||||
$$
|
||||
g(f_i,f_j) = <f_i, f_j>
|
||||
$$
|
||||
将内积的表达式带入$l_p^n$的计算表达式中有：
|
||||
$$
|
||||
\begin{aligned}
|
||||
|
||||
l_p^n &= W_p^n \odot{p} \\
|
||||
&= \sum_{i=1}^N \sum_{j=1}^N (W_p^n)_{i,j}p_{i,j} \\
|
||||
&= \sum_{i=1}^N \sum_{j=1}^N (W_p^n)_{i,j}<f_i, f_j>
|
||||
|
||||
\end{aligned}
|
||||
$$
|
||||
上面就提到了这里使用的内积是计算两两特征之间的内积，然而向量a和向量b的内积与向量b和向量a的内积是相同的，其实是没必要计算的，看一下下面FM的计算公式：
|
||||
$$
|
||||
\hat{y}(X) = \omega_{0}+\sum_{i=1}^{n}{\omega_{i}x_{i}}+\sum_{i=1}^{n}{\sum_{j=i+1}^{n} <v_{i},v_{j}>x_{i}x_{j}}
|
||||
$$
|
||||
也就是说计算的内积矩阵$p$是对称的，那么与其对应元素做矩阵内积的矩阵$W_p^n$也是对称的，对于可学习的权重来说如果是对称的是不是可以只使用其中的一半就行了呢，所以基于这个思考，对Inner Product的权重定义及内积计算进行优化，首先将权重矩阵分解$W_p^n=\theta^n \theta^{nT}$,此时$\theta^n \in R^N$（参数从原来的$N^2$变成了$N$）,将分解后的$W_p^n$带入$l_p^n$的计算公式有：
|
||||
$$
|
||||
\begin{aligned}
|
||||
|
||||
l_p^n &= W_p^n \odot{p} \\
|
||||
&= \sum_{i=1}^N \sum_{j=1}^N (W_p^n)_{i,j}p_{i,j} \\
|
||||
&= \sum_{i=1}^N \sum_{j=1}^N \theta^n \theta^n <f_i, f_j> \\
|
||||
&= \sum_{i=1}^N \sum_{j=1}^N <\theta^n f_i, \theta^n f_j> \\
|
||||
&= <\sum_{i=1}^N \theta^n f_i, \sum_{j=1}^N \theta^n f_j> \\
|
||||
&= ||\sum_{i=1}^N \theta^n f_i||^2
|
||||
\end{aligned}
|
||||
$$
|
||||
所以优化后的$l_p$的计算公式为：
|
||||
$$
|
||||
l_p = (||\sum_{i=1}^N \theta^1 f_i||^2, ||\sum_{i=1}^N \theta^2 f_i||^2, ..., ||\sum_{i=1}^N \theta^{D_1} f_i||^2)
|
||||
$$
|
||||
这里为了好理解不做过多的解释，其实这里对于矩阵分解省略了一些细节，感兴趣的可以去看原文，最后模型实现的时候就是基于上面的这个公式计算的（给出的代码也是基于优化之后的实现）。
|
||||
|
||||
#### OPNN
|
||||
|
||||
使用外积实现相比于使用内积实现，唯一的区别就是使用向量的外积来计算矩阵$p$,首先定义向量的外积计算
|
||||
$$
|
||||
g(i,j) = f_i f_j^T
|
||||
$$
|
||||
从外积公式可以发现两个向量的外积得到的是一个矩阵，与上面介绍的内积计算不太相同，内积得到的是一个数值。内积实现的Product层是将计算得到的内积矩阵，乘以一个与其大小一样的权重矩阵，然后求和，按照这个思路的话，通过外积得到的$p$计算$W_p^n \odot{p}$相当于之前的内积值乘以权重矩阵对应位置的值求和就变成了，外积矩阵乘以权重矩阵中对应位置的子矩阵然后将整个相乘得到的大矩阵对应元素相加，用公式表示如下：
|
||||
$$
|
||||
\begin{aligned}
|
||||
l_p^n &= W_p^n \odot{p} \\
|
||||
&= \sum_{i=1}^N \sum_{j=1}^N (W_p^n)_{i,j}p_{i,j} \\
|
||||
&= \sum_{i=1}^N \sum_{j=1}^N (W_p^n)_{i,j} f_i f_j^T
|
||||
\end{aligned}
|
||||
$$
|
||||
需要注意的是此时的$(W_p^n)_{i,j}$表示的是一个矩阵，而不是一个值，此时计算$l_p$的复杂度是$O(D_1*N^2*M^2)$, 其中$N^2$表示的是特征的组合数量，$M^2$表示的是计算外积的复杂度。这样的复杂度肯定是无法接受的，所以为了优化复杂度，PNN的作者重新定义了$p$的计算方式：
|
||||
$$
|
||||
p=\sum_{i=1}^{N} \sum_{j=1}^{N} f_{i} f_{j}^{T}=f_{\Sigma}\left(f_{\Sigma}\right)^{T} \\
|
||||
f_{\Sigma}=\sum_{i=1}^{N} f_{i}
|
||||
$$
|
||||
需要注意，这里新定义的外积计算与传统的外积计算时不等价的，这里是为了优化计算效率重新定义的计算方式，从公式中可以看出，相当于先将原来的embedding向量在特征维度上先求和，变成一个向量之后再计算外积。加入原embedding向量表示为$E \in R^{N\times M}$，其中$N$表示特征的数量，M表示的是所有特征的总维度，即$N*emb\_dim$, 在特征维度上进行求和就是将$E \in R^{N\times M}$矩阵压缩成了$E \in R^M$, 然后两个$M$维的向量计算外积得到最终所有特征的外积交叉结果$p\in R^{M\times M}$，最终的$l_p^n$可以表示为：
|
||||
$$
|
||||
l_p^n = W_p^n \odot{p} = \sum_{i=1}^N \sum_{j=1}^N (W_p^n)_{i,j}p_{i,j} \\
|
||||
$$
|
||||
最终的计算方式和$l_z$的计算方式看起来差不多，但是需要注意外积优化后的$W_p^n$的维度是$R^{M \times M}$的，$M$表示的是特征矩阵的维度，即$N*emb\_dim$。
|
||||
|
||||
> 虽然叠加概念的引入可以降低计算开销，但是中间的精度损失也是很大的，性能与精度之间的tradeoff
|
||||
|
||||
## 代码实现
|
||||
|
||||
代码实现的整体逻辑比较简单，就是对类别特征进行embedding编码，然后通过embedding特征计算$l_z,l_p$, 接着将$l_z, l_p$的输出concat到一起输入到DNN中得到最终的预测结果
|
||||
|
||||
```python
|
||||
def PNN(dnn_feature_columns, inner=True, outer=True):
|
||||
# 构建输入层，即所有特征对应的Input()层，这里使用字典的形式返回，方便后续构建模型
|
||||
_, sparse_input_dict = build_input_layers(dnn_feature_columns)
|
||||
|
||||
# 构建模型的输入层，模型的输入层不能是字典的形式，应该将字典的形式转换成列表的形式
|
||||
# 注意：这里实际的输入与Input()层的对应，是通过模型输入时候的字典数据的key与对应name的Input层
|
||||
input_layers = list(sparse_input_dict.values())
|
||||
|
||||
# 构建维度为k的embedding层，这里使用字典的形式返回，方便后面搭建模型
|
||||
embedding_layer_dict = build_embedding_layers(dnn_feature_columns, sparse_input_dict, is_linear=False)
|
||||
|
||||
sparse_embed_list = concat_embedding_list(dnn_feature_columns, sparse_input_dict, embedding_layer_dict, flatten=False)
|
||||
|
||||
dnn_inputs = ProductLayer(units=32, use_inner=True, use_outer=True)(sparse_embed_list)
|
||||
|
||||
# 输入到dnn中，需要提前定义需要几个残差块
|
||||
output_layer = get_dnn_logits(dnn_inputs)
|
||||
|
||||
model = Model(input_layers, output_layer)
|
||||
return model
|
||||
```
|
||||
|
||||
PNN的难点就是Product层的实现，下面是Product 层实现的代码，代码中是使用优化之后$l_p$的计算方式编写的, 代码中有详细的注释，但是要完全理解代码还需要去理解上述说过的优化思路。
|
||||
|
||||
```python
|
||||
class ProductLayer(Layer):
|
||||
def __init__(self, units, use_inner=True, use_outer=False):
|
||||
super(ProductLayer, self).__init__()
|
||||
self.use_inner = use_inner
|
||||
self.use_outer = use_outer
|
||||
self.units = units # 指的是原文中D1的大小
|
||||
|
||||
def build(self, input_shape):
|
||||
# 需要注意input_shape也是一个列表，并且里面的每一个元素都是TensorShape类型，
|
||||
# 需要将其转换成list然后才能参与数值计算，不然类型容易错
|
||||
# input_shape[0] : feat_nums x embed_dims
|
||||
self.feat_nums = len(input_shape)
|
||||
self.embed_dims = input_shape[0].as_list()[-1]
|
||||
flatten_dims = self.feat_nums * self.embed_dims
|
||||
|
||||
# Linear signals weight, 这部分是用于产生Z的权重，因为这里需要计算的是两个元素对应元素乘积然后再相加
|
||||
# 等价于先把矩阵拉成一维，然后相乘再相加
|
||||
self.linear_w = self.add_weight(name='linear_w', shape=(flatten_dims, self.units), initializer='glorot_normal')
|
||||
|
||||
# inner product weight
|
||||
if self.use_inner:
|
||||
# 优化之后的内积权重是未优化时的一个分解矩阵，未优化时的矩阵大小为：D x N x N
|
||||
# 优化后的内积权重大小为：D x N
|
||||
self.inner_w = self.add_weight(name='inner_w', shape=(self.units, self.feat_nums), initializer='glorot_normal')
|
||||
|
||||
if self.use_outer:
|
||||
# 优化之后的外积权重大小为：D x embed_dim x embed_dim, 因为计算外积的时候在特征维度通过求和的方式进行了压缩
|
||||
self.outer_w = self.add_weight(name='outer_w', shape=(self.units, self.embed_dims, self.embed_dims), initializer='glorot_normal')
|
||||
|
||||
|
||||
def call(self, inputs):
|
||||
# inputs是一个列表
|
||||
# 先将所有的embedding拼接起来计算线性信号部分的输出
|
||||
concat_embed = Concatenate(axis=1)(inputs) # B x feat_nums x embed_dims
|
||||
# 将两个矩阵都拉成二维的，然后通过矩阵相乘得到最终的结果
|
||||
concat_embed_ = tf.reshape(concat_embed, shape=[-1, self.feat_nums * self.embed_dims])
|
||||
lz = tf.matmul(concat_embed_, self.linear_w) # B x units
|
||||
|
||||
# inner
|
||||
lp_list = []
|
||||
if self.use_inner:
|
||||
for i in range(self.units):
|
||||
# 相当于给每一个特征向量都乘以一个权重
|
||||
# self.inner_w[i] : (embed_dims, ) 添加一个维度变成 (embed_dims, 1)
|
||||
# concat_embed: B x feat_nums x embed_dims; delta = B x feat_nums x embed_dims
|
||||
delta = tf.multiply(concat_embed, tf.expand_dims(self.inner_w[i], axis=1))
|
||||
# 在特征之间的维度上求和
|
||||
delta = tf.reduce_sum(delta, axis=1) # B x embed_dims
|
||||
# 最终在特征embedding维度上求二范数得到p
|
||||
lp_list.append(tf.reduce_sum(tf.square(delta), axis=1, keepdims=True)) # B x 1
|
||||
|
||||
# outer
|
||||
if self.use_outer:
|
||||
# 外积的优化是将embedding矩阵，在特征间的维度上通过求和进行压缩
|
||||
feat_sum = tf.reduce_sum(concat_embed, axis=1) # B x embed_dims
|
||||
|
||||
# 为了方便计算外积，将维度进行扩展
|
||||
f1 = tf.expand_dims(feat_sum, axis=2) # B x embed_dims x 1
|
||||
f2 = tf.expand_dims(feat_sum, axis=1) # B x 1 x embed_dims
|
||||
|
||||
# 求外积, a * a^T
|
||||
product = tf.matmul(f1, f2) # B x embed_dims x embed_dims
|
||||
|
||||
# 将product与外积权重矩阵对应元素相乘再相加
|
||||
for i in range(self.units):
|
||||
lpi = tf.multiply(product, self.outer_w[i]) # B x embed_dims x embed_dims
|
||||
# 将后面两个维度进行求和，需要注意的是，每使用一次reduce_sum就会减少一个维度
|
||||
lpi = tf.reduce_sum(lpi, axis=[1, 2]) # B
|
||||
# 添加一个维度便于特征拼接
|
||||
lpi = tf.expand_dims(lpi, axis=1) # B x 1
|
||||
lp_list.append(lpi)
|
||||
|
||||
# 将所有交叉特征拼接到一起
|
||||
lp = Concatenate(axis=1)(lp_list)
|
||||
|
||||
# 将lz和lp拼接到一起
|
||||
product_out = Concatenate(axis=1)([lz, lp])
|
||||
|
||||
return product_out
|
||||
```
|
||||
|
||||
因为这个模型的整体实现框架比较简单，就不画实现的草图了，直接看模型搭建的函数即可，对于PNN重点需要理解Product的两种类型及不同的优化方式。
|
||||
|
||||
下面是一个通过keras画的模型结构图，为了更好的显示，类别特征都只是选择了一小部分，画图的代码也在github中。
|
||||
|
||||
<div align=center> <img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片PNN.png" alt="image-20210308143101261" style="zoom: 50%;" />
|
||||
</div>
|
||||
|
||||
## 思考题
|
||||
|
||||
1. 降低复杂度的具体策略与具体的product函数选择有关，IPNN其实通过矩阵分解，“跳过”了显式的product层，而OPNN则是直接在product层入手进行优化。看原文去理解优化的动机及细节。
|
||||
|
||||
|
||||
**参考文献**
|
||||
- [PNN原文论文](https://arxiv.org/pdf/1611.00144.pdf)
|
||||
- [推荐系统系列（四）：PNN理论与实践](https://zhuanlan.zhihu.com/p/89850560)
|
||||
- [deepctr](https://github.com/shenweichen/DeepCTR)
|
||||
127
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.3/AFM.md
Normal file
127
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.3/AFM.md
Normal file
@@ -0,0 +1,127 @@
|
||||
# AFM
|
||||
## AFM提出的动机
|
||||
|
||||
AFM的全称是Attentional Factorization Machines, 从模型的名称上来看是在FM的基础上加上了注意力机制，FM是通过特征隐向量的内积来对交叉特征进行建模，从公式中可以看出所有的交叉特征都具有相同的权重也就是1，没有考虑到不同的交叉特征的重要性程度：
|
||||
$$
|
||||
y_{fm} = w_0+\sum_{i=1}^nw_ix_i+\sum_{i=1}^{n}\sum_{i+1}^n\lt v_i,v_j\gt x_ix_j
|
||||
$$
|
||||
如何让不同的交叉特征具有不同的重要性就是AFM核心的贡献，在谈论AFM交叉特征注意力之前，对于FM交叉特征部分的改进还有FFM，其是考虑到了对于不同的其他特征，某个指定特征的隐向量应该是不同的（相比于FM对于所有的特征只有一个隐向量，FFM对于一个特征有多个不同的隐向量）。
|
||||
|
||||
## AFM模型原理
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20210131092744905.png" alt="image-20210131092744905" style="zoom: 50%;" />
|
||||
</div>
|
||||
上图表示的就是AFM交叉特征部分的模型结构(非交叉部分与FM是一样的，图中并没有给出)。AFM最核心的两个点分别是Pair-wise Interaction Layer和Attention-based Pooling。前者将输入的非零特征的隐向量两两计算element-wise product(哈达玛积，两个向量对应元素相乘，得到的还是一个向量)，假如输入的特征中的非零向量的数量为m，那么经过Pair-wise Interaction Layer之后输出的就是$\frac{m(m-1)}{2}$个向量，再将前面得到的交叉特征向量组输入到Attention-based Pooling，该pooling层会先计算出每个特征组合的自适应权重(通过Attention Net进行计算)，通过加权求和的方式将向量组压缩成一个向量，由于最终需要输出的是一个数值，所以还需要将前一步得到的向量通过另外一个向量将其映射成一个值，得到最终的基于注意力加权的二阶交叉特征的输出。(对于这部分如果不是很清楚，可以先看下面对两个核心层的介绍)
|
||||
|
||||
### Pair-wise Interaction Layer
|
||||
|
||||
FM二阶交叉项：所有非零特征对应的隐向量两两点积再求和，输出的是一个数值
|
||||
$$
|
||||
\sum_{i=1}^{n}\sum_{i+1}^n\lt v_i,v_j\gt x_ix_j
|
||||
$$
|
||||
AFM二阶交叉项(无attention)：所有非零特征对应的隐向量两两对应元素乘积，然后再向量求和，输出的还是一个向量。
|
||||
$$
|
||||
\sum_{i=1}^{n}\sum_{i+1}^n (v_i \odot v_j) x_ix_j
|
||||
$$
|
||||
上述写法是为了更好的与FM进行对比，下面将公式变形方便与原论文中保持一致。首先是特征的隐向量。从上图中可以看出，作者对数值特征也对应了一个隐向量，不同的数值乘以对应的隐向量就可以得到不同的隐向量，相对于onehot编码的特征乘以1还是其本身(并没有什么变化)，其实就是为了将公式进行统一。虽然论文中给出了对数值特征定义隐向量，但是在作者的代码中并没有发现有对数值特征进行embedding的过程([原论文代码链接](https://github.com/hexiangnan/attentional_factorization_machine/blob/master/code/AFM.py)）具体原因不详。
|
||||
|
||||
按照论文的意思，特征的embedding可以表示为：$\varepsilon = {v_ix_i}$，经过Pair-wise Interaction Layer输出可得：
|
||||
$$
|
||||
f_{PI}(\varepsilon)=\{(v_i \odot v_j) x_ix_j\}_{i,j \in R_x}
|
||||
$$
|
||||
$R_x$表示的是有效特征集合。此时的$f_{PI}(\varepsilon)$表示的是一个向量集合，所以需要先将这些向量集合聚合成一个向量，然后在转换成一个数值：
|
||||
$$
|
||||
\hat{y} = p^T \sum_{(i,j)\in R_x}(v_i \odot v_j) x_ix_j + b
|
||||
$$
|
||||
上式中的求和部分就是将向量集合聚合成一个维度与隐向量维度相同的向量，通过向量$p$再将其转换成一个数值，b表示的是偏置。
|
||||
|
||||
从开始介绍Pair-wise Interaction Layer到现在解决的一个问题是，如何将使用哈达玛积得到的交叉特征转换成一个最终输出需要的数值，到目前为止交叉特征之间的注意力权重还没有出现。在没有详细介绍注意力之前先感性的认识一下如果现在已经有了每个交叉特征的注意力权重，那么交叉特征的输出可以表示为：
|
||||
$$
|
||||
\hat{y} = p^T \sum_{(i,j)\in R_x}\alpha_{ij}(v_i \odot v_j) x_ix_j + b
|
||||
$$
|
||||
就是在交叉特征得到的新向量前面乘以一个注意力权重$\alpha_{ij}$, 那么这个注意力权重如何计算得到呢？
|
||||
|
||||
### Attention-based Pooling
|
||||
|
||||
对于神经网络注意力相关的基础知识大家可以去看一下邱锡鹏老师的《神经网络与深度学习》第8章注意力机制与外部记忆。这里简单的叙述一下使用MLP实现注意力机制的计算。假设现在有n个交叉特征(假如维度是k)，将nxk的数据输入到一个kx1的全连接网络中，输出的张量维度为nx1，使用softmax函数将nx1的向量的每个维度进行归一化，得到一个新的nx1的向量，这个向量所有维度加起来的和为1，每个维度上的值就可以表示原nxk数据每一行(即1xk的数据)的权重。用公式表示为：
|
||||
$$
|
||||
\alpha_{ij}' = h^T ReLU(W(v_i \odot v_j)x_ix_j + b)
|
||||
$$
|
||||
使用softmax归一化可得：
|
||||
$$
|
||||
\alpha_{ij} = \frac{exp(\alpha_{ij}')}{\sum_{(i,j)\in R_x}exp(\alpha_{ij}')}
|
||||
$$
|
||||
这样就得到了AFM二阶交叉部分的注意力权重，如果将AFM的一阶项写在一起，AFM模型用公式表示为：
|
||||
$$
|
||||
\hat{y}_{afm}(x) = w_0+\sum_{i=1}^nw_ix_i+p^T \sum_{(i,j)\in R_x}\alpha_{ij}(v_i \odot v_j) x_ix_j + b
|
||||
$$
|
||||
### AFM模型训练
|
||||
|
||||
AFM从最终的模型公式可以看出与FM的模型公式是非常相似的，所以也可以和FM一样应用于不同的任务，例如分类、回归及排序（不同的任务的损失函数是不一样的），AFM也有对防止过拟合进行处理：
|
||||
|
||||
1. 在Pair-wise Interaction Layer层的输出结果上使用dropout防止过拟合，因为并不是所有的特征组合对预测结果都有用，所以随机的去除一些交叉特征，让剩下的特征去自适应的学习可以更好的防止过拟合。
|
||||
2. 对Attention-based Pooling层中的权重矩阵$W$使用L2正则，作者没有在这一层使用dropout的原因是发现同时在特征交叉层和注意力层加dropout会使得模型训练不稳定，并且性能还会下降。
|
||||
|
||||
加上正则参数之后的回归任务的损失函数表示为：
|
||||
$$
|
||||
L = \sum_{x\in T} (\hat{y}_{afm}(x) - y(x))^2 + \lambda ||W||^2
|
||||
$$
|
||||
## AFM代码实现
|
||||
|
||||
1. linear part: 这部分是有关于线性计算，也就是FM的前半部分$w1x1+w2x2...wnxn+b$的计算。对于这一块的计算，我们用了一个get_linear_logits函数实现，后面再说，总之通过这个函数，我们就可以实现上面这个公式的计算过程，得到linear的输出
|
||||
2. dnn part: 这部分是后面交叉特征的那部分计算，这一部分需要使用注意力机制来将所有类别特征的embedding计算注意力权重，然后通过加权求和的方式将所有交叉之后的特征池化成一个向量，最终通过一个映射矩阵$p$将向量转化成一个logits值
|
||||
3. 最终将linear部分与dnn部分相加之后，通过sigmoid激活得到最终的输出
|
||||
|
||||
```python
|
||||
def AFM(linear_feature_columns, dnn_feature_columns):
|
||||
# 构建输入层，即所有特征对应的Input()层，这里使用字典的形式返回，方便后续构建模型
|
||||
dense_input_dict, sparse_input_dict = build_input_layers(linear_feature_columns + dnn_feature_columns)
|
||||
|
||||
# 将linear部分的特征中sparse特征筛选出来，后面用来做1维的embedding
|
||||
linear_sparse_feature_columns = list(filter(lambda x: isinstance(x, SparseFeat), linear_feature_columns))
|
||||
|
||||
# 构建模型的输入层，模型的输入层不能是字典的形式，应该将字典的形式转换成列表的形式
|
||||
# 注意：这里实际的输入与Input()层的对应，是通过模型输入时候的字典数据的key与对应name的Input层
|
||||
input_layers = list(dense_input_dict.values()) + list(sparse_input_dict.values())
|
||||
|
||||
# linear_logits由两部分组成，分别是dense特征的logits和sparse特征的logits
|
||||
linear_logits = get_linear_logits(dense_input_dict, sparse_input_dict, linear_sparse_feature_columns)
|
||||
|
||||
# 构建维度为k的embedding层，这里使用字典的形式返回，方便后面搭建模型
|
||||
# embedding层用户构建FM交叉部分和DNN的输入部分
|
||||
embedding_layers = build_embedding_layers(dnn_feature_columns, sparse_input_dict, is_linear=False)
|
||||
|
||||
# 将输入到dnn中的sparse特征筛选出来
|
||||
att_sparse_feature_columns = list(filter(lambda x: isinstance(x, SparseFeat), dnn_feature_columns))
|
||||
|
||||
att_logits = get_attention_logits(sparse_input_dict, att_sparse_feature_columns, embedding_layers) # B x (n(n-1)/2)
|
||||
|
||||
# 将linear,dnn的logits相加作为最终的logits
|
||||
output_logits = Add()([linear_logits, att_logits])
|
||||
|
||||
# 这里的激活函数使用sigmoid
|
||||
output_layers = Activation("sigmoid")(output_logits)
|
||||
|
||||
model = Model(input_layers, output_layers)
|
||||
return model
|
||||
```
|
||||
|
||||
关于每一块的细节，这里就不解释了，在我们给出的GitHub代码中，我们已经加了非常详细的注释，大家看那个应该很容易看明白， 为了方便大家的阅读，我们这里还给大家画了一个整体的模型架构图，帮助大家更好的了解每一块以及前向传播（画的图不是很规范，先将就看一下，后面我们会统一在优化一下这个手工图）。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20210307200304199.png" alt="image-20210307200304199" style="zoom:67%;" />
|
||||
</div>
|
||||
|
||||
下面是一个通过keras画的模型结构图，为了更好的显示，数值特征和类别特征都只是选择了一小部分，画图的代码也在github中。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片AFM.png" alt="image-20210307200304199" style="zoom:67%;" />
|
||||
</div>
|
||||
|
||||
## 思考
|
||||
1. AFM与NFM优缺点对比。
|
||||
|
||||
|
||||
**参考资料**
|
||||
[原论文](https://www.ijcai.org/Proceedings/2017/0435.pdf)
|
||||
[deepctr](https://github.com/shenweichen/DeepCTR)
|
||||
156
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.3/DeepFM.md
Normal file
156
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.3/DeepFM.md
Normal file
@@ -0,0 +1,156 @@
|
||||
# DeepFM
|
||||
## 动机
|
||||
对于CTR问题，被证明的最有效的提升任务表现的策略是特征组合(Feature Interaction), 在CTR问题的探究历史上来看就是如何更好地学习特征组合，进而更加精确地描述数据的特点。可以说这是基础推荐模型到深度学习推荐模型遵循的一个主要的思想。而组合特征大牛们研究过组合二阶特征，三阶甚至更高阶，但是面临一个问题就是随着阶数的提升，复杂度就成几何倍的升高。这样即使模型的表现更好了，但是推荐系统在实时性的要求也不能满足了。所以很多模型的出现都是为了解决另外一个更加深入的问题：如何更高效的学习特征组合？
|
||||
|
||||
为了解决上述问题，出现了FM和FFM来优化LR的特征组合较差这一个问题。并且在这个时候科学家们已经发现了DNN在特征组合方面的优势，所以又出现了FNN和PNN等使用深度网络的模型。但是DNN也存在局限性。
|
||||
|
||||
- **DNN局限**
|
||||
当我们使用DNN网络解决推荐问题的时候存在网络参数过于庞大的问题，这是因为在进行特征处理的时候我们需要使用one-hot编码来处理离散特征，这会导致输入的维度猛增。这里借用AI大会的一张图片：
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片2021-02-22-10-11-15.png" style="zoom: 50%;" />
|
||||
</div>
|
||||
|
||||
这样庞大的参数量也是不实际的。为了解决DNN参数量过大的局限性，可以采用非常经典的Field思想，将OneHot特征转换为Dense Vector
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片2021-02-22-10-11-40.png" style="zoom: 50%;" />
|
||||
</div>
|
||||
|
||||
此时通过增加全连接层就可以实现高阶的特征组合，如下图所示：
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片2021-02-22-10-11-59.png" style="zoom:67%;" />
|
||||
</div>
|
||||
但是仍然缺少低阶的特征组合，于是增加FM来表示低阶的特征组合。
|
||||
|
||||
- **FNN和PNN**
|
||||
结合FM和DNN其实有两种方式，可以并行结合也可以串行结合。这两种方式各有几种代表模型。在DeepFM之前有FNN，虽然在影响力上可能并不如DeepFM，但是了解FNN的思想对我们理解DeepFM的特点和优点是很有帮助的。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片2021-02-22-10-12-19.png" style="zoom:50%;" />
|
||||
</div>
|
||||
|
||||
FNN是使用预训练好的FM模块，得到隐向量，然后把隐向量作为DNN的输入，但是经过实验进一步发现，在Embedding layer和hidden layer1之间增加一个product层（如上图所示）可以提高模型的表现，所以提出了PNN，使用product layer替换FM预训练层。
|
||||
|
||||
- **Wide&Deep**
|
||||
FNN和PNN模型仍然有一个比较明显的尚未解决的缺点：对于低阶组合特征学习到的比较少，这一点主要是由于FM和DNN的串行方式导致的，也就是虽然FM学到了低阶特征组合，但是DNN的全连接结构导致低阶特征并不能在DNN的输出端较好的表现。看来我们已经找到问题了，将串行方式改进为并行方式能比较好的解决这个问题。于是Google提出了Wide&Deep模型（将前几章），但是如果深入探究Wide&Deep的构成方式，虽然将整个模型的结构调整为了并行结构，在实际的使用中Wide Module中的部分需要较为精巧的特征工程，换句话说人工处理对于模型的效果具有比较大的影响（这一点可以在Wide&Deep模型部分得到验证）。
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/Javaimage-20200910214310877.png" alt="image-20200910214310877" style="zoom:65%;" />
|
||||
</div>
|
||||
如上图所示，该模型仍然存在问题：**在output Units阶段直接将低阶和高阶特征进行组合，很容易让模型最终偏向学习到低阶或者高阶的特征，而不能做到很好的结合。**
|
||||
|
||||
综上所示，DeepFM模型横空出世。
|
||||
|
||||
## 模型的结构与原理
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20210225180556628.png" alt="image-20210225180556628" style="zoom:50%;" />
|
||||
</div>
|
||||
|
||||
前面的Field和Embedding处理是和前面的方法是相同的，如上图中的绿色部分；DeepFM将Wide部分替换为了FM layer如上图中的蓝色部分
|
||||
|
||||
这幅图其实有很多的点需要注意，很多人都一眼略过了，这里我个人认为在DeepFM模型中有三点需要注意：
|
||||
|
||||
- **Deep模型部分**
|
||||
- **FM模型部分**
|
||||
- **Sparse Feature中黄色和灰色节点代表什么意思**
|
||||
|
||||
### FM
|
||||
详细内容参考FM模型部分的内容，下图是FM的一个结构图，从图中大致可以看出FM Layer是由一阶特征和二阶特征Concatenate到一起在经过一个Sigmoid得到logits（结合FM的公式一起看），所以在实现的时候需要单独考虑linear部分和FM交叉特征部分。
|
||||
$$
|
||||
\hat{y}_{FM}(x) = w_0+\sum_{i=1}^N w_ix_i + \sum_{i=1}^N \sum_{j=i+1}^N v_i^T v_j x_ix_j
|
||||
$$
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20210225181340313.png" alt="image-20210225181340313" style="zoom: 67%;" />
|
||||
</div>
|
||||
### Deep
|
||||
Deep架构图
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20210225181010107.png" alt="image-20210225181010107" style="zoom:50%;" />
|
||||
</div>
|
||||
Deep Module是为了学习高阶的特征组合，在上图中使用用全连接的方式将Dense Embedding输入到Hidden Layer，这里面Dense Embeddings就是为了解决DNN中的参数爆炸问题，这也是推荐模型中常用的处理方法。
|
||||
|
||||
Embedding层的输出是将所有id类特征对应的embedding向量concat到到一起输入到DNN中。其中$v_i$表示第i个field的embedding，m是field的数量。
|
||||
$$
|
||||
z_1=[v_1, v_2, ..., v_m]
|
||||
$$
|
||||
上一层的输出作为下一层的输入，我们得到：
|
||||
$$
|
||||
z_L=\sigma(W_{L-1} z_{L-1}+b_{L-1})
|
||||
$$
|
||||
其中$\sigma$表示激活函数，$z, W, b $分别表示该层的输入、权重和偏置。
|
||||
|
||||
最后进入DNN部分输出使用sigmod激活函数进行激活：
|
||||
$$
|
||||
y_{DNN}=\sigma(W^{L}a^L+b^L)
|
||||
$$
|
||||
|
||||
|
||||
## 代码实现
|
||||
DeepFM在模型的结构图中显示，模型大致由两部分组成，一部分是FM，还有一部分就是DNN, 而FM又由一阶特征部分与二阶特征交叉部分组成，所以可以将整个模型拆成三部分，分别是一阶特征处理linear部分，二阶特征交叉FM以及DNN的高阶特征交叉。在下面的代码中也能够清晰的看到这个结构。此外每一部分可能由是由不同的特征组成，所以在构建模型的时候需要分别对这三部分输入的特征进行选择。
|
||||
|
||||
- linear_logits: 这部分是有关于线性计算，也就是FM的前半部分$w1x1+w2x2...wnxn+b$的计算。对于这一块的计算，我们用了一个get_linear_logits函数实现，后面再说，总之通过这个函数，我们就可以实现上面这个公式的计算过程，得到linear的输出， 这部分特征由数值特征和类别特征的onehot编码组成的一维向量组成，实际应用中根据自己的业务放置不同的一阶特征(这里的dense特征并不是必须的，有可能会将数值特征进行分桶，然后在当做类别特征来处理)
|
||||
- fm_logits: 这一块主要是针对离散的特征，首先过embedding，然后使用FM特征交叉的方式，两两特征进行交叉，得到新的特征向量，最后计算交叉特征的logits
|
||||
- dnn_logits: 这一块主要是针对离散的特征，首先过embedding，然后将得到的embedding拼接成一个向量(具体的可以看代码，也可以看一下下面的模型结构图)，通过dnn学习类别特征之间的隐式特征交叉并输出logits值
|
||||
|
||||
```python
|
||||
def DeepFM(linear_feature_columns, dnn_feature_columns):
|
||||
# 构建输入层，即所有特征对应的Input()层，这里使用字典的形式返回，方便后续构建模型
|
||||
dense_input_dict, sparse_input_dict = build_input_layers(linear_feature_columns + dnn_feature_columns)
|
||||
|
||||
# 将linear部分的特征中sparse特征筛选出来，后面用来做1维的embedding
|
||||
linear_sparse_feature_columns = list(filter(lambda x: isinstance(x, SparseFeat), linear_feature_columns))
|
||||
|
||||
# 构建模型的输入层，模型的输入层不能是字典的形式，应该将字典的形式转换成列表的形式
|
||||
# 注意：这里实际的输入与Input()层的对应，是通过模型输入时候的字典数据的key与对应name的Input层
|
||||
input_layers = list(dense_input_dict.values()) + list(sparse_input_dict.values())
|
||||
|
||||
# linear_logits由两部分组成，分别是dense特征的logits和sparse特征的logits
|
||||
linear_logits = get_linear_logits(dense_input_dict, sparse_input_dict, linear_sparse_feature_columns)
|
||||
|
||||
# 构建维度为k的embedding层，这里使用字典的形式返回，方便后面搭建模型
|
||||
# embedding层用户构建FM交叉部分和DNN的输入部分
|
||||
embedding_layers = build_embedding_layers(dnn_feature_columns, sparse_input_dict, is_linear=False)
|
||||
|
||||
# 将输入到dnn中的所有sparse特征筛选出来
|
||||
dnn_sparse_feature_columns = list(filter(lambda x: isinstance(x, SparseFeat), dnn_feature_columns))
|
||||
|
||||
fm_logits = get_fm_logits(sparse_input_dict, dnn_sparse_feature_columns, embedding_layers) # 只考虑二阶项
|
||||
|
||||
# 将所有的Embedding都拼起来，一起输入到dnn中
|
||||
dnn_logits = get_dnn_logits(sparse_input_dict, dnn_sparse_feature_columns, embedding_layers)
|
||||
|
||||
# 将linear,FM,dnn的logits相加作为最终的logits
|
||||
output_logits = Add()([linear_logits, fm_logits, dnn_logits])
|
||||
|
||||
# 这里的激活函数使用sigmoid
|
||||
output_layers = Activation("sigmoid")(output_logits)
|
||||
|
||||
model = Model(input_layers, output_layers)
|
||||
return model
|
||||
```
|
||||
|
||||
关于每一块的细节，这里就不解释了，在我们给出的GitHub代码中，我们已经加了非常详细的注释，大家看那个应该很容易看明白， 为了方便大家的阅读，我们这里还给大家画了一个整体的模型架构图，帮助大家更好的了解每一块以及前向传播（画的图不是很规范，先将就看一下，后面我们会统一在优化一下这个手工图）。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20210228161135777.png" alt="image-20210228161135777" />
|
||||
</div>
|
||||
|
||||
下面是一个通过keras画的模型结构图，为了更好的显示，数值特征和类别特征都只是选择了一小部分，画图的代码也在github中。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片DeepFM.png" alt="image-20210225180556628" style="zoom:50%;" />
|
||||
</div>
|
||||
|
||||
## 思考
|
||||
1. 如果对于FM采用随机梯度下降SGD训练模型参数，请写出模型各个参数的梯度和FM参数训练的复杂度
|
||||
2. 对于下图所示，根据你的理解Sparse Feature中的不同颜色节点分别表示什么意思
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20210225180556628.png" alt="image-20210225180556628" style="zoom:50%;" />
|
||||
</div>
|
||||
|
||||
|
||||
**参考资料**
|
||||
- [论文原文](https://arxiv.org/pdf/1703.04247.pdf)
|
||||
- [deepctr](https://github.com/shenweichen/DeepCTR)
|
||||
- [FM](https://github.com/datawhalechina/fun-rec/blob/master/docs/ch02/ch2.1/ch2.1.2/FM.md)
|
||||
- [推荐系统遇上深度学习(三)--DeepFM模型理论和实践](https://www.jianshu.com/p/6f1c2643d31b)
|
||||
- [FM算法公式推导](https://blog.csdn.net/qq_32486393/article/details/103498519)
|
||||
146
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.3/NFM.md
Normal file
146
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.3/NFM.md
Normal file
@@ -0,0 +1,146 @@
|
||||
# NFM
|
||||
## 动机
|
||||
|
||||
NFM(Neural Factorization Machines)是2017年由新加坡国立大学的何向南教授等人在SIGIR会议上提出的一个模型，传统的FM模型仅局限于线性表达和二阶交互， 无法胜任生活中各种具有复杂结构和规律性的真实数据， 针对FM的这点不足， 作者提出了一种将FM融合进DNN的策略，通过引进了一个特征交叉池化层的结构，使得FM与DNN进行了完美衔接，这样就组合了FM的建模低阶特征交互能力和DNN学习高阶特征交互和非线性的能力，形成了深度学习时代的神经FM模型(NFM)。
|
||||
|
||||
那么NFM具体是怎么做的呢？ 首先看一下NFM的公式：
|
||||
$$
|
||||
\hat{y}_{N F M}(\mathbf{x})=w_{0}+\sum_{i=1}^{n} w_{i} x_{i}+f(\mathbf{x})
|
||||
$$
|
||||
我们对比FM， 就会发现变化的是第三项，前两项还是原来的， 因为我们说FM的一个问题，就是只能到二阶交叉， 且是线性模型， 这是他本身的一个局限性， 而如果想突破这个局限性， 就需要从他的公式本身下点功夫， 于是乎，作者在这里改进的思路就是**用一个表达能力更强的函数来替代原FM中二阶隐向量内积的部分**。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片1.png" style="zoom:70%;" />
|
||||
</div>
|
||||
而这个表达能力更强的函数呢， 我们很容易就可以想到神经网络来充当，因为神经网络理论上可以拟合任何复杂能力的函数， 所以作者真的就把这个$f(x)$换成了一个神经网络，当然不是一个简单的DNN， 而是依然底层考虑了交叉，然后高层使用的DNN网络， 这个也就是我们最终的NFM网络了：
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片2.png" style="zoom:80%;" />
|
||||
</div>
|
||||
这个结构，如果前面看过了PNN的伙伴会发现，这个结构和PNN非常像，只不过那里是一个product_layer， 而这里换成了Bi-Interaction Pooling了， 这个也是NFM的核心结构了。这里注意， 这个结构中，忽略了一阶部分，只可视化出来了$f(x)$， 我们还是下面从底层一点点的对这个网络进行剖析。
|
||||
|
||||
## 模型结构与原理
|
||||
### Input 和Embedding层
|
||||
输入层的特征， 文章指定了稀疏离散特征居多， 这种特征我们也知道一般是先one-hot, 然后会通过embedding，处理成稠密低维的。 所以这两层还是和之前一样，假设$\mathbf{v}_{\mathbf{i}} \in \mathbb{R}^{k}$为第$i$个特征的embedding向量， 那么$\mathcal{V}_{x}=\left\{x_{1} \mathbf{v}_{1}, \ldots, x_{n} \mathbf{v}_{n}\right\}$表示的下一层的输入特征。这里带上了$x_i$是因为很多$x_i$转成了One-hot之后，出现很多为0的， 这里的$\{x_iv_i\}$是$x_i$不等于0的那些特征向量。
|
||||
|
||||
### Bi-Interaction Pooling layer
|
||||
在Embedding层和神经网络之间加入了特征交叉池化层是本网络的核心创新了，正是因为这个结构，实现了FM与DNN的无缝连接， 组成了一个大的网络，且能够正常的反向传播。假设$\mathcal{V}_{x}$是所有特征embedding的集合， 那么在特征交叉池化层的操作：
|
||||
$$
|
||||
f_{B I}\left(\mathcal{V}_{x}\right)=\sum_{i=1}^{n} \sum_{j=i+1}^{n} x_{i} \mathbf{v}_{i} \odot x_{j} \mathbf{v}_{j}
|
||||
$$
|
||||
|
||||
$\odot$表示两个向量的元素积操作，即两个向量对应维度相乘得到的元素积向量（可不是点乘呀），其中第$k$维的操作：
|
||||
$$
|
||||
\left(v_{i} \odot v_{j}\right)_{k}=\boldsymbol{v}_{i k} \boldsymbol{v}_{j k}
|
||||
$$
|
||||
|
||||
这便定义了在embedding空间特征的二阶交互，这个不仔细看会和感觉FM的最后一项很像，但是不一样，一定要注意这个地方不是两个隐向量的内积，而是元素积，也就是这一个交叉完了之后k个维度不求和，最后会得到一个$k$维向量，而FM那里内积的话最后得到一个数， 在进行两两Embedding元素积之后，对交叉特征向量取和， 得到该层的输出向量， 很显然， 输出是一个$k$维的向量。
|
||||
|
||||
注意， 之前的FM到这里其实就完事了， 上面就是输出了，而这里很大的一点改进就是加入特征池化层之后， 把二阶交互的信息合并， 且上面接了一个DNN网络， 这样就能够增强FM的表达能力了， 因为FM只能到二阶， 而这里的DNN可以进行多阶且非线性，只要FM把二阶的学习好了， DNN这块学习来会更加容易， 作者在论文中也说明了这一点，且通过后面的实验证实了这个观点。
|
||||
|
||||
如果不加DNN， NFM就退化成了FM，所以改进的关键就在于加了一个这样的层，组合了一下二阶交叉的信息，然后又给了DNN进行高阶交叉的学习，成了一种“加强版”的FM。
|
||||
|
||||
Bi-Interaction层不需要额外的模型学习参数，更重要的是它在一个线性的时间内完成计算，和FM一致的，即时间复杂度为$O\left(k N_{x}\right)$，$N_x$为embedding向量的数量。参考FM，可以将上式转化为：
|
||||
$$
|
||||
f_{B I}\left(\mathcal{V}_{x}\right)=\frac{1}{2}\left[\left(\sum_{i=1}^{n} x_{i} \mathbf{v}_{i}\right)^{2}-\sum_{i=1}^{n}\left(x_{i} \mathbf{v}_{i}\right)^{2}\right]
|
||||
$$
|
||||
后面代码复现NFM就是用的这个公式直接计算，比较简便且清晰。
|
||||
|
||||
### 隐藏层
|
||||
这一层就是全连接的神经网络， DNN在进行特征的高层非线性交互上有着天然的学习优势，公式如下：
|
||||
$$
|
||||
\begin{aligned}
|
||||
\mathbf{z}_{1}=&\sigma_{1}\left(\mathbf{W}_{1} f_{B I}
|
||||
\left(\mathcal{V}_{x}\right)+\mathbf{b}_{1}\right) \\
|
||||
\mathbf{z}_{2}=& \sigma_{2}\left(\mathbf{W}_{2} \mathbf{z}_{1}+\mathbf{b}_{2}\right) \\
|
||||
\ldots \ldots \\
|
||||
\mathbf{z}_{L}=& \sigma_{L}\left(\mathbf{W}_{L} \mathbf{z}_{L-1}+\mathbf{b}_{L}\right)
|
||||
\end{aligned}
|
||||
$$
|
||||
这里的$\sigma_i$是第$i$层的激活函数，可不要理解成sigmoid激活函数。
|
||||
|
||||
### 预测层
|
||||
这个就是最后一层的结果直接过一个隐藏层，但注意由于这里是回归问题，没有加sigmoid激活：
|
||||
$$
|
||||
f(\mathbf{x})=\mathbf{h}^{T} \mathbf{z}_{L}
|
||||
$$
|
||||
|
||||
所以， NFM模型的前向传播过程总结如下：
|
||||
$$
|
||||
\begin{aligned}
|
||||
\hat{y}_{N F M}(\mathbf{x}) &=w_{0}+\sum_{i=1}^{n} w_{i} x_{i} \\
|
||||
&+\mathbf{h}^{T} \sigma_{L}\left(\mathbf{W}_{L}\left(\ldots \sigma_{1}\left(\mathbf{W}_{1} f_{B I}\left(\mathcal{V}_{x}\right)+\mathbf{b}_{1}\right) \ldots\right)+\mathbf{b}_{L}\right)
|
||||
\end{aligned}
|
||||
$$
|
||||
这就是NFM模型的全貌， NFM相比较于其他模型的核心创新点是特征交叉池化层，基于它，实现了FM和DNN的无缝连接，使得DNN可以在底层就学习到包含更多信息的组合特征，这时候，就会减少DNN的很多负担，只需要很少的隐藏层就可以学习到高阶特征信息。NFM相比之前的DNN， 模型结构更浅，更简单，但是性能更好，训练和调参更容易。集合FM二阶交叉线性和DNN高阶交叉非线性的优势，非常适合处理稀疏数据的场景任务。在对NFM的真实训练过程中，也会用到像Dropout和BatchNormalization这样的技术来缓解过拟合和在过大的改变数据分布。
|
||||
|
||||
下面通过代码看下NFM的具体实现过程， 学习一些细节。
|
||||
|
||||
## 代码实现
|
||||
下面我们看下NFM的代码复现，这里主要是给大家说一下这个模型的设计逻辑，参考了deepctr的函数API的编程风格， 具体的代码以及示例大家可以去参考后面的GitHub，里面已经给出了详细的注释， 这里主要分析模型的逻辑这块。关于函数API的编程式风格，我们还给出了一份文档， 大家可以先看这个，再看后面的代码部分，会更加舒服些。下面开始：
|
||||
|
||||
这里主要说一下NFM模型的总体运行逻辑， 这样可以让大家从宏观的层面去把握模型的设计过程， 该模型所使用的数据集是criteo数据集，具体介绍参考后面的GitHub。 数据集的特征会分为dense特征(连续)和sparse特征(离散)， 所以模型的输入层接收这两种输入。但是我们这里把输入分成了linear input和dnn input两种情况，而每种情况都有可能包含上面这两种输入。因为我们后面的模型逻辑会分这两部分走，这里有个细节要注意，就是光看上面那个NFM模型的话，是没有看到它线性特征处理的那部分的，也就是FM的前半部分公式那里图里面是没有的。但是这里我们要加上。
|
||||
$$
|
||||
\hat{y}_{N F M}(\mathbf{x})=w_{0}+\sum_{i=1}^{n} w_{i} x_{i}+f(\mathbf{x})
|
||||
$$
|
||||
所以模型的逻辑我们分成了两大部分，这里我分别给大家解释下每一块做了什么事情：
|
||||
|
||||
1. linear part: 这部分是有关于线性计算，也就是FM的前半部分$w1x1+w2x2...wnxn+b$的计算。对于这一块的计算，我们用了一个get_linear_logits函数实现，后面再说，总之通过这个函数，我们就可以实现上面这个公式的计算过程，得到linear的输出
|
||||
2. dnn part: 这部分是后面交叉特征的那部分计算，FM的最后那部分公式f(x)。 这一块主要是针对离散的特征，首先过embedding， 然后过特征交叉池化层，这个计算我们用了get_bi_interaction_pooling_output函数实现， 得到输出之后又过了DNN网络，最后得到dnn的输出
|
||||
|
||||
模型的最后输出结果，就是把这两个部分的输出结果加和(当然也可以加权)，再过一个sigmoid得到。所以NFM的模型定义就出来了：
|
||||
|
||||
```python
|
||||
def NFM(linear_feature_columns, dnn_feature_columns):
|
||||
"""
|
||||
搭建NFM模型，上面已经把所有组块都写好了，这里拼起来就好
|
||||
:param linear_feature_columns: A list. 里面的每个元素是namedtuple(元组的一种扩展类型，同时支持序号和属性名访问组件)类型，表示的是linear数据的特征封装版
|
||||
:param dnn_feature_columns: A list. 里面的每个元素是namedtuple(元组的一种扩展类型，同时支持序号和属性名访问组件)类型，表示的是DNN数据的特征封装版
|
||||
"""
|
||||
# 构建输入层，即所有特征对应的Input()层， 这里使用字典的形式返回， 方便后续构建模型
|
||||
# 构建模型的输入层，模型的输入层不能是字典的形式，应该将字典的形式转换成列表的形式
|
||||
# 注意：这里实际的输入与Input()层的对应，是通过模型输入时候的字典数据的key与对应name的Input层
|
||||
dense_input_dict, sparse_input_dict = build_input_layers(linear_feature_columns+dnn_feature_columns)
|
||||
input_layers = list(dense_input_dict.values()) + list(sparse_input_dict.values())
|
||||
|
||||
# 线性部分的计算 w1x1 + w2x2 + ..wnxn + b部分，dense特征和sparse两部分的计算结果组成，具体看上面细节
|
||||
linear_logits = get_linear_logits(dense_input_dict, sparse_input_dict, linear_feature_columns)
|
||||
|
||||
# DNN部分的计算
|
||||
# 首先，在这里构建DNN部分的embedding层，之所以写在这里，是为了灵活的迁移到其他网络上，这里用字典的形式返回
|
||||
# embedding层用于构建FM交叉部分以及DNN的输入部分
|
||||
embedding_layers = build_embedding_layers(dnn_feature_columns, sparse_input_dict, is_linear=False)
|
||||
|
||||
# 过特征交叉池化层
|
||||
pooling_output = get_bi_interaction_pooling_output(sparse_input_dict, dnn_feature_columns, embedding_layers)
|
||||
|
||||
# 加个BatchNormalization
|
||||
pooling_output = BatchNormalization()(pooling_output)
|
||||
|
||||
# dnn部分的计算
|
||||
dnn_logits = get_dnn_logits(pooling_output)
|
||||
|
||||
# 线性部分和dnn部分的结果相加，最后再过个sigmoid
|
||||
output_logits = Add()([linear_logits, dnn_logits])
|
||||
output_layers = Activation("sigmoid")(output_logits)
|
||||
|
||||
model = Model(inputs=input_layers, outputs=output_layers)
|
||||
|
||||
return model
|
||||
```
|
||||
|
||||
有了上面的解释，这个模型的宏观层面相信就很容易理解了。关于这每一块的细节，这里就不解释了，在我们给出的GitHub代码中，我们已经加了非常详细的注释，大家看那个应该很容易看明白， 为了方便大家的阅读，我们这里还给大家画了一个整体的模型架构图，帮助大家更好的了解每一块以及前向传播。（画的图不是很规范，先将就看一下，后面我们会统一在优化一下这个手工图）。
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片NFM_aaaa.png" alt="NFM_aaaa" style="zoom: 50%;" />
|
||||
</div>
|
||||
下面是一个通过keras画的模型结构图，为了更好的显示，数值特征和类别特征都只是选择了一小部分，画图的代码也在github中。
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片nfm.png" alt="NFM_aaaa" style="zoom: 50%;" />
|
||||
</div>
|
||||
|
||||
## 思考题
|
||||
1. NFM中的特征交叉与FM中的特征交叉有何异同，分别从原理和代码实现上进行对比分析
|
||||
|
||||
**参考资料**
|
||||
- [论文原文](https://arxiv.org/pdf/1708.05027.pdf)
|
||||
- [deepctr](https://github.com/shenweichen/DeepCTR)
|
||||
- [AI上推荐 之 FNN、DeepFM与NFM(FM在深度学习中的身影重现)](https://blog.csdn.net/wuzhongqiang/article/details/109532267?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522161442951716780255224635%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=161442951716780255224635&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_v1~rank_blog_v1-1-109532267.pc_v1_rank_blog_v1&utm_term=NFM)
|
||||
117
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.3/WideNDeep.md
Normal file
117
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.3/WideNDeep.md
Normal file
@@ -0,0 +1,117 @@
|
||||
# Wide & Deep
|
||||
## 动机
|
||||
|
||||
在CTR预估任务中利用手工构造的交叉组合特征来使线性模型具有“记忆性”，使模型记住共现频率较高的特征组合，往往也能达到一个不错的baseline，且可解释性强。但这种方式有着较为明显的缺点：
|
||||
|
||||
1. 特征工程需要耗费太多精力。
|
||||
2. 模型是强行记住这些组合特征的，对于未曾出现过的特征组合，权重系数为0，无法进行泛化。
|
||||
|
||||
为了加强模型的泛化能力，研究者引入了DNN结构，将高维稀疏特征编码为低维稠密的Embedding vector，这种基于Embedding的方式能够有效提高模型的泛化能力。但是，基于Embedding的方式可能因为数据长尾分布，导致长尾的一些特征值无法被充分学习，其对应的Embedding vector是不准确的，这便会造成模型泛化过度。
|
||||
|
||||
Wide&Deep模型就是围绕记忆性和泛化性进行讨论的，模型能够从历史数据中学习到高频共现的特征组合的能力，称为是模型的Memorization。能够利用特征之间的传递性去探索历史数据中从未出现过的特征组合，称为是模型的Generalization。Wide&Deep兼顾Memorization与Generalization并在Google Play store的场景中成功落地。
|
||||
|
||||
## 模型结构及原理
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/Javaimage-20200910214310877.png" alt="image-20200910214310877" style="zoom:65%;" />
|
||||
</div>
|
||||
|
||||
其实wide&deep模型本身的结构是非常简单的，对于有点机器学习基础和深度学习基础的人来说都非常的容易看懂，但是如何根据自己的场景去选择那些特征放在Wide部分，哪些特征放在Deep部分就需要理解这篇论文提出者当时对于设计该模型不同结构时的意图了，所以这也是用好这个模型的一个前提。
|
||||
|
||||
**如何理解Wide部分有利于增强模型的“记忆能力”，Deep部分有利于增强模型的“泛化能力”？**
|
||||
|
||||
- wide部分是一个广义的线性模型，输入的特征主要有两部分组成，一部分是原始的部分特征，另一部分是原始特征的交叉特征(cross-product transformation)，对于交互特征可以定义为：
|
||||
$$
|
||||
\phi_{k}(x)=\prod_{i=1}^d x_i^{c_{ki}}, c_{ki}\in \{0,1\}
|
||||
$$
|
||||
$c_{ki}$是一个布尔变量，当第i个特征属于第k个特征组合时，$c_{ki}$的值为1，否则为0，$x_i$是第i个特征的值，大体意思就是两个特征都同时为1这个新的特征才能为1，否则就是0，说白了就是一个特征组合。用原论文的例子举例：
|
||||
|
||||
> AND(user_installed_app=QQ, impression_app=WeChat)，当特征user_installed_app=QQ,和特征impression_app=WeChat取值都为1的时候，组合特征AND(user_installed_app=QQ, impression_app=WeChat)的取值才为1，否则为0。
|
||||
|
||||
对于wide部分训练时候使用的优化器是带$L_1$正则的FTRL算法(Follow-the-regularized-leader)，而L1 FTLR是非常注重模型稀疏性质的，也就是说W&D模型采用L1 FTRL是想让Wide部分变得更加的稀疏，即Wide部分的大部分参数都为0，这就大大压缩了模型权重及特征向量的维度。**Wide部分模型训练完之后留下来的特征都是非常重要的，那么模型的“记忆能力”就可以理解为发现"直接的"，“暴力的”，“显然的”关联规则的能力。**例如Google W&D期望wide部分发现这样的规则：**用户安装了应用A，此时曝光应用B，用户安装应用B的概率大。**
|
||||
|
||||
- Deep部分是一个DNN模型，输入的特征主要分为两大类，一类是数值特征(可直接输入DNN)，一类是类别特征(需要经过Embedding之后才能输入到DNN中)，Deep部分的数学形式如下：
|
||||
$$
|
||||
a^{(l+1)} = f(W^{l}a^{(l)} + b^{l})
|
||||
$$
|
||||
**我们知道DNN模型随着层数的增加，中间的特征就越抽象，也就提高了模型的泛化能力。**对于Deep部分的DNN模型作者使用了深度学习常用的优化器AdaGrad，这也是为了使得模型可以得到更精确的解。
|
||||
|
||||
**Wide部分与Deep部分的结合**
|
||||
|
||||
W&D模型是将两部分输出的结果结合起来联合训练，将deep和wide部分的输出重新使用一个逻辑回归模型做最终的预测，输出概率值。联合训练的数学形式如下：需要注意的是，因为Wide侧的数据是高维稀疏的，所以作者使用了FTRL算法优化，而Deep侧使用的是 Adagrad。
|
||||
$$
|
||||
P(Y=1|x)=\delta(w_{wide}^T[x,\phi(x)] + w_{deep}^T a^{(lf)} + b)
|
||||
$$
|
||||
|
||||
## 代码实现
|
||||
|
||||
Wide侧记住的是历史数据中那些**常见、高频**的模式，是推荐系统中的“**红海**”。实际上，Wide侧没有发现新的模式，只是学习到这些模式之间的权重，做一些模式的筛选。正因为Wide侧不能发现新模式，因此我们需要**根据人工经验、业务背景，将我们认为有价值的、显而易见的特征及特征组合，喂入Wide侧**
|
||||
|
||||
Deep侧就是DNN，通过embedding的方式将categorical/id特征映射成稠密向量，让DNN学习到这些特征之间的**深层交叉**，以增强扩展能力。
|
||||
|
||||
模型的实现与模型结构类似由deep和wide两部分组成，这两部分结构所需要的特征在上面已经说过了，针对当前数据集实现，我们在wide部分加入了所有可能的一阶特征，包括数值特征和类别特征的onehot都加进去了，其实也可以加入一些与wide&deep原论文中类似交叉特征。只要能够发现高频、常见模式的特征都可以放在wide侧，对于Deep部分，在本数据中放入了数值特征和类别特征的embedding特征，实际应用也需要根据需求进行选择。
|
||||
|
||||
```python
|
||||
# Wide&Deep 模型的wide部分及Deep部分的特征选择，应该根据实际的业务场景去确定哪些特征应该放在Wide部分，哪些特征应该放在Deep部分
|
||||
def WideNDeep(linear_feature_columns, dnn_feature_columns):
|
||||
# 构建输入层，即所有特征对应的Input()层，这里使用字典的形式返回，方便后续构建模型
|
||||
dense_input_dict, sparse_input_dict = build_input_layers(linear_feature_columns + dnn_feature_columns)
|
||||
|
||||
# 将linear部分的特征中sparse特征筛选出来，后面用来做1维的embedding
|
||||
linear_sparse_feature_columns = list(filter(lambda x: isinstance(x, SparseFeat), linear_feature_columns))
|
||||
|
||||
# 构建模型的输入层，模型的输入层不能是字典的形式，应该将字典的形式转换成列表的形式
|
||||
# 注意：这里实际的输入与Input()层的对应，是通过模型输入时候的字典数据的key与对应name的Input层
|
||||
input_layers = list(dense_input_dict.values()) + list(sparse_input_dict.values())
|
||||
|
||||
# Wide&Deep模型论文中Wide部分使用的特征比较简单，并且得到的特征非常的稀疏，所以使用了FTRL优化Wide部分（这里没有实现FTRL）
|
||||
# 但是是根据他们业务进行选择的，我们这里将所有可能用到的特征都输入到Wide部分，具体的细节可以根据需求进行修改
|
||||
linear_logits = get_linear_logits(dense_input_dict, sparse_input_dict, linear_sparse_feature_columns)
|
||||
|
||||
# 构建维度为k的embedding层，这里使用字典的形式返回，方便后面搭建模型
|
||||
embedding_layers = build_embedding_layers(dnn_feature_columns, sparse_input_dict, is_linear=False)
|
||||
|
||||
dnn_sparse_feature_columns = list(filter(lambda x: isinstance(x, SparseFeat), dnn_feature_columns))
|
||||
|
||||
# 在Wide&Deep模型中，deep部分的输入是将dense特征和embedding特征拼在一起输入到dnn中
|
||||
dnn_logits = get_dnn_logits(dense_input_dict, sparse_input_dict, dnn_sparse_feature_columns, embedding_layers)
|
||||
|
||||
# 将linear,dnn的logits相加作为最终的logits
|
||||
output_logits = Add()([linear_logits, dnn_logits])
|
||||
|
||||
# 这里的激活函数使用sigmoid
|
||||
output_layer = Activation("sigmoid")(output_logits)
|
||||
|
||||
model = Model(input_layers, output_layer)
|
||||
return model
|
||||
```
|
||||
|
||||
关于每一块的细节，这里就不解释了，在我们给出的GitHub代码中，我们已经加了非常详细的注释，大家看那个应该很容易看明白， 为了方便大家的阅读，我们这里还给大家画了一个整体的模型架构图，帮助大家更好的了解每一块以及前向传播。（画的图不是很规范，先将就看一下，后面我们会统一在优化一下这个手工图）。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20210228160557072.png" alt="image-20210228160557072" style="zoom:67%;" />
|
||||
</div>
|
||||
|
||||
下面是一个通过keras画的模型结构图，为了更好的显示，数值特征和类别特征都只是选择了一小部分，画图的代码也在github中。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片Wide&Deep.png" alt="image-20210228160557072" style="zoom:67%;" />
|
||||
</div>
|
||||
|
||||
## 思考
|
||||
1. 在你的应用场景中，哪些特征适合放在Wide侧，哪些特征适合放在Deep侧，为什么呢？
|
||||
2. 为什么Wide部分要用L1 FTRL训练？
|
||||
3. 为什么Deep部分不特别考虑稀疏性的问题？
|
||||
|
||||
思考题可以参考[见微知著，你真的搞懂Google的Wide&Deep模型了吗?](https://zhuanlan.zhihu.com/p/142958834)
|
||||
|
||||
|
||||
**参考资料**
|
||||
- [论文原文](https://arxiv.org/pdf/1606.07792.pdf)
|
||||
- [deepctr](https://github.com/shenweichen/DeepCTR)
|
||||
- [看Google如何实现Wide & Deep模型(1)](https://zhuanlan.zhihu.com/p/47293765)
|
||||
- [推荐系统系列（六）：Wide&Deep理论与实践](https://zhuanlan.zhihu.com/p/92279796?utm_source=wechat_session&utm_medium=social&utm_oi=753565305866829824&utm_campaign=shareopn)
|
||||
- [见微知著，你真的搞懂Google的Wide&Deep模型了吗?](https://zhuanlan.zhihu.com/p/142958834)
|
||||
- [用NumPy手工打造 Wide & Deep](https://zhuanlan.zhihu.com/p/53110408)
|
||||
- [tensorflow官网的WideDeepModel](https://www.tensorflow.org/api_docs/python/tf/keras/experimental/WideDeepModel)
|
||||
- [详解 Wide & Deep 结构背后的动机](https://zhuanlan.zhihu.com/p/53361519)
|
||||
|
||||
565
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.3/xDeepFM.md
Normal file
565
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.3/xDeepFM.md
Normal file
@@ -0,0 +1,565 @@
|
||||
## 写在前面
|
||||
xDeepFM(eXtreme DeepFM)，这是2018年中科大联合微软在KDD上提出的一个模型，在DeepFM的前面加了一个eXtreme，看这个名字，貌似是DeepFM的加强版，但当我仔细的读完原文之后才发现，如果论血缘关系，这个模型应该离着DCN更近一些，这个模型的改进出发点依然是如何更好的学习特征之间的高阶交互作用，从而挖掘更多的交互信息。而基于这样的动机，作者提出了又一个更powerful的网络来完成特征间的高阶显性交互(DCN的话是一个交叉网络)， 这个网络叫做CIN(Compressed Interaction Network)，这个网络也是xDeepFM的亮点或者核心创新点了(牛x的地方)， 有了这个网络才使得这里的"Deep"变得名副其实。而xDeepFM的模型架构依然是w&D结构，更好的理解方式就是用这个CIN网络代替了DCN里面的Cross Network， 这样使得该网络同时能够显性和隐性的学习特征的高阶交互(显性由CIN完成，隐性由DNN完成)。 那么为啥需要同时学习特征的显性和隐性高阶交互呢？ 为啥会用CIN代替Cross Network呢？ CIN到底有什么更加强大之处呢？ xDeepFM与之前的DeepFM以及FM的关系是怎样的呢？ 这些问题都会在后面一一揭晓。
|
||||
|
||||
这篇文章的逻辑和前面一样，首先依然是介绍xDeepFM的理论部分和论文里面的细节，我觉得这篇文章的创新思路还是非常厉害的，也就是CIN的结构，在里面是会看到RNN和CNN的身影的，又会看到Cross Network的身影。所以这个结构我这次也是花了一些时间去理解，花了一些时间找解读文章看， 但讲真，解读文章真没有论文里面讲的清晰，所以我这次整理也是完全基于原论文加上我自己的理解进行解读。 当然，我水平有限，难免有理解不到位的地方，如果发现有错，也麻烦各位大佬帮我指出来呀。这样优秀的一个模型，不管是工业上还是面试里面，也是非常喜欢用或者考的内容，所以后面依然参考deepctr的代码，进行简化版的复现，重点看看CIN结构的实现过程。最后就是简单介绍和小总。
|
||||
|
||||
这篇文章依然比较长，首先是CIN结构本身可能比较难理解，前面需要一定的铺垫任务，比如一些概念(显隐性交叉，bit-wise和vector-wise等)， 一些基础模型(FM,FNN,PNN,DNN等)，DCN的Cross Network，有了这些铺垫后再理解CIN以及操作会简单些，而CIN本身运算也可能比较复杂，再加上里面时间复杂度和空间复杂度那块的分析，还有后面实验的各个小细节以最后论文还帮助我们串联了各种模型，我想在这篇文章中都整理一下。 再加上模型的复现内容，所以篇幅上还是会很长，各取所需吧还是哈哈。当然这篇文章的重点还是在CIN，这个也是面试里面非常喜欢问的点。
|
||||
|
||||
## xDeepFM? 我们需要先了解这些
|
||||
### 简介与进化动机
|
||||
再具体介绍xDeepFM之前，想先整理点铺垫的知识，也是以前的一些内容，是基于原论文的Introduction部分摘抄了一些，算是对前面内容的一些回顾吧，因为这段时间一直忙着找实习，也已经好久没有写这个系列的相关文章了。所以多少还是有点风格和知识上的遗忘哈哈。
|
||||
|
||||
首先是在推荐系统里面， 一般原始的特征很难让模型学习到隐藏在数据背后的规律，因为推荐系统中的原始特征往往非常稀疏，且维度非常高。所以如果想得到一个好的推荐系统，我们必须尽可能的制作更多的特征出来，而特征组合往往是比较好的方式，毕竟特征一般都不是独立存在的，那么特征究竟怎么组合呢？ 这是一个比较值得研究的难题，并且好多学者在这上面也下足了工夫。 如果你说，特征组合是啥来？ 不太清楚了呀，那么文章中这个例子正好能解决你的疑问
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210504201748649.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="image-20210308142624189" style="zoom: 60%;" />
|
||||
</div>
|
||||
|
||||
起初的时候，是人工特征组合，这个往往在作比赛的时候会遇到，就是特征工程里面自己进行某些特征的交叉与组合来生成新的特征。 这样的方式会有几个问题，作者在论文里面总结了：
|
||||
1. 一般需要一些经验和时间才会得到比较好的特征组合，也就是找这样的组合对于人来说有着非常高的要求，无脑组合不可取 --- 需要一定的经验，耗费大量的时间
|
||||
2. 由于推荐系统中数据的维度规模太大了，如果人工进行组合，根本就不太可能实现 --- 特征过多，无法全面顾及特征的组合
|
||||
3. 手工制作的特征也没有一定的泛化能力，而恰巧推荐系统中的数据往往又非常稀疏 --- 手工组合无泛化能力
|
||||
|
||||
所以，让**模型自动的进行特征交叉组合**探索成了推荐模型里面的比较重要的一个任务，还记得吗？ 这个也是模型进化的方向之一，之所以从前面进行引出，是因为本质上这篇的主角xDeepFM也是从这个方向上进行的探索， 那么既然又探索，那也说明了前面模型在这方面还有一定的问题，那么我们就来再综合理一理。
|
||||
|
||||
1. FM模型: 这个模型能够自动学习特征之间的两两交叉，并且比较厉害的地方就是用特征的隐向量内积去表示两两交叉后特征的重要程度，这使得模型在学习交互信息的同时，也让模型有了一定的泛化能力。 But，这个模型也有缺点，首先一般是只能应付特征的两两交叉，再高阶一点的交叉虽然行，但计算复杂，并且作者在论文中提到了高阶交叉的FM模型是不管有用还是无用的交叉都建模，这往往会带来一定的噪声。
|
||||
2. DNN模型: 这个非常熟悉了，深度学习到来之后，推荐模型的演化都朝着DNN的时代去了，原因之一就是因为DNN的多层神经网络可以比较出色的完成特征之间的高阶交互，只需要增加网络的层数，就可以轻松的学习交互，这是DNN的优势所在。 比较有代表的模型PNN，DeepCrossing模型等。 But， DNN并不是非常可靠，有下面几个问题。
|
||||
1. 首先，DNN的这种特征交互是隐性的，后面会具体说显隐性交互区别，但直观上理解，这种隐性交互我们是无法看到到底特征之间是怎么交互的，具体交互到了几阶，这些都是带有一定的不可解释性。
|
||||
2. 其次，DNN是bit-wise层级的交叉，关于bit-wise，后面会说，这种方式论文里面说一个embedding向量里面的各个元素也会相互影响， 这样我觉得在这里带来的一个问题就是可能会发生过拟合。 因为我们知道embedding向量的表示方法就是想从不同的角度去看待某个商品(比如颜色，价格，质地等)，当然embedding各个维度是无可解释性的，但我们还是希望这各个维度更加独立一点好，也就是相关性不那么大为妙，这样的话往往能更加表示出各个商品的区别来。 但如果这各个维度上的元素也互相影响了(神经网络会把这个也学习进去), 那过拟合的风险会变大。当然，上面这个是我自己的感觉， 原作者只是给了这样一段：<br>
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/2021050420491452.png#pic_center" alt="image-20210308142624189" style="zoom: 60%;" />
|
||||
</div>
|
||||
|
||||
也就是**DNN是否能够真正的有效学习特征之间的高阶交互是个谜！**
|
||||
3. DNN还存在的问题就是学习高阶交互或许是可能，但没法再兼顾低阶交互，也就是记忆能力，所以后面w&D架构在成为了主流架构。
|
||||
3. Wide&Deep, DeepFM模型: 这两个模型是既有DNN的深度，也有FM或者传统模型的广度，兼顾记忆能力和泛化能力，也是后面的主流模型。但依然有不足之处，wide&Deep的话不用多讲，首先逻辑回归(宽度部分)仍然需要人工特征交叉，而深度部分的高阶交叉又是一个谜。 DeepFM的话是FM和DNN的组合，用FM替代了逻辑回归，这样至少是模型的自动交叉特征，结合了FM的二阶以及DNN的高阶交叉能力。 但如果DNN这块高度交叉是个谜的话，就有点玄乎了。
|
||||
4. DCN网络: 这个模型也是w&D架构，不过宽度那部分使用了一个Cross Network，这个网络的奇妙之处，就是扩展了FM这种只能显性交叉的二阶的模型， 通过交叉网络能真正的显性的进行特征间的高阶交叉。 具体结构后面还会在复习，毕竟这次的xdeepFM主要是在Cross Network的基础上进行的再升级，这也是为啥说论血缘关系，xdeepFM离DCN更近一些的原因。那么Cross network有啥问题呢？ 这个想放在后面的2.4去说了，这样能更好的引出本篇主角来。
|
||||
|
||||
通过上面的一个梳理，首先是回忆起了前面这几个模型的发展脉络， 其次差不多也能明白xDeepFM到底再干个什么事情了，或者要解决啥问题了，xDeepFM其实简单的说，依然是研究如何自动的进行特征之间的交叉组合，以让模型学习的更好。 从上面这段梳理中，我们至少要得到3个重要信息：
|
||||
|
||||
1. 推荐模型如何有效的学习特征的交叉组合信息是非常重要的， 而原始的人工特征交叉组合不可取，如何让模型自动的学习交叉组合信息就变得非常关键
|
||||
2. 有的模型(FM)可以显性的交叉特征， 但往往没法高阶，只能到二阶
|
||||
3. 有的模型(DNN)可以进行高阶的特征交互，但往往是以一种无法解释的方式(隐性高阶交互)，并且是bit-wise的形式，能不能真正的学习到高阶交互其实是个谜。
|
||||
4. 有的模型(DCN)探索了显性的高阶交叉特征，但仍然存在一些问题。
|
||||
|
||||
所以xDeepFM的改进动机来了： 更有效的高阶显性交叉特征(CIN)，更高的泛化能力(vector-wise)， 显性和隐性高阶特征的组合(CIN+DNN)， 这就是xDeepFM了， 而这里面的关键，就是CIN网络了。在这之前，还是先把准备工作做足。
|
||||
|
||||
### Embedding Layer
|
||||
这个是为了回顾一下，简单一说，我们拿到的数据往往会有连续型数据和离散型或者叫类别型数据之分。 如果是连续型数据，那个不用多说，一般会归一化或者标准化处理，当然还可能进行一定的非线性化操作，就算处理完了。 而类别型数据，一般需要先LabelEncoder，转成类别型编码，然后再one-hot转成0或者1的编码格式。 比如论文里面的这个例子：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210504212842660.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="image-20210308142624189" style="zoom: 60%;" />
|
||||
</div>
|
||||
|
||||
这样的数据往往是高维稀疏的，不利于模型的学习，所以往往在这样数据之后，加一个embedding层，把数据转成低维稠密的向量表示。 关于embedding的原理这里不说了，但这里要注意一个细节，就是如果某个特征每个样本只有一种取值，也就是one-hot里面只有一个地方是1，比如前面3个field。这时候，可以直接拿1所在位置的embedding当做此时类别特征的embedding向量。 但是如果某个特征域每个样本好多种取值，比如interests这个，有好几个1的这种，那么就拿到1所在位置的embedding向量之后**求和**来代表该类别特征的embedding。这样，经过embedding层之后，我们得到的数据成下面这样了：
|
||||
$$
|
||||
\mathbf{e}=\left[\mathbf{e}_{1}, \mathbf{e}_{2}, \ldots, \mathbf{e}_{m}\right]
|
||||
$$
|
||||
这个应该比较好理解，$e_i$表示的一个向量，一般是$D$维的(隐向量的维度)， 那么假设$m$表示特征域的个数，那么此时的$\mathbf{e}$是$m\times D$的矩阵。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210504213606429.png#pic_center" alt="image-20210308142624189" style="zoom: 60%;" />
|
||||
</div>
|
||||
|
||||
### bit-wise VS vector-wise
|
||||
这是特征交互的两种方式，需要了解下，因为论文里面的CIN结构是在vector-wise上完成特征交互的， 这里拿从网上找到的一个例子来解释概念。
|
||||
|
||||
假设隐向量的维度是3维， 如果两个特征对应的向量分别是$(a_1, b_1, c_1)$和$(a_2,b_2, c_2)$
|
||||
|
||||
1. bit-wise = element-wise
|
||||
在进行交互时，交互的形式类似于$f(w_1a_1a_2, w_2b_1b_2,w_3c_1c_2)$，此时我们认为特征交互发生在元素级别上，bit-wise的交互是以bit为最小单元的，也就是向量的每一位上交互，且学习一个$w_i$
|
||||
2. vector-wise
|
||||
如果特征交互形式类似于$f(w(a_1a_2,b_1b_2,c_1c_2))$， 我们认为特征交互发生在向量级别上，vector-wise交互是以整个向量为最小单元的，向量层级的交互，为交互完的向量学习一个统一的$w$
|
||||
|
||||
这个一直没弄明白后者为什么会比前者好，我也在讨论群里问过这个问题，下面是得到的一个伙伴的想法：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210504214822820.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="image-20210308142624189" style="zoom: 80%;" />
|
||||
</div>
|
||||
|
||||
对于这个问题有想法的伙伴，也欢迎在下面评论，我自己的想法是bit-wise看上面的定义，仿佛是在元素的级别交叉，然后学习权重， 而vector-wise是在向量的级别交叉，然后学习统一权重，bit-wise具体到了元素级别上，虽然可能学习的更加细致，但这样应该会增加过拟合的风险，失去一定的泛化能力，再联想作者在论文里面解释的bit-wise:
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210504215106707.png#pic_center" alt="image-20210308142624189" style="zoom: 60%;" />
|
||||
</div>
|
||||
|
||||
更觉得这个想法会有一定的合理性，就想我在DNN那里解释这个一样，把细节学的太细，就看不到整体了，佛曰：着相了哈哈。如果再联想下FM的设计初衷，FM是一个vector-wise的模型，它进行了显性的二阶特征交叉，却是embedding级别的交互，这样的好处是有一定的泛化能力到看不见的特征交互。 emmm, 我在后面整理Cross Network问题的时候，突然悟了一下， bit-wise最大的问题其实在于**违背了特征交互的初衷**， 我们本意上其实是让模型学习特征之间的交互，放到embedding的角度，也理应是embedding与embedding的相关作用交互， 但bit-wise已经没有了embedding的概念，以bit为最细粒度进行学习， 这里面既有不同embedding的bit交互，也有同一embedding的bit交互，已经**意识不到Field vector的概念**。 具体可以看Cross Network那里的解释，分析了Cross Network之后，可能会更好理解些。
|
||||
|
||||
这个问题最好是先这样理解或者自己思考下，因为xDeepFM的一个挺大的亮点就是保留了FM的这种vector-wise的特征交互模式，也是作者一直强调的，vector-wise应该是要比bit-wise要好的，否则作者就不会强调Cross Network的弊端之一就是bit-wise，而改进的方法就是设计了CIN，用的是vector-wise。
|
||||
|
||||
### 高阶隐性特征交互(DNN) VS 高阶显性特征交互(Cross Network)
|
||||
#### DNN的隐性高阶交互
|
||||
DNN非常擅长学习特征之间的高阶交互信息，但是隐性的，这个比较好理解了，前面也提到过：
|
||||
$$
|
||||
\begin{array}{c}
|
||||
\mathbf{x}^{1}=\sigma\left(\mathbf{W}^{(1)} \mathbf{e}+\mathbf{b}^{1}\right) \\
|
||||
\mathbf{x}^{k}=\sigma\left(\mathbf{W}^{(k)} \mathbf{x}^{(k-1)}+\mathbf{b}^{k}\right)
|
||||
\end{array}
|
||||
$$
|
||||
但是问题的话，前面也剖析过了， 简单总结：
|
||||
1. DNN 是一种隐性的方式学习特征交互， 但这种交互是不可解释性的， 没法看出究竟是学习了几阶的特征交互
|
||||
2. DNN是在bit-wise层级上学习的特征交互， 这个不同于传统的FM的vector-wise
|
||||
3. DNN是否能有效的学习高阶特征交互是个迷，其实不知道学习了多少重要的高阶交互，哪些高阶交互会有作用，高阶到了几阶等， 如果用的话，只能靠玄学二字来解释
|
||||
|
||||
#### Cross Network的显性高阶交互
|
||||
谈到显性高阶交互，这里就必须先分析一下我们大名鼎鼎的DCN网络的Cross Network了， 关于这个模型，我在[AI上推荐 之 Wide&Deep与Deep&Cross模型](https://blog.csdn.net/wuzhongqiang/article/details/109254498)文章中进行了一些剖析，这里再复习的话我又参考了一个大佬的文章，因为再把我之前的拿过来感觉没有啥意思，重新再阅读别人的文章很可能会再get新的点，于是乎还真的学习到了新东西，具体链接放到了下面。 这里我们重温下Cross Network，看看到底啥子叫显性高阶交互。再根据论文看看这样子的交互有啥问题。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210505200049781.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="image-20210308142624189" style="zoom: 60%;" />
|
||||
</div>
|
||||
|
||||
这里的输入$x_0$需要提醒下，首先对于离散的特征，需要进行embedding， 对于multi-hot的离散变量， 需要embedding之后再做一个简单的average pooling, 而dense特征，归一化， **然后和embedding的特征拼接到一块作为Cross层和Deep层的输入，也就是Dense特征会在这里进行拼接**。 下面回顾Cross Layer。
|
||||
|
||||
Cross的目的是一一种显性、可控且高效的方式，**自动**构造**有限高阶**交叉特征。 具体的公式如下：
|
||||
$$
|
||||
\boldsymbol{x}_{l+1}=\boldsymbol{x}_{0} \boldsymbol{x}_{l}^{T} \boldsymbol{w}_{l}+\boldsymbol{b}_{l}+\boldsymbol{x}_{l}=f\left(\boldsymbol{x}_{l}, \boldsymbol{w}_{l}, \boldsymbol{b}_{l}\right)+\boldsymbol{x}_{l}
|
||||
$$
|
||||
其中$\boldsymbol{x}_{l+1}, \boldsymbol{x}_{l}, \boldsymbol{x}_{0} \in \mathbb{R}^{d}$。有图有真相：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20201026200320611.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="image-20210308142624189" style="zoom: 60%;" />
|
||||
</div>
|
||||
|
||||
Cross Layer的巧妙之处全部体现在上面的公式，下面放张图是为了更好的理解，这里我们回顾一些细节。
|
||||
1. 每层的神经元个数相同，都等于输入$\boldsymbol{x}_0$的维度$d$， 即每层的输入和输出维度是相等的(这个之前没有整理，没注意到)
|
||||
2. 残差网络的结构启发，每层的函数$\boldsymbol{f}$拟合的是$\boldsymbol{x}_{l+1}-\boldsymbol{x}_l$的残差，残差网络有很多优点，其中一个是处理梯度消失的问题，可以使得网络更“深”
|
||||
|
||||
那么显性交叉到底体会到哪里呢？ 还是拿我之前举的那个例子：假设$\boldsymbol{x}_{0}=\left[\begin{array}{l}x_{0,1} \\ x_{0,2}\end{array}\right]$， 为了讨论各层，先令$\boldsymbol{b}_i=0$， 则
|
||||
|
||||
$$
|
||||
\boldsymbol{x}_{1}=\boldsymbol{x}_{0} \boldsymbol{x}_{0}^{T} \boldsymbol{w}_{0}+\boldsymbol{x}_{0}=\left[\begin{array}{l}
|
||||
x_{0,1} \\
|
||||
x_{0,2}
|
||||
\end{array}\right]\left[x_{0,1}, x_{0,2}\right]\left[\begin{array}{c}
|
||||
w_{0,1} \\
|
||||
w_{0,2}
|
||||
\end{array}\right]+\left[\begin{array}{l}
|
||||
x_{0,1} \\
|
||||
x_{0,2}
|
||||
\end{array}\right]=\left[\begin{array}{l}
|
||||
w_{0,1} x_{0,1}^{2}+w_{0,2} x_{0,1} x_{0,2}+x_{0,1} \\
|
||||
w_{0,1} x_{0,2} x_{0,1}+w_{0,2} x_{0,2}^{2}+x_{0,2}
|
||||
\end{array}\right] \\
|
||||
\begin{aligned}
|
||||
\boldsymbol{x}_{2}=& \boldsymbol{x}_{0} \boldsymbol{x}_{1}^{T} \boldsymbol{w}_{1}+\boldsymbol{x}_{1} \\
|
||||
=&\left[\begin{array}{l}
|
||||
w_{1,1} x_{0,1} x_{1,1}+w_{1,2} x_{0,1} x_{1,2}+x_{1,1} \\
|
||||
\left.w_{1,1} x_{0,2} x_{1,1}+w_{1,2} x_{0,2} x_{1,2}+x_{1,2}\right]
|
||||
\end{array}\right. \\
|
||||
&=\left[\begin{array}{l}
|
||||
\left.w_{0,1} w_{1,1} x_{0,1}^{3}+\left(w_{0,2} w_{1,1}+w_{0,1} w_{1,2}\right) x_{0,1}^{2} x_{0,2}+w_{0,2} w_{1,2} x_{0,1} x_{0,2}^{2}+\left(w_{0,1}+w_{1,1}\right) x_{0,1}^{2}+\left(w_{0,2}+w_{1,2}\right) x_{0,1} x_{0,2}+x_{0,1}\right] \\
|
||||
\ldots \ldots \ldots .
|
||||
\end{array}\right.
|
||||
\end{aligned}
|
||||
$$
|
||||
最后得到$y_{\text {cross }}=\boldsymbol{x}_{2}^{T} * \boldsymbol{w}_{\text {cross }} \in \mathbb{R}$参与到最后的loss计算。 可以看到$\boldsymbol{x}_1$包含了原始特征$x_{0,1},x_{0,2}$从一阶导二阶所有可能叉乘组合， 而$\boldsymbol{x}_2$包含了从一阶导三阶素有可能的叉乘组合， 而**显性特征组合的意思，就是最终的结果可以经过一系列转换，得到类似$W_{i,j}x_ix_j$的形式**， 上面这个可以说是非常明显了吧。
|
||||
1. **有限高阶**： 叉乘**阶数由网络深度决定**， 深度$L_c$对应最高$L_c+1$阶的叉乘
|
||||
2. **自动叉乘**：Cross输出包含了原始从一阶(本身)到$L_c+1$阶的**所有叉乘组合**， 而模型参数量仅仅随着输入维度**线性增长**：$2\times d\times L_c$
|
||||
3. **参数共享**: 不同叉乘项对应的权重不同，但并非每个叉乘组合对应独立的权重，通过参数共享，Cross有效**降低了参数数量**。 并且，使得模型有更强的**泛化性**和**鲁棒性**。例如，如果独立训练权重，当训练集中$x_{i} \neq 0 \wedge x_{j} \neq 0$这个叉乘特征没有出现，对应权重肯定是0，而参数共享不会，类似的，数据集中的一些噪声可以由大部分样本来纠正权重参数的学习
|
||||
|
||||
这里有一点很值得留意，前面介绍过，文中将dense特征和embedding特征拼接后作为Cross层和Deep层的共同输入。这对于Deep层是合理的，但我们知道人工交叉特征基本是对原始sparse特征进行叉乘，那为何不直接用原始sparse特征作为Cross的输入呢？联系这里介绍的Cross设计，每层layer的节点数都与Cross的输入维度一致的，**直接使用大规模高维的sparse特征作为输入，会导致极大地增加Cross的参数量**。当然，可以畅想一下，其实直接拿原始sparse特征喂给Cross层，才是论文真正宣称的“省去人工叉乘”的更完美实现，但是现实条件不太允许。所以将高维sparse特征转化为低维的embedding，再喂给Cross，实则是一种**trade-off**的可行选择。
|
||||
|
||||
看下DNN与Cross Network的参数量对比: <br><br>初始输入$x_0$维度是$d$, Deep和Cross层数分别为$L_{cross}$和$L_{deep}$， 为便于分析，设Deep每层神经元个数为$m$则两部分参数量：
|
||||
$$
|
||||
\text { Cross: } d * L_{\text {cross }} * 2 \quad V S \quad \text { Deep: }(d * m+m)+\left(m^{2}+m\right) *\left(L_{\text {deep }}-1\right)
|
||||
$$
|
||||
可以看到Cross的参数量随$d$增大仅呈“线性增长”！相比于Deep部分，对整体模型的复杂度影响不大，这得益于Cross的特殊网络设计，对于模型在业界落地并实际上线来说，这是一个相当诱人的特点。Deep那部分参数计算其实是第一层单算$m(d+1)$， 接下来的$L-1$层，每层都是$m$， 再加上$b$个个数，所以$m(m+1)$。
|
||||
|
||||
好了， Cross的好处啥的都分析完了， 下面得分析点不好的地方了，否则就没法引出这次的主角了。作者直接说：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210505195118178.png#pic_center" alt="image-20210308142624189" style="zoom: 60%;" />
|
||||
</div>
|
||||
|
||||
每一层学习到的是$\boldsymbol{x}_0$的标量倍，这是啥意思。 这里有一个理论：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/202105051955220.png#pic_center" alt="image-20210308142624189" style="zoom: 60%;" />
|
||||
</div>
|
||||
|
||||
这里作者用数学归纳法进行了证明。
|
||||
|
||||
当$k=1$的时候
|
||||
$$
|
||||
\begin{aligned}
|
||||
\mathbf{x}_{1} &=\mathbf{x}_{0}\left(\mathbf{x}_{0}^{T} \mathbf{w}_{1}\right)+\mathbf{x}_{0} \\
|
||||
&=\mathbf{x}_{0}\left(\mathbf{x}_{0}^{T} \mathbf{w}_{1}+1\right) \\
|
||||
&=\alpha^{1} \mathbf{x}_{0}
|
||||
\end{aligned}
|
||||
$$
|
||||
这里的$\alpha^{1}=\mathbf{x}_{0}^{T} \mathbf{w}_{1}+1$是$x_0$的一个线性回归， $x_1$是$x_0$的标量倍成立。 假设当$k=i$的时候也成立，那么$k=i+1$的时候：
|
||||
$$
|
||||
\begin{aligned}
|
||||
\mathbf{x}_{i+1} &=\mathbf{x}_{0} \mathbf{x}_{i}^{T} \mathbf{w}_{i+1}+\mathbf{x}_{i} \\
|
||||
&=\mathbf{x}_{0}\left(\left(\alpha^{i} \mathbf{x}_{0}\right)^{T} \mathbf{w}_{i+1}\right)+\alpha^{i} \mathbf{x}_{0} \\
|
||||
&=\alpha^{i+1} \mathbf{x}_{0}
|
||||
\end{aligned}
|
||||
$$
|
||||
其中$\alpha^{i+1}=\alpha^{i}\left(\mathbf{x}_{0}^{T} \mathbf{w}_{i+1}+1\right)$， 即$x_{i+1}$依然是$x_0$的标量倍。
|
||||
|
||||
所以作者认为Cross Network有两个缺点:
|
||||
1. 由于每个隐藏层是$x_0$的标量倍，所以CrossNet的输出受到了特定形式的限制
|
||||
2. CrossNet的特征交互是bit-wise的方式(这个经过上面举例子应该是显然了)，这种方式embedding向量的各个元素也会互相影响，这样在泛化能力上可能受到限制，并且也**意识不到Field Vector的概念**, **这其实违背了我们特征之间相互交叉的初衷**。因为我们想让模型学习的是特征与特征之间的交互或者是相关性，从embedding的角度，，那么自然的特征与特征之间的交互信息应该是embedding与embedding的交互信息。 但是**bit-wise的交互上，已经意识不到embedding的概念了**。由于最细粒度是bit(embedding的具体元素)，所以这样的交互既包括了不同embedding不同元素之间的交互，也包括了同一embedding不同元素的交互。本质上其实发生了改变。 **这也是作者为啥强调CIN网络是vector-wise的原因**。而FM，恰好是以向量为最细粒度学习相关性。
|
||||
|
||||
好了， 如果真正理解了Cross Network，以及上面存在的两个问题，理解xDeepFM的动机就不难了，**xDeepFM的动机，正是将FM的vector-wise的思想引入到了Cross部分**。
|
||||
|
||||
下面主角登场了:
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210505201840211.png#pic_center" alt="image-20210308142624189" style="zoom: 60%;" />
|
||||
</div>
|
||||
|
||||
## xDeepFM模型的理论以及论文细节
|
||||
了解了xDeepFM的动机，再强调下xDeepFM的核心，就是提出的一个新的Cross Network(CIN)，这个是基于DCN的Cross Network，但是有上面那几点好处。下面的逻辑打算是这样，首先先整体看下xDeepFM的模型架构，由于我们已经知道了这里其实就是用一个CIN网络代替了DCN的Cross Network，那么这里面除了这个网络，其他的我们都熟悉。 然后我们再重点看看CIN网络到底在干个什么样的事情，然后再看看CIN与FM等有啥关系，最后分析下这个新网络的时间复杂度等问题。
|
||||
### xDeepFM的架构剖析
|
||||
首先，我们先看下xDeepFM的架构
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/2021050520373226.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="image-20210308142624189" style="zoom: 60%;" />
|
||||
</div>
|
||||
|
||||
这个网络结构名副其实，依然是采用了W&D架构，DNN负责Deep端，学习特征之间的隐性高阶交互， 而CIN网络负责wide端，学习特征之间的显性高阶交互，这样显隐性高阶交互就在这个模型里面体现的淋漓尽致了。不过这里的线性层单拿出来了。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210505204057446.png#pic_center" alt="image-20210308142624189" style="zoom: 60%;" />
|
||||
</div>
|
||||
|
||||
最终的计算公式如下：
|
||||
$$
|
||||
\hat{y}=\sigma\left(\mathbf{w}_{\text {linear }}^{T} \mathbf{a}+\mathbf{w}_{d n n}^{T} \mathbf{x}_{d n n}^{k}+\mathbf{w}_{\text {cin }}^{T} \mathbf{p}^{+}+b\right)
|
||||
$$
|
||||
这里的$\mathbf{a}$表示原始的特征，$\mathbf{a}_{dnn}^k$表示的是DNN的输出， $\mathbf{p}^+$表示的是CIN的输出。最终的损失依然是交叉熵损失，这里也是做一个点击率预测的问题：
|
||||
$$
|
||||
\mathcal{L}=-\frac{1}{N} \sum_{i=1}^{N} y_{i} \log \hat{y}_{i}+\left(1-y_{i}\right) \log \left(1-\hat{y}_{i}\right)
|
||||
$$
|
||||
最终的目标函数加了正则化:
|
||||
$$
|
||||
\mathcal{J}=\mathcal{L}+\lambda_{*}\|\Theta\|
|
||||
$$
|
||||
|
||||
### CIN网络的细节(重头戏）
|
||||
这里尝试剖析下本篇论文的主角CIN网络，全称Compressed Interaction Network。这个东西说白了其实也是一个网络，并不是什么高大上的东西，和Cross Network一样，也是一层一层，每一层都是基于一个固定的公式进行的计算，那个公式长这样:
|
||||
$$
|
||||
\mathbf{X}_{h, *}^{k}=\sum_{i=1}^{H_{k-1}} \sum_{j=1}^{m} \mathbf{W}_{i j}^{k, h}\left(\mathbf{X}_{i, *}^{k-1} \circ \mathbf{X}_{j, *}^{0}\right)
|
||||
$$
|
||||
这个公式第一眼看过来，肯定更是懵逼，这是写的个啥玩意？如果我再把CIN的三个核心图放上来:
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/2021050520530391.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="image-20210308142624189" style="zoom: 60%;" />
|
||||
</div>
|
||||
|
||||
上面其实就是CIN网络的精髓了，也是它具体的运算过程，只不过直接上图的话，会有些抽象，难以理解，也不符合我整理论文的习惯。下面，我们就一一进行剖析， 先从上面这个公式开始。但在这之前，需要先约定一些符号。要不然不知道代表啥意思。
|
||||
1. $\mathbf{X}^{0} \in \mathbb{R}^{m \times D}$: 这个就是我们的输入，也就是embedding层的输出，可以理解为各个embedding的堆叠而成的矩阵，假设有$m$个特征，embedding的维度是$D$维，那么这样就得到了这样的矩阵， $m$行$D$列。$\mathbf{X}_{i, *}^{0}=\mathbf{e}_{i}$， 这个表示的是第$i$个特征的embedding向量$e_i$。所以上标在这里表示的是网络的层数，输入可以看做第0层，而下标表示的第几行的embedding向量，这个清楚了。
|
||||
2. $\mathbf{X}^{k} \in \mathbb{R}^{H_{k} \times D}$: 这个表示的是CIN网络第$k$层的输出，和上面这个一样，也是一个矩阵，每一行是一个embedding向量，每一列代表一个embedding维度。这里的$H_k$表示的是第$k$层特征的数量，也可以理解为神经元个数。那么显然，这个$\mathbf{X}^{k}$就是$H_k$个$D$为向量堆叠而成的矩阵，维度也显然了。$\mathbf{X}_{h, *}^{k}$代表的就是第$k$层第$h$个特征向量了。
|
||||
|
||||
所以上面的那个公式：
|
||||
$$
|
||||
\mathbf{X}_{h, *}^{k}=\sum_{i=1}^{H_{k-1}} \sum_{j=1}^{m} \mathbf{W}_{i j}^{k, h}\left(\mathbf{X}_{i, *}^{k-1} \circ \mathbf{X}_{j, *}^{0}\right)
|
||||
$$
|
||||
其实就是计算第$k$层第$h$个特征向量， 这里的$1 \leq h \leq H_{k}, \mathbf{W}^{k, h} \in \mathbb{R}^{H_{k-1} \times m}$是第$h$个特征向量的参数矩阵。 $\circ$表示的哈达玛积，也就是向量之间对应维度元素相乘(不相加了)。$\left\langle a_{1}, a_{2}, a_{3}\right\rangle \circ\left\langle b_{1}, b_{2}, b_{3}\right\rangle=\left\langle a_{1} b_{1}, a_{2} b_{2}, a_{3} b_{3}\right\rangle$。通过这个公式也能看到$\mathbf{X}^k$是通过$\mathbf{X}^{k-1}$和$\mathbf{X}^0$计算得来的，也就是说特征的显性交互阶数会虽然网络层数的加深而增加。
|
||||
|
||||
那么这个公式到底表示的啥意思呢？ 是具体怎么计算的呢？我们往前计算一层就知道了，这里令$k=1$，也就是尝试计算第一层里面的第$h$个向量， 那么上面公式就变成了:
|
||||
|
||||
$$
|
||||
\mathbf{X}_{h, *}^{1}=\sum_{i=1}^{H_{0}} \sum_{j=1}^{m} \mathbf{W}_{i j}^{1, h}\left(\mathbf{X}_{i, *}^{0} \circ \mathbf{X}_{j, *}^{0}\right)
|
||||
$$
|
||||
这里的$\mathbf{W}^{1, h} \in \mathbb{R}^{H_{0} \times m}$。这个能看懂吗？ 首先这个$\mathbf{W}$矩阵是$H_0$行$m$列， 而前面那两个累加正好也是$H_0$行$m$列的参数。$m$代表的是输入特征的个数， $H_0$代表的是第0层($k-1$层)的神经元的个数， 这个也是$m$。这个应该好理解，输入层就是第0层。所以这其实就是一个$m\times m$的矩阵。那么后面这个运算到底是怎么算的呢？ 首先对于第$i$个特征向量， 要依次和其他的$m$个特征向量做哈达玛积操作，当然也乘以对应位置的权重，求和。对于每个$i$特征向量，都重复这样的操作，最终求和得到一个$D$维的向量，这个就是$\mathbf{X}_{h, *}^{1}$。好吧，这么说。我觉得应该也没有啥感觉，画一下就了然了，现在可以先不用管论文里面是怎么说的，先跟着这个思路走，只要理解了这个公式是怎么计算的，论文里面的那三个图就会非常清晰了。灵魂画手:
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210505215026537.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="image-20210308142624189" style="zoom: 60%;" />
|
||||
</div>
|
||||
|
||||
这就是上面那个公式的具体过程了，图实在是太难看了， 但应该能说明这个详细的过程了。这样只要给定一个$\mathbf{W}^{1,h}$之后，就能算出一个相应的$\mathbf{X}^1_{h,*}$来，这样第一层的$H_1$个神经元按照这样的步骤就能够都计算出来了。 后面的计算过程其实是同理，无非就是输入是前一层的输出以及$\mathbf{X}_0$罢了，而这时候，第一个矩阵特征数就不一定是$m$了，而是一个$H_{k-1}$行$D$列的矩阵了。这里的$\mathbf{W}^{k,h}$就是上面写的$H_{k-1}$行$m$列了。
|
||||
|
||||
这个过程明白了之后，再看论文后面的内容就相对容易了，首先
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210505215629371.png#pic_center" alt="image-20210308142624189" style="zoom: 60%;" />
|
||||
</div>
|
||||
|
||||
CIN里面能看到RNN的身影，也就是当前层的隐藏单元的计算要依赖于上一层以及当前的输入层，只不过这里的当前输入每个时间步都是$\mathbf{X}_0$。 同时这里也能看到，CIN的计算是vector-wise级别的，也就是向量之间的哈达玛积的操作，并没有涉及到具体向量里面的位交叉。
|
||||
|
||||
下面我们再从CNN的角度去看这个计算过程。其实还是和上面一样的计算过程，只不过是换了个角度看而已，所以上面那个只要能理解，下面CNN也容易理解了。首先，这里引入了一个tensor张量$\mathbf{Z}^{k+1}$表示的是$\mathbf{X}^k$和$\mathbf{X}^0$的外积，那么这个东西是啥呢？ 上面加权求和前的那个矩阵，是一个三维的张量。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210505221222945.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="image-20210308142624189" style="zoom: 60%;" />
|
||||
</div>
|
||||
|
||||
这个可以看成是一个三维的图片，$H_{k-1}$高，$m$宽，$D$个通道。而$\mathbf{W}^{k,h}$的大小是$H_{k-1}\times m$的， 这个就相当于一个过滤器，用这个过滤器对输入的图片如果**逐通道进行卷积**，就会最终得到一个$D$维的向量，而这个其实就是$\mathbf{X}^{k}_{h,*}$，也就是一张特征图(每个通道过滤器是共享的)。 第$k$层其实有$H_k$个这样的过滤器，所以最后得到的是一个$H_k\times D$的矩阵。这样，在第$k$个隐藏层，就把了$H_{k-1}\times m\times D$的三维张量通过逐通道卷积的方式，压缩成了一个$H_k\times D$的矩阵($H_k$张特征图)， 这就是第$k$层的输出$\mathbf{X}^k$。 而这也就是“compressed"的由来。这时候再看这两个图就非常舒服了：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210505222742858.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="image-20210308142624189" style="zoom: 60%;" />
|
||||
</div>
|
||||
|
||||
通过这样的一个CIN网络，就很容易的实现了特征的显性高阶交互，并且是vector-wise级别的，那么最终的输出层是啥呢？ 通过上面的分析，首先我们了解了对于第$k$层输出的某个特征向量，其实是综合了输入里面各个embedding向量显性高阶交互的信息(第$k$层其实学习的输入embedding$k+1$阶交互信息)，这个看第一层那个输出就能看出来。第$k$层的每个特征向量其实都能学习到这样的信息，那么如果把这些向量在从$D$维度上进行加和，也就是$\mathbf{X}^k$，这是个$H_k\times D$的，我们沿着D这个维度加和，又会得到一个$H_k$的向量，公式如下:
|
||||
$$
|
||||
p_{i}^{k}=\sum_{j=1}^{D} \mathbf{X}_{i, j}^{k}
|
||||
$$
|
||||
每一层，都会得到一个这样的向量，那么把所有的向量拼接到一块，其实就是CIN网络的输出了。之所以，这里要把中间结果都与输出层相连，就是因为CIN与Cross不同的一点是，在第$k$层，CIN只包含$k+1$阶的组合特征，而Cross是能包含从1阶-$k+1$阶的组合特征的，所以为了让模型学习到从1阶到所有阶的组合特征，CIN这里需要把中间层的结果与输出层建立连接。
|
||||
|
||||
这也就是第三个图表示的含义:
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210505223705748.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="image-20210308142624189" style="zoom: 60%;" />
|
||||
</div>
|
||||
|
||||
这样， 就得到了最终CIN的输出$\mathbf{p}^+$了:
|
||||
|
||||
$$
|
||||
\mathbf{p}^{+}=\left[\mathbf{p}^{1}, \mathbf{p}^{2}, \ldots, \mathbf{p}^{T}\right] \in \mathbb{R} \sum_{i=1}^{T} H_{i}
|
||||
$$
|
||||
后面那个维度的意思，就是说每一层是的向量维度是$H_i$维， 最后是所有时间步的维度之和。 CIN网络的计算过程的细节就是这些了。
|
||||
|
||||
### CIN网络的其他角度分析
|
||||
#### 设计意图分析
|
||||
CIN和DCN层的设计动机是相似的，Cross层的input也是前一层与输入层，这么做的原因就是可以实现: **有限高阶交互，自动叉乘和参数共享**。
|
||||
|
||||
但是CIN与Cross的有些地方是不一样的:
|
||||
1. Cross是bit-wise级别的， 而CIN是vector-wise级别的
|
||||
2. 在第$l$层，Cross包含从1阶-$l+1$阶的所有组合特征， 而CIN只包含$l+1$阶的组合特征。 相应的，Cross在输出层输出全部结果， 而CIN在每层都输出中间结果。 而之所以会造成这两者的不同， 就是因为Cross层计算公式中除了与CIN一样包含"上一层与输入层的×乘"外，会再额外加了个"＋输入层"。**这是两种涵盖所有阶特征交互的不同策略，CIN和Cross也可以使用对方的策略**。
|
||||
|
||||
#### 时间和空间复杂度分析
|
||||
1. 空间复杂度
|
||||
假设CIN和DNN每层神经元个数是$H$，网络深度为$T$。 那么CIN的参数空间复杂度$O(mTH^2)$。 这个我们先捋捋是怎么算的哈， 首先对于CIN，第$k$层的每个神经元都会对应着一个$H_{k-1}\times m$的参数矩阵$\mathbf{W}^{k,h}$， 那么第$k$层$H$个神经元的话，那就是$H \times H_{k-1} \times m$个参数，这里假设的是每层都有$H$个神经元，那么就是$O(H^2\times m)$，这是一层。 而网络深度一共$T$层的话，那就是$H \times H_{k-1} \times m\times T$的规模。 但别忘了，输出层还有参数， 由于输出层的参数会和输出向量的维度相对应，而输出向量的维度又和每一层神经单元个数相对应， 所以CIN的网络参数一共是$\sum_{k=1}^{T} H_{k} \times\left(1+H_{k-1} \times m\right)$， 而换成大O表示的话，其实就是上面那个了。当然，CIN还可以对$\mathbf{W}$进行$L$阶矩阵分解，使得空间复杂度再降低。 <br><br>再看DNN，第一层是$m\times D\times H_1$， 中间层$H_k\times H_{k-1}$，T-1层，这是一个$O(mDH+TH^2)$的空间复杂度，并且参数量会随着$D$的增加而增加。 <br><br>所以空间上来说，CIN会有优势。
|
||||
2. 时间复杂度
|
||||
对于CIN， 我们计算某一层的某个特征向量的时候，需要前面的$H_{k-1}$个向量与输入的$m$个向量两两哈达玛积的操作，这个过程花费的时间$O(Hm)$， 而哈达玛积完事之后，有需要拿个过滤器在D维度上逐通道卷积，这时候得到了$\mathbf{Z}^{k+1}$，花费时间$O(HmD)$。 这只是某个特征向量， $k$层一共$H$个向量， 那么花费时间$O(H^2mD)$， 而一共$T$层，所以最终时间为$O(mH^2TD)$<br><br>对于普通的DNN，花费时间$O(mHD+H^2T)$<br><br>**所以时间复杂度会是CIN的一大痛点**。
|
||||
|
||||
#### 多项式逼近
|
||||
这地方没怎么看懂，大体写写吧， 通过对问题进行简化，即假设CIN中不同层的feature map的数量全部一致，均为fields的数量$m$，并且用`[m]`表示小于等于m的正整数。CIN中的第一层的第$h$个feature map表示为$x_h^1 \in \mathbb{R}^D$，即
|
||||
$$
|
||||
\boldsymbol{x}_{\boldsymbol{h}}^{1}=\sum_{i \in[m], j \in[m]} \boldsymbol{W}_{i, j}^{1, h}\left(x_{i}^{0} \circ x_{j}^{0}\right)
|
||||
$$
|
||||
因此， 在第一层中通过$O(m^2)$个参数来建模成对的特征交互关系，相似的，第二层的第$h$个特征图表示为:
|
||||
$$
|
||||
\begin{array}{c}
|
||||
\boldsymbol{x}_{h}^{2}=\sum_{i \in[m], j \in[m]} \boldsymbol{W}_{i, j}^{2, h}\left(x_{i}^{1} \circ x_{j}^{0}\right) \\
|
||||
=\sum_{i \in[m], j \in[m]] \in[m], k \in[m]} \boldsymbol{W}_{i, j}^{2, h} \boldsymbol{W}_{l, k}^{1, h}\left(x_{j}^{0} \circ x_{k}^{0} \circ x_{l}^{0}\right)
|
||||
\end{array}
|
||||
$$
|
||||
由于第二个$\mathbf{W}$矩阵在前面一层计算好了，所以第二层的feature map也是只用了$O(m^2)$个参数就建模出了3阶特征交互关系。
|
||||
|
||||
我们知道一个经典的$k$阶多项式一般是需要$O(m^k)$个参数的，而我们展示了CIN在一系列feature map中只需要$O(k m^2)$个参数就可以近似此类多项式。而且paper使用了归纳假设的方法证明了一下，也就是后面那两个公式。具体的没咋看懂证明，不整理了。但得知道两个结论:
|
||||
1. 对于CIN来讲， 第$k$层只包含$k+1$阶特征间的显性特征交互
|
||||
2. CIN的一系列特征图只需要$O(km^2)$个参数就可以近似此类多项式
|
||||
|
||||
#### xDeepFM与其他模型的关系
|
||||
1. 对于xDeepFM，将CIN模块的层数设置为1，feature map数量也为1时，其实就是DeepFM的结构，因此DeepFM是xDeepFM的特殊形式，而xDeepFM是DeepFM的一般形式；
|
||||
2. 在1中的基础上，当我们再将xDeepFM中的DNN去除，并对feature map使用一个常数1形式的 `sum filter`，那么xDeepFM就退化成了FM形式了。
|
||||
|
||||
一般这种模型的改进，是基于之前模型进行的，也就是简化之后，会得到原来的模型，这样最差的结果，模型效果还是原来的，而不应该会比原来模型的表现差，这样的改进才更有说服力。
|
||||
|
||||
所以，既然提到了FM，再考虑下面两个问题理解下CIN设计的合理性。
|
||||
1. 每层通过sum pooling对vector的元素加和输出，这么做的意义或者合理性? 这个就是为了退化成FM做准备，如果CIN只有1层， 只有$m$个vector，即 $H_1=m$ ，且加和的权重矩阵恒等于1，即$W^1=1$ ，那么sum pooling的输出结果，就是一系列的两两向量内积之和，即标准的FM（不考虑一阶与偏置）。
|
||||
2. 除了第一层，中间层的基于Vector高阶组合有什么物理意义? 回顾FM，虽然是二阶的，但可以扩展到多阶，例如考虑三阶FM，是对三个嵌入向量做哈达玛积乘再对得到的vector做sum， CIN基于vector-wise的高阶组合再sum pooling与之类似，这也是模型名字"eXtreme Deep Factorization Machine(xDeepFM)"的由来。
|
||||
### 论文的其他重要细节
|
||||
#### 实验部分
|
||||
这一块就是后面实验了，这里作者依然是抛出了三个问题，并通过实验进行了解答。
|
||||
1. CIN如何学习高阶特征交互
|
||||
通过提出的交叉网络，这里单独证明了这个结构要比CrossNet，DNN模块和FM模块要好
|
||||
2. 推荐系统中，是否需要显性和隐性的高阶特征交互都存在?
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/2021050609553410.png#pic_center" alt="image-20210308142624189" style="zoom: 60%;" />
|
||||
</div>
|
||||
|
||||
3. 超参对于xDeepFM的影响
|
||||
1. 网络的深度: 不用太深， CIN网络层数大于3，就不太好了，容易过拟合
|
||||
2. 每一层神经网络的单元数: 100是比较合适的一个数值
|
||||
3. 激活函数: CIN这里不用加任何的非线性激活函数，用恒等函数$f(x)=x$效果最好
|
||||
|
||||
|
||||
这里用了三个数据集
|
||||
1. 公开数据集 Criteo 与 微软数据集 BingNews
|
||||
2. DianPing 从大众点评网整理的相关数据，收集6个月的user check-in 餐厅poi的记录，从check-in餐厅周围3km内，按照poi受欢迎度抽取餐厅poi作为负例。根据user属性、poi属性，以及user之前3家check-in的poi，预测用户check-in一家给定poi的概率。
|
||||
|
||||
评估指标用了两个AUC和Logloss, 这两个是从不同的角度去评估模型。
|
||||
1. AUC: AUC度量一个正的实例比一个随机选择的负的实例排名更高的概率。它只考虑预测实例的顺序，对类的不平衡问题不敏感.
|
||||
2. LogLoss(交叉熵损失): 真实分数与预测分数的距离
|
||||
|
||||
作者说:
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/2021050609492960.png#pic_center" alt="image-20210308142624189" style="zoom: 60%;" />
|
||||
</div>
|
||||
|
||||
#### 相关工作部分
|
||||
这里作者又梳理了之前的模型，这里就再梳理一遍了
|
||||
|
||||
1. 经典推荐系统
|
||||
1. 非因子分解模型: 主要介绍了两类，一类是常见的线性模型，例如LR with FTRL，这一块很多工作是在交互特征的特征工程方面；另一类是提升决策树模型的研究（GBDT+LR)
|
||||
2. 因子分解模型: MF模型， FM模型，以及在FM模型基础上的贝叶斯模型
|
||||
|
||||
2. 深度学习模型
|
||||
1. 学习高阶交互特征: 论文中提到的DeepCross, FNN，PNN，DCN, NFM, W&D, DeepFM,
|
||||
2. 学习精心的表征学习:这块常见的深度学习模型不是focus在学习高阶特征交互关系。比如NCF，ACF，DIN等。
|
||||
|
||||
推荐系统数据特点: 稀疏，类别连续特征混合，高维。
|
||||
|
||||
关于未来两个方向:
|
||||
1. CIN的sum pooling这里， 后面可以考虑DIN的那种思路，根据当前候选商品与embedding的关联进行注意力权重的添加
|
||||
2. CIN的时间复杂度还是比较高的，后面在GPU集群上使用分布式的方式来训练模型。
|
||||
|
||||
|
||||
## xDeepFM模型的代码复现及重要结构解释
|
||||
### xDeepFM的整体代码逻辑
|
||||
下面看下xDeepFM模型的具体实现， 这样可以从更细节的角度去了解这个模型， 这里我依然是参考的deepctr的代码风格，这种函数式模型编程更清晰一些，当然由于时间原因，我这里目前只完成了一个tf2版本的(pytorch版本的后面有时间会补上)。 这里先看下xDeepFM的全貌:
|
||||
|
||||
```python
|
||||
def xDeepFM(linear_feature_columns, dnn_feature_columns, cin_size=[128, 128]):
|
||||
# 构建输入层，即所有特征对应的Input()层，这里使用字典的形式返回，方便后续构建模型
|
||||
dense_input_dict, sparse_input_dict = build_input_layers(linear_feature_columns+dnn_feature_columns)
|
||||
|
||||
# 构建模型的输入层，模型的输入层不能是字典的形式，应该将字典的形式转换成列表的形式
|
||||
# 注意：这里实际的输入预Input层对应，是通过模型输入时候的字典数据的key与对应name的Input层
|
||||
input_layers = list(dense_input_dict.values()) + list(sparse_input_dict.values())
|
||||
|
||||
# 线性部分的计算逻辑 -- linear
|
||||
linear_logits = get_linear_logits(dense_input_dict, sparse_input_dict, linear_feature_columns)
|
||||
|
||||
# 构建维度为k的embedding层，这里使用字典的形式返回，方便后面搭建模型
|
||||
# 线性层和dnn层统一的embedding层
|
||||
embedding_layer_dict = build_embedding_layers(linear_feature_columns+dnn_feature_columns, sparse_input_dict, is_linear=False)
|
||||
|
||||
# DNN侧的计算逻辑 -- Deep
|
||||
# 将dnn_feature_columns里面的连续特征筛选出来，并把相应的Input层拼接到一块
|
||||
dnn_dense_feature_columns = list(filter(lambda x: isinstance(x, DenseFeat), dnn_feature_columns)) if dnn_feature_columns else []
|
||||
dnn_dense_feature_columns = [fc.name for fc in dnn_dense_feature_columns]
|
||||
dnn_concat_dense_inputs = Concatenate(axis=1)([dense_input_dict[col] for col in dnn_dense_feature_columns])
|
||||
|
||||
# 将dnn_feature_columns里面的离散特征筛选出来，相应的embedding层拼接到一块
|
||||
dnn_sparse_kd_embed = concat_embedding_list(dnn_feature_columns, sparse_input_dict, embedding_layer_dict, flatten=True)
|
||||
dnn_concat_sparse_kd_embed = Concatenate(axis=1)(dnn_sparse_kd_embed)
|
||||
|
||||
# DNN层的输入和输出
|
||||
dnn_input = Concatenate(axis=1)([dnn_concat_dense_inputs, dnn_concat_sparse_kd_embed])
|
||||
dnn_out = get_dnn_output(dnn_input)
|
||||
dnn_logits = Dense(1)(dnn_out)
|
||||
|
||||
# CIN侧的计算逻辑， 这里使用的DNN feature里面的sparse部分,这里不要flatten
|
||||
exFM_sparse_kd_embed = concat_embedding_list(dnn_feature_columns, sparse_input_dict, embedding_layer_dict, flatten=False)
|
||||
exFM_input = Concatenate(axis=1)(exFM_sparse_kd_embed)
|
||||
exFM_out = CIN(cin_size=cin_size)(exFM_input)
|
||||
exFM_logits = Dense(1)(exFM_out)
|
||||
|
||||
# 三边的结果stack
|
||||
stack_output = Add()([linear_logits, dnn_logits, exFM_logits])
|
||||
|
||||
# 输出层
|
||||
output_layer = Dense(1, activation='sigmoid')(stack_output)
|
||||
|
||||
model = Model(input_layers, output_layer)
|
||||
|
||||
return model
|
||||
```
|
||||
这种风格最好的一点，就是很容易从宏观上把握模型的整体逻辑。 首先，接收的输入是linear_feature_columns和dnn_feature_columns， 这两个是深度和宽度两侧的特征，具体选取要结合着场景来。 接下来，就是为这些特征建立相应的Input层，这里要分成连续特征和离散的特征，因为后面的处理方式不同， 连续特征的话可以直接拼了， 而离散特征的话，需要过一个embedding层转成低维稠密，这就是第一行代码干的事情了。
|
||||
|
||||
接下来， 计算线性部分，从上面xDeepFM的结构里面可以看出， 是分三路走的，线性，CIN和DNN路， 所以`get_linear_logits`就是线性这部分的计算结果，完成的是$w_1x_1+w_2x_2..w_kx_k+b$， 这里面依然是连续和离散的不太一样，对于连续特征，直接过一个全连接就实现了这个操作，而离散特征，这里依然过一个embedding，不过这个维度是1，目的是转成了一个连续数值(这个相当于离散特征对应的w值)，这样后面进行总的加和操作即可。
|
||||
|
||||
接下来是另外两路，DNN这路也比较简单， dnn_feature_columns里面的离散特征过embedding，和连续特征拼接起来，然后过DNN即可。 CIN这路使用的是dnn_feature_columns里面的离散embedding特征，进行显性高阶交叉，这里的输入是`[None, field_num, embedding_dim]`的维度。这个也好理解，每个特征embedding之后，拼起来即可，注意`flatten=False`了。 这个输入，过CIN网络得到输出。
|
||||
|
||||
这样三路输出都得到，然后进行了一个加和，再连接一个Dense映射到最终输出。这就是整体的逻辑了，关于每个部分的具体细节，可以看代码。 下面主要是看看CIN这个网络是怎么实现的，因为其他的在之前的模型里面也基本是类似的操作，比如前面DIEN，DSIN版本，并且我后面项目里面补充了DCN的deepctr风格版，这个和那个超级像，唯一不同的就是把CrossNet换成了CIN，所以这个如果感觉看不大懂，可以先看那个网络代码。下面说CIN。
|
||||
### CIN网络的代码实现细节
|
||||
再具体代码实现， 我们先简单捋一下CIN网络的实现过程，这里的输入是`[None, field_num embed_dim]`的维度，在CIN里面，我们知道接下来的话，就是每一层会有$H_k$个神经元， 而每个神经元的计算要根据上面的那个计算公式，也就是$X_0$要和前面一层的输出两两embedding，加权求和再求和的方式。 而从CNN的角度来看，这个过程可以是这样，对于每一层的计算，先$X_0$和$X_k$进行外积运算(相当于两两embedding)，然后采用$H_k$个过滤器对前面的结果逐通道卷积就能得到每一层的$X_k$了。 最后的输出是每一层的$X_k$拼接起来，然后在embedding维度上的求和。 所以依据这个思路，就能得到下面的实现代码:
|
||||
|
||||
```python
|
||||
class CIN(Layer):
|
||||
def __init__(self, cin_size, l2_reg=1e-4):
|
||||
"""
|
||||
:param: cin_size: A list. [H_1, H_2, ....H_T], a list of number of layers
|
||||
"""
|
||||
super(CIN, self).__init__()
|
||||
self.cin_size = cin_size
|
||||
self.l2_reg = l2_reg
|
||||
|
||||
def build(self, input_shape):
|
||||
# input_shape [None, field_nums, embedding_dim]
|
||||
self.field_nums = input_shape[1]
|
||||
|
||||
# CIN 的每一层大小，这里加入第0层，也就是输入层H_0
|
||||
self.field_nums = [self.field_nums] + self.cin_size
|
||||
|
||||
# 过滤器
|
||||
self.cin_W = {
|
||||
'CIN_W_' + str(i): self.add_weight(
|
||||
name='CIN_W_' + str(i),
|
||||
shape = (1, self.field_nums[0] * self.field_nums[i], self.field_nums[i+1]), # 这个大小要理解
|
||||
initializer='random_uniform',
|
||||
regularizer=l2(self.l2_reg),
|
||||
trainable=True
|
||||
)
|
||||
for i in range(len(self.field_nums)-1)
|
||||
}
|
||||
|
||||
super(CIN, self).build(input_shape)
|
||||
|
||||
def call(self, inputs):
|
||||
# inputs [None, field_num, embed_dim]
|
||||
embed_dim = inputs.shape[-1]
|
||||
hidden_layers_results = [inputs]
|
||||
|
||||
# 从embedding的维度把张量一个个的切开,这个为了后面逐通道进行卷积，算起来好算
|
||||
# 这个结果是个list， list长度是embed_dim, 每个元素维度是[None, field_nums[0], 1] field_nums[0]即输入的特征个数
|
||||
# 即把输入的[None, field_num, embed_dim]，切成了embed_dim个[None, field_nums[0], 1]的张量
|
||||
split_X_0 = tf.split(hidden_layers_results[0], embed_dim, 2)
|
||||
|
||||
for idx, size in enumerate(self.cin_size):
|
||||
# 这个操作和上面是同理的，也是为了逐通道卷积的时候更加方便，分割的是当一层的输入Xk-1
|
||||
split_X_K = tf.split(hidden_layers_results[-1], embed_dim, 2) # embed_dim个[None, field_nums[i], 1] feild_nums[i] 当前隐藏层单元数量
|
||||
|
||||
# 外积的运算
|
||||
out_product_res_m = tf.matmul(split_X_0, split_X_K, transpose_b=True) # [embed_dim, None, field_nums[0], field_nums[i]]
|
||||
out_product_res_o = tf.reshape(out_product_res_m, shape=[embed_dim, -1, self.field_nums[0]*self.field_nums[idx]]) # 后两维合并起来
|
||||
out_product_res = tf.transpose(out_product_res_o, perm=[1, 0, 2]) # [None, dim, field_nums[0]*field_nums[i]]
|
||||
|
||||
# 卷积运算
|
||||
# 这个理解的时候每个样本相当于1张通道为1的照片 dim为宽度， field_nums[0]*field_nums[i]为长度
|
||||
# 这时候的卷积核大小是field_nums[0]*field_nums[i]的, 这样一个卷积核的卷积操作相当于在dim上进行滑动，每一次滑动会得到一个数
|
||||
# 这样一个卷积核之后，会得到dim个数，即得到了[None, dim, 1]的张量， 这个即当前层某个神经元的输出
|
||||
# 当前层一共有field_nums[i+1]个神经元， 也就是field_nums[i+1]个卷积核，最终的这个输出维度[None, dim, field_nums[i+1]]
|
||||
cur_layer_out = tf.nn.conv1d(input=out_product_res, filters=self.cin_W['CIN_W_'+str(idx)], stride=1, padding='VALID')
|
||||
|
||||
cur_layer_out = tf.transpose(cur_layer_out, perm=[0, 2, 1]) # [None, field_num[i+1], dim]
|
||||
|
||||
hidden_layers_results.append(cur_layer_out)
|
||||
|
||||
# 最后CIN的结果，要取每个中间层的输出，这里不要第0层的了
|
||||
final_result = hidden_layers_results[1:] # 这个的维度T个[None, field_num[i], dim] T 是CIN的网络层数
|
||||
|
||||
# 接下来在第一维度上拼起来
|
||||
result = tf.concat(final_result, axis=1) # [None, H1+H2+...HT, dim]
|
||||
# 接下来， dim维度上加和，并把第三个维度1干掉
|
||||
result = tf.reduce_sum(result, axis=-1, keepdims=False) # [None, H1+H2+..HT]
|
||||
|
||||
return result
|
||||
```
|
||||
这里主要是解释四点：
|
||||
1. 每一层的W的维度，是一个`[1, self.field_nums[0]*self.field_nums[i], self.field_nums[i+1]`的，首先，得明白这个`self.field_nums`存储的是每一层的神经单元个数，这里包括了输入层，也就是第0层。那么每一层的每个神经元计算都会有一个$W^{k,h}$， 这个的大小是$[H_{k-1},m]$维的，而第$K$层一共$H_k$个神经元，所以总的维度就是$[H_{k-1},m,H_k]$， 这和上面这个是一个意思，只不过前面扩展了维度1而已。
|
||||
2. 具体实现的时候，这里为了更方便计算，采用了切片的思路，也就是从embedding的维度把张量切开，这样外积的计算就会变得更加的简单。
|
||||
3. 具体卷积运算的时候，这里采用的是Conv1d，1维卷积对应的是一张张高度为1的图片(理解的时候可这么理解)，输入维度是`[None, in_width, in_channels]`的形式，而对应这里的数据是`[None, dim, field_nums[0]*field_nums[i]]`, 而这里的过滤器大小是`[1, field_nums[0]*field_nums[i], field_nums[i+1]`, 这样进行卷积的话，最后一个维度是卷积核的数量。是沿着dim这个维度卷积，得到的是`[None, dim, field_nums[i+1]]`的张量，这个就是第$i+1$层的输出了。和我画的
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210505221222945.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="image-20210308142624189" style="zoom: 60%;" />
|
||||
</div>
|
||||
|
||||
这个不同的是它把前面这个矩形Flatten了，得到了一个$[D,H_{k-1}\times m]$的二维矩阵，然后用$[1,H_{k-1}\times m]$的卷积核沿着D这个维度进行Conv1D， 这样就直接得到了一个D维向量， 而$H_k$个卷积核，就得到了$H_k\times D$的矩阵了。
|
||||
4. 每一层的输出$X_k$先加入到列表里面，然后在$H_i$的维度上拼接，再从$D$这个维度上求和，这样就得到了CIN的最终输出。
|
||||
|
||||
关于CIN的代码细节解释到这里啦，剩下的可以看后面链接里面的代码了。
|
||||
|
||||
## 总结
|
||||
这篇文章主要是介绍了又一个新的模型xDeepFM， 这个模型的改进焦点依然是特征之间的交互信息，xDeepFM的核心就是提出了一个新的CIN结构(这个是重点，面试的时候也喜欢问)，将基于Field的vecotr-wise思想引入到了Cross Network中，并保留了Cross高阶交互，自动叉乘，参数共享等优势，模型结构上保留了DeepFM的广深结构。主要有三大优势:
|
||||
1. CIN可以学习高效的学习有界的高阶特征；
|
||||
2. xDeepFM模型可以同时显示和隐式的学习高阶交互特征；
|
||||
3. 以vector-wise方式而不是bit-wise方式学习特征交互关系。
|
||||
|
||||
如果说DeepFM只是“Deep & FM”，那么xDeepFm就真正做到了”Deep” Factorization Machine。当然，xDeepFM的时间复杂度比较高，会是工业落地的主要瓶颈，后面需要进行一些优化操作。
|
||||
|
||||
这篇论文整体上还是非常清晰的，实验做的也非常丰富，语言描述上也非常地道，建议读读原文呀。
|
||||
|
||||
**参考**：
|
||||
* [xDeepFM原论文-建议读一下，这个真的超级不错](https://arxiv.org/abs/1803.05170)
|
||||
* [xDeepFM：名副其实的 ”Deep” Factorization Machine](https://zhuanlan.zhihu.com/p/57162373)
|
||||
* [深度CTR之xDeepFM：融合了显式和隐式特征交互关系的深度模型推荐系统](https://blog.csdn.net/oppo62258801/article/details/104236828)
|
||||
* [揭秘 Deep & Cross : 如何自动构造高阶交叉特征](https://zhuanlan.zhihu.com/p/55234968)
|
||||
* [一文读懂xDeepFM](https://zhuanlan.zhihu.com/p/110076629)
|
||||
* [推荐系统 - xDeepFM架构详解](https://blog.csdn.net/maqunfi/article/details/99664119)
|
||||
|
||||
177
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.4/DIEN.md
Normal file
177
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.4/DIEN.md
Normal file
@@ -0,0 +1,177 @@
|
||||
# DIEN
|
||||
## DIEN提出的动机
|
||||
在推荐场景，用户无需输入搜索关键词来表达意图，这种情况下捕捉用户兴趣并考虑兴趣的动态变化将是提升模型效果的关键。以Wide&Deep为代表的深度模型更多的是考虑不同field特征之间的相互作用，未关注用户兴趣。
|
||||
|
||||
DIN模型考虑了用户兴趣，并且强调用户兴趣是多样的，该模型使用注意力机制来捕捉和**target item**的相关的兴趣，这样以来用户的兴趣就会随着目标商品自适应的改变。但是大多该类模型包括DIN在内，直接将用户的行为当做用户的兴趣(因为DIN模型只是在行为序列上做了简单的特征处理)，但是用户潜在兴趣一般很难直接通过用户的行为直接表示，大多模型都没有挖掘用户行为背后真实的兴趣，捕捉用户兴趣的动态变化对用户兴趣的表示非常重要。DIEN相比于之前的模型，即对用户的兴趣进行建模，又对建模出来的用户兴趣继续建模得到用户的兴趣变化过程。
|
||||
|
||||
## DIEN模型原理
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20210218155901144.png" alt="image-20210218155901144" style="zoom:50%;" />
|
||||
</div>
|
||||
|
||||
模型的输入可以分成两大部分，一部分是用户的行为序列(这部分会通过兴趣提取层及兴趣演化层转换成与用户当前兴趣相关的embedding)，另一部分就是除了用户行为以外的其他所有特征，如Target id, Coontext Feature, UserProfile Feature，这些特征都转化成embedding的类型然后concat在一起（形成一个大的embedding）作为非行为相关的特征(这里可能也会存在一些非id类特征，应该可以直接进行concat)。最后DNN输入的部分由行为序列embedding和非行为特征embedding（多个特征concat到一起之后形成的一个大的向量）组成，将两者concat之后输入到DNN中。
|
||||
|
||||
所以DIEN模型的重点就是如何将用户的行为序列转换成与用户兴趣相关的向量，在DIN中是直接通过与target item计算序列中每个元素的注意力分数，然后加权求和得到最终的兴趣表示向量。在DIEN中使用了两层结构来建模用户兴趣相关的向量。
|
||||
|
||||
### Interest Exterator Layer
|
||||
|
||||
兴趣抽取层的输入原本是一个id序列(按照点击时间的先后顺序形成的一个序列)，通过Embedding层将其转化成一个embedding序列。然后使用GRU模块对兴趣进行抽取，GRU的输入是embedding层之后得到的embedding序列。对于GRU模块不是很了解的可以看一下[动手学深度学习中GRU相关的内容](https://zh.d2l.ai/chapter_recurrent-neural-networks/gru.html)
|
||||
|
||||
作者并没有直接完全使用原始的GRU来提取用户的兴趣，而是引入了一个辅助函数来指导用户兴趣的提取。作者认为如果直接使用GRU提取用户的兴趣，只能得到用户行为之间的依赖关系，不能有效的表示用户的兴趣。因为是用户的兴趣导致了用户的点击，用户的最后一次点击与用户点击之前的兴趣相关性就很强，但是直接使用行为序列训练GRU的话，只有用户最后一次点击的物品(也就是label，在这里可以认为是Target Ad), 那么最多就是能够捕捉到用户最后一次点击时的兴趣，而最后一次的兴趣又和前面点击过的物品在兴趣上是相关的，而前面点击的物品中并没有target item进行监督。**所以作者提出的辅助损失就是为了让行为序列中的每一个时刻都有一个target item进行监督训练，也就是使用下一个行为来监督兴趣状态的学习**
|
||||
|
||||
**辅助损失**
|
||||
首先需要明确的就是辅助损失是计算哪两个量的损失。计算的是用户每个时刻的兴趣表示（GRU每个时刻输出的隐藏状态形成的序列）与用户当前时刻实际点击的物品表示（输入的embedding序列）之间的损失，相当于是行为序列中的第t+1个物品与用户第t时刻的兴趣表示之间的损失**（为什么这里用户第t时刻的兴趣与第t+1时刻的真实点击做损失呢？我的理解是，只有知道了用户第t+1真实点击的商品，才能更好的确定用户第t时刻的兴趣）。**
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20210218163742638.png" alt="image-20210218163742638" style="zoom:50%;" />
|
||||
</div>
|
||||
|
||||
当然，如果只计算用户点击物品与其点击前一次的兴趣之间的损失，只能认为是正样本之间的损失，那么用户第t时刻的兴趣其实还有很多其他的未点击的商品，这些未点击的商品就是负样本，负样本一般通过从用户点击序列中采样得到，这样一来辅助损失中就包含了用户某个时刻下的兴趣及与该时刻兴趣相关的正负物品。所以最终的损失函数表示如下。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20210218162447125.png" alt="image-20210218162447125" style="zoom: 25%;" />
|
||||
</div>
|
||||
其中$h_t^i$表示的是用户$i$第$t$时刻的隐藏状态，可以表示用户第$t$时刻的兴趣向量，$e_b^i，\hat{e_b^i}$分别表示的是正负样本，$e_b^i[t+1]$表示的是用户$i$第$t+1$时刻点击的物品向量。
|
||||
|
||||
辅助损失会加到最终的目标损失(ctr损失)中一起进行优化，并且通过$\alpha$参数来平衡点击率和兴趣的关系
|
||||
$$
|
||||
L = L_{target} + \alpha L_{aux}
|
||||
$$
|
||||
|
||||
**引入辅助函数的函数有：**
|
||||
|
||||
- 辅助loss可以帮助GRU的隐状态更好地表示用户兴趣。
|
||||
|
||||
- RNN在长序列建模场景下梯度传播可能并不能很好的影响到序列开始部分，如果在序列的每个部分都引入一个辅助的监督信号，则可一定程度降低优化难度。
|
||||
|
||||
- 辅助loss可以给embedding层的学习带来更多语义信息，学习到item对应的更好的embedding。
|
||||
|
||||
### Interest Evolving Layer
|
||||
将用户的行为序列通过GRU+辅助损失建模之后，对用户行为序列中的兴趣进行了提取并表达成了向量的形式(GRU每个时刻输出的隐藏状态)。而用户的兴趣会因为外部环境或内部认知随着时间变化，特点如下：
|
||||
|
||||
- **兴趣是多样化的，可能发生漂移**。兴趣漂移对行为的影响是用户可能在一段时间内对各种书籍感兴趣，而在另一段时间却需要衣服
|
||||
|
||||
- 虽然兴趣可能会相互影响，但是**每一种兴趣都有自己的发展过程**，例如书和衣服的发展过程几乎是独立的。**而我们只关注与target item相关的演进过程。**
|
||||
|
||||
由于用户的兴趣是多样的，但是用户的每一种兴趣都有自己的发展过程，即使兴趣发生漂移我们可以只考虑用户与target item(广告或者商品)相关的兴趣演化过程，这样就不用考虑用户多样化的兴趣的问题了，而如何只获取与target item相关的信息，作者使用了与DIN模型中提取与target item相同的方法，来计算用户历史兴趣与target item之间的相似度，即这里也使用了DIN中介绍的局部激活单元(就是下图中的Attention模块)。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20210218180755462.png" alt="image-20210218180755462" style="zoom:70%;" />
|
||||
</div>
|
||||
|
||||
当得到了用户历史兴趣序列及兴趣序列与target item之间的相关性(注意力分数)之后，就需要再次对注意力序列进行建模得到用户注意力的演化过程，进一步表示用户最终的兴趣向量。此时的序列数据等同于有了一个序列及序列中每个向量的注意力权重，下面就是考虑如何使用这个注意力权重来一起优化序列建模的结果了。作者提出了三种注意力结合的GRU模型快：
|
||||
|
||||
1. **AIGRU:** 将注意力分数直接与输入的序列进行相乘，也就是权重越大的向量对应的值也越大, 其中$i_t^{'}, h_t, a_t$分别表示用户$i$在兴趣演化过程使用的GRU的第t时刻的输入，$h_t$表示的是兴趣抽取层第t时刻的输出，$a_t$表示的是$h_t$的注意力分数，这种方式的弊端是即使是零输入也会改变GRU的隐藏状态，所以相对较少的兴趣值也会影响兴趣的学习进化(根据GRU门的更新公式就可以知道，下一个隐藏状态的计算会用到上一个隐藏状态的信息，所以即使当前输入为0，最终隐藏状态也不会直接等于0，所以即使兴趣较少，也会影响到最终兴趣的演化)。
|
||||
$$
|
||||
i_t^{'} = h_t * a_t
|
||||
$$
|
||||
|
||||
2. **AGRU:** 将注意力分数直接作为GRU模块中，更新门的值，则重置门对应的值表示为$1-a_t$, 所以最终隐藏状态的更新公式表示为：其中$\hat{h_t^{'}}$表示的是候选隐藏状态。但是这种方式的弊端是弱化了兴趣之间的相关性，因为最终兴趣的更新前后是没关系的，只取决于输入的注意力分数
|
||||
$$
|
||||
h_t^{'} = (1-a_t)h_{t-1}^{'} + a_t * \tilde{h_t^{'}}
|
||||
$$
|
||||
|
||||
3. **AUGRU:** 将注意力分数作为更新门的权重，这样既兼顾了注意力分数很低时的状态更新值，也利用了兴趣之间的相关性，最终的表达式如下：
|
||||
$$
|
||||
\begin{align}
|
||||
& \tilde{u_t^{'}} = a_t * u_t \\
|
||||
& h_t^{'} = (1-\tilde{u_t^{'}})h_{t-1}^{'} + \tilde{u_t^{'}} * \tilde{h_t^{'}}
|
||||
\end{align}
|
||||
$$
|
||||
|
||||
**建模兴趣演化过程的好处：**
|
||||
- 追踪用户的interest可以使我们学习final interest的表达时包含更多的历史信息
|
||||
- 可以根据interest的变化趋势更好地进行CTR预测
|
||||
|
||||
## 代码实现
|
||||
下面我们看下DIN的代码复现，这里主要是给大家说一下这个模型的设计逻辑，参考了deepctr的函数API的编程风格， 具体的代码以及示例大家可以去参考后面的GitHub，里面已经给出了详细的注释， 这里主要分析模型的逻辑这块。关于函数API的编程式风格，我们还给出了一份文档， 大家可以先看这个，再看后面的代码部分，会更加舒服些。下面开始：
|
||||
|
||||
这里主要和大家说一下DIN模型的总体运行逻辑，这样可以让大家从宏观的层面去把握模型的编写过程。该模型所使用的数据集是movielens数据集， 具体介绍可以参考后面的GitHub。 因为上面反复强调了DIN的应用场景，需要基于用户的历史行为数据， 所以在这个数据集中会有用户过去对电影评分的一系列行为。这在之前的数据集中往往是看不到的。 大家可以导入数据之后自行查看这种行为特征(hist_behavior)。另外还有一点需要说明的是这种历史行为是序列性质的特征， 并且**不同的用户这种历史行为特征长度会不一样**， 但是我们的神经网络是要求序列等长的，所以这种情况我们一般会按照最长的序列进行padding的操作(不够长的填0)， 而到具体层上进行运算的时候，会用mask掩码的方式标记出这些填充的位置，好保证计算的准确性。 在我们给出的代码中，大家会在AttentionPoolingLayer层的前向传播中看到这种操作。下面开始说编写逻辑：
|
||||
|
||||
首先， DIN模型的输入特征大致上分为了三类： Dense(连续型), Sparse(离散型), VarlenSparse(变长离散型)，也就是指的上面的历史行为数据。而不同的类型特征也就决定了后面处理的方式会不同：
|
||||
|
||||
* Dense型特征：由于是数值型了，这里为每个这样的特征建立Input层接收这种输入， 然后拼接起来先放着，等离散的那边处理好之后，和离散的拼接起来进DNN
|
||||
* Sparse型特征，为离散型特征建立Input层接收输入，然后需要先通过embedding层转成低维稠密向量，然后拼接起来放着，等变长离散那边处理好之后， 一块拼起来进DNN， 但是这里面要注意有个特征的embedding向量还得拿出来用，就是候选商品的embedding向量，这个还得和后面的计算相关性，对历史行为序列加权。
|
||||
* VarlenSparse型特征：这个一般指的用户的历史行为特征，变长数据， 首先会进行padding操作成等长， 然后建立Input层接收输入，然后通过embedding层得到各自历史行为的embedding向量， 拿着这些向量与上面的候选商品embedding向量进入AttentionPoolingLayer去对这些历史行为特征加权合并，最后得到输出。
|
||||
|
||||
通过上面的三种处理， 就得到了处理好的连续特征，离散特征和变长离散特征， 接下来把这三种特征拼接，进DNN网络，得到最后的输出结果即可。所以有了这个解释， 就可以放DIN模型的代码全貌了，大家可以感受下我上面解释的：
|
||||
|
||||
```python
|
||||
def DIEN(feature_columns, behavior_feature_list, behavior_seq_feature_list, neg_seq_feature_list, use_neg_sample=False, alpha=1.0):
|
||||
# 构建输入层
|
||||
input_layer_dict = build_input_layers(feature_columns)
|
||||
|
||||
# 将Input层转化为列表的形式作为model的输入
|
||||
input_layers = list(input_layer_dict.values()) # 各个输入层
|
||||
user_behavior_length = input_layer_dict["hist_len"]
|
||||
|
||||
# 筛选出特征中的sparse_fea, dense_fea, varlen_fea
|
||||
sparse_feature_columns = list(filter(lambda x: isinstance(x, SparseFeat), feature_columns)) if feature_columns else []
|
||||
dense_feature_columns = list(filter(lambda x: isinstance(x, DenseFeat), feature_columns)) if feature_columns else []
|
||||
varlen_sparse_feature_columns = list(filter(lambda x: isinstance(x, VarLenSparseFeat), feature_columns)) if feature_columns else []
|
||||
|
||||
# 获取dense
|
||||
dnn_dense_input = []
|
||||
for fc in dense_feature_columns:
|
||||
dnn_dense_input.append(input_layer_dict[fc.name])
|
||||
|
||||
# 将所有的dense特征拼接
|
||||
dnn_dense_input = concat_input_list(dnn_dense_input)
|
||||
|
||||
# 构建embedding字典
|
||||
embedding_layer_dict = build_embedding_layers(feature_columns, input_layer_dict)
|
||||
|
||||
# 因为这里最终需要将embedding拼接后直接输入到全连接层(Dense)中, 所以需要Flatten
|
||||
dnn_sparse_embed_input = concat_embedding_list(sparse_feature_columns, input_layer_dict, embedding_layer_dict, flatten=True)
|
||||
# 将所有sparse特征的embedding进行拼接
|
||||
dnn_sparse_input = concat_input_list(dnn_sparse_embed_input)
|
||||
|
||||
# 获取当前的行为特征(movie)的embedding，这里有可能有多个行为产生了行为序列，所以需要使用列表将其放在一起
|
||||
query_embed_list = embedding_lookup(behavior_feature_list, input_layer_dict, embedding_layer_dict)
|
||||
# 获取行为序列(movie_id序列, hist_movie_id) 对应的embedding，这里有可能有多个行为产生了行为序列，所以需要使用列表将其放在一起
|
||||
keys_embed_list = embedding_lookup(behavior_seq_feature_list, input_layer_dict, embedding_layer_dict)
|
||||
# 把q,k的embedding拼在一块
|
||||
query_emb, keys_emb = concat_input_list(query_embed_list), concat_input_list(keys_embed_list)
|
||||
|
||||
# 采样的负行为
|
||||
neg_uiseq_embed_list = embedding_lookup(neg_seq_feature_list, input_layer_dict, embedding_layer_dict)
|
||||
neg_concat_behavior = concat_input_list(neg_uiseq_embed_list)
|
||||
|
||||
# 兴趣进化层的计算过程
|
||||
dnn_seq_input, aux_loss = interest_evolution(keys_emb, query_emb, user_behavior_length, neg_concat_behavior, gru_type="AUGRU")
|
||||
|
||||
# 后面的全连接层
|
||||
deep_input_embed = Concatenate()([dnn_dense_input, dnn_sparse_input, dnn_seq_input])
|
||||
|
||||
# 获取最终dnn的logits
|
||||
dnn_logits = get_dnn_logits(deep_input_embed, activation='prelu')
|
||||
model = Model(input_layers, dnn_logits)
|
||||
|
||||
# 加兴趣提取层的损失 这个比例可调
|
||||
if use_neg_sample:
|
||||
model.add_loss(alpha * aux_loss)
|
||||
|
||||
# 所有变量需要初始化
|
||||
tf.compat.v1.keras.backend.get_session().run(tf.compat.v1.global_variables_initializer())
|
||||
return model
|
||||
```
|
||||
|
||||
关于每一块的细节，这里就不解释了，在我们给出的GitHub代码中，我们已经加了非常详细的注释，大家看那个应该很容易看明白， 为了方便大家的阅读，我们这里还给大家画了一个整体的模型架构图，帮助大家更好的了解每一块以及前向传播。（画的图不是很规范，先将就看一下，后面我们会统一在优化一下这个手工图）。
|
||||
|
||||
下面是一个通过keras画的模型结构图，为了更好的显示，数值特征和类别特征都只是选择了一小部分，画图的代码也在github中（看不清的话可以自己用代码生成之后使用其他的软件打开看）。
|
||||
|
||||
> 下面这个图失效了
|
||||
<div align=center>
|
||||
此处无图
|
||||
</div>
|
||||
|
||||
## 思考
|
||||
1. 对于知乎上大佬们对DIEN的探讨，你有什么看法呢？[也评Deep Interest Evolution Network](https://zhuanlan.zhihu.com/p/54838663)
|
||||
|
||||
|
||||
**参考资料**
|
||||
- [deepctr](https://github.com/shenweichen/DeepCTR)
|
||||
- [原论文](https://arxiv.org/pdf/1809.03672.pdf)
|
||||
- [论文阅读-阿里DIEN深度兴趣进化网络之总体解读](https://mp.weixin.qq.com/s/IlVZCVtDco3hWuvnsUmekg)
|
||||
- [也评Deep Interest Evolution Network](https://zhuanlan.zhihu.com/p/54838663)
|
||||
|
||||
177
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.4/DIN.md
Normal file
177
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.4/DIN.md
Normal file
@@ -0,0 +1,177 @@
|
||||
# DIN
|
||||
## 动机
|
||||
Deep Interest Network(DIIN)是2018年阿里巴巴提出来的模型， 该模型基于业务的观察，从实际应用的角度进行改进，相比于之前很多“学术风”的深度模型， 该模型更加具有业务气息。该模型的应用场景是阿里巴巴的电商广告推荐业务， 这样的场景下一般**会有大量的用户历史行为信息**， 这个其实是很关键的，因为DIN模型的创新点或者解决的问题就是使用了注意力机制来对用户的兴趣动态模拟， 而这个模拟过程存在的前提就是用户之前有大量的历史行为了，这样我们在预测某个商品广告用户是否点击的时候，就可以参考他之前购买过或者查看过的商品，这样就能猜测出用户的大致兴趣来，这样我们的推荐才能做的更加到位，所以这个模型的使用场景是**非常注重用户的历史行为特征（历史购买过的商品或者类别信息）**，也希望通过这一点，能够和前面的一些深度学习模型对比一下。
|
||||
|
||||
在个性化的电商广告推荐业务场景中，也正式由于用户留下了大量的历史交互行为，才更加看出了之前的深度学习模型(作者统称Embeding&MLP模型)的不足之处。如果学习了前面的各种深度学习模型，就会发现Embeding&MLP模型对于这种推荐任务一般有着差不多的固定处理套路，就是大量稀疏特征先经过embedding层， 转成低维稠密的，然后进行拼接，最后喂入到多层神经网络中去。
|
||||
|
||||
这些模型在这种个性化广告点击预测任务中存在的问题就是**无法表达用户广泛的兴趣**，因为这些模型在得到各个特征的embedding之后，就蛮力拼接了，然后就各种交叉等。这时候根本没有考虑之前用户历史行为商品具体是什么，究竟用户历史行为中的哪个会对当前的点击预测带来积极的作用。 而实际上，对于用户点不点击当前的商品广告，很大程度上是依赖于他的历史行为的，王喆老师举了个例子
|
||||
|
||||
>假设广告中的商品是键盘， 如果用户历史点击的商品中有化妆品， 包包，衣服， 洗面奶等商品， 那么大概率上该用户可能是对键盘不感兴趣的， 而如果用户历史行为中的商品有鼠标， 电脑，iPad，手机等， 那么大概率该用户对键盘是感兴趣的， 而如果用户历史商品中有鼠标， 化妆品， T-shirt和洗面奶， 鼠标这个商品embedding对预测“键盘”广告的点击率的重要程度应该大于后面的那三个。
|
||||
|
||||
这里也就是说如果是之前的那些深度学习模型，是没法很好的去表达出用户这广泛多样的兴趣的，如果想表达的准确些， 那么就得加大隐向量的维度，让每个特征的信息更加丰富， 那这样带来的问题就是计算量上去了，毕竟真实情景尤其是电商广告推荐的场景，特征维度的规模是非常大的。 并且根据上面的例子， 也**并不是用户所有的历史行为特征都会对某个商品广告点击预测起到作用**。所以对于当前某个商品广告的点击预测任务，没必要考虑之前所有的用户历史行为。
|
||||
|
||||
这样， DIN的动机就出来了，在业务的角度，我们应该自适应的去捕捉用户的兴趣变化，这样才能较为准确的实施广告推荐；而放到模型的角度， 我们应该**考虑到用户的历史行为商品与当前商品广告的一个关联性**，如果用户历史商品中很多与当前商品关联，那么说明该商品可能符合用户的品味，就把该广告推荐给他。而一谈到关联性的话， 我们就容易想到“注意力”的思想了， 所以为了更好的从用户的历史行为中学习到与当前商品广告的关联性，学习到用户的兴趣变化， 作者把注意力引入到了模型，设计了一个"local activation unit"结构，利用候选商品和历史问题商品之间的相关性计算出权重，这个就代表了对于当前商品广告的预测，用户历史行为的各个商品的重要程度大小， 而加入了注意力权重的深度学习网络，就是这次的主角DIN， 下面具体来看下该模型。
|
||||
|
||||
## DIN模型结构及原理
|
||||
在具体分析DIN模型之前， 我们还得先介绍两块小内容，一个是DIN模型的数据集和特征表示， 一个是上面提到的之前深度学习模型的基线模型， 有了这两个， 再看DIN模型，就感觉是水到渠成了。
|
||||
|
||||
### 特征表示
|
||||
工业上的CTR预测数据集一般都是`multi-group categorial form`的形式，就是类别型特征最为常见，这种数据集一般长这样：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210118190044920.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" style="zoom: 67%;" />
|
||||
</div>
|
||||
|
||||
这里的亮点就是框出来的那个特征，这个包含着丰富的用户兴趣信息。
|
||||
|
||||
对于特征编码，作者这里举了个例子：`[weekday=Friday, gender=Female, visited_cate_ids={Bag,Book}, ad_cate_id=Book]`， 这种情况我们知道一般是通过one-hot的形式对其编码， 转成系数的二值特征的形式。但是这里我们会发现一个`visted_cate_ids`， 也就是用户的历史商品列表， 对于某个用户来讲，这个值是个多值型的特征， 而且还要知道这个特征的长度不一样长，也就是用户购买的历史商品个数不一样多，这个显然。这个特征的话，我们一般是用到multi-hot编码，也就是可能不止1个1了，有哪个商品，对应位置就是1， 所以经过编码后的数据长下面这个样子：
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210118185933510.png" style="zoom:67%;" />
|
||||
</div>
|
||||
这个就是喂入模型的数据格式了，这里还要注意一点 就是上面的特征里面没有任何的交互组合，也就是没有做特征交叉。这个交互信息交给后面的神经网络去学习。
|
||||
|
||||
### 基线模型
|
||||
|
||||
这里的base 模型，就是上面提到过的Embedding&MLP的形式， 这个之所以要介绍，就是因为DIN网络的基准也是他，只不过在这个的基础上添加了一个新结构(注意力网络)来学习当前候选广告与用户历史行为特征的相关性，从而动态捕捉用户的兴趣。
|
||||
|
||||
基准模型的结构相对比较简单，我们前面也一直用这个基准， 分为三大模块：Embedding layer，Pooling & Concat layer和MLP， 结构如下:
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210118191224464.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" style="zoom:80%;" />
|
||||
</div>
|
||||
|
||||
前面的大部分深度模型结构也是遵循着这个范式套路， 简介一下各个模块。
|
||||
|
||||
1. **Embedding layer**：这个层的作用是把高维稀疏的输入转成低维稠密向量， 每个离散特征下面都会对应着一个embedding词典， 维度是$D\times K$， 这里的$D$表示的是隐向量的维度， 而$K$表示的是当前离散特征的唯一取值个数, 这里为了好理解，这里举个例子说明，就比如上面的weekday特征：
|
||||
|
||||
> 假设某个用户的weekday特征就是周五，化成one-hot编码的时候，就是[0,0,0,0,1,0,0]表示，这里如果再假设隐向量维度是D， 那么这个特征对应的embedding词典是一个$D\times7$的一个矩阵(每一列代表一个embedding，7列正好7个embedding向量，对应周一到周日)，那么该用户这个one-hot向量经过embedding层之后会得到一个$D\times1$的向量，也就是周五对应的那个embedding，怎么算的，其实就是$embedding矩阵* [0,0,0,0,1,0,0]^T$ 。其实也就是直接把embedding矩阵中one-hot向量为1的那个位置的embedding向量拿出来。 这样就得到了稀疏特征的稠密向量了。其他离散特征也是同理，只不过上面那个multi-hot编码的那个，会得到一个embedding向量的列表，因为他开始的那个multi-hot向量不止有一个是1，这样乘以embedding矩阵，就会得到一个列表了。通过这个层，上面的输入特征都可以拿到相应的稠密embedding向量了。
|
||||
|
||||
2. **pooling layer and Concat layer**： pooling层的作用是将用户的历史行为embedding这个最终变成一个定长的向量，因为每个用户历史购买的商品数是不一样的， 也就是每个用户multi-hot中1的个数不一致，这样经过embedding层，得到的用户历史行为embedding的个数不一样多，也就是上面的embedding列表$t_i$不一样长， 那么这样的话，每个用户的历史行为特征拼起来就不一样长了。 而后面如果加全连接网络的话，我们知道，他需要定长的特征输入。 所以往往用一个pooling layer先把用户历史行为embedding变成固定长度(统一长度)，所以有了这个公式：
|
||||
$$
|
||||
e_i=pooling(e_{i1}, e_{i2}, ...e_{ik})
|
||||
$$
|
||||
这里的$e_{ij}$是用户历史行为的那些embedding。$e_i$就变成了定长的向量， 这里的$i$表示第$i$个历史特征组(是历史行为，比如历史的商品id，历史的商品类别id等)， 这里的$k$表示对应历史特种组里面用户购买过的商品数量，也就是历史embedding的数量，看上面图里面的user behaviors系列，就是那个过程了。 Concat layer层的作用就是拼接了，就是把这所有的特征embedding向量，如果再有连续特征的话也算上，从特征维度拼接整合，作为MLP的输入。
|
||||
|
||||
3. **MLP**：这个就是普通的全连接，用了学习特征之间的各种交互。
|
||||
|
||||
4. **Loss**: 由于这里是点击率预测任务， 二分类的问题，所以这里的损失函数用的负的log对数似然：
|
||||
$$
|
||||
L=-\frac{1}{N} \sum_{(\boldsymbol{x}, y) \in \mathcal{S}}(y \log p(\boldsymbol{x})+(1-y) \log (1-p(\boldsymbol{x})))
|
||||
$$
|
||||
|
||||
这就是base 模型的全貌， 这里应该能看出这种模型的问题， 通过上面的图也能看出来， 用户的历史行为特征和当前的候选广告特征在全都拼起来给神经网络之前，是一点交互的过程都没有， 而拼起来之后给神经网络，虽然是有了交互了，但是原来的一些信息，比如，每个历史商品的信息会丢失了一部分，因为这个与当前候选广告商品交互的是池化后的历史特征embedding， 这个embedding是综合了所有的历史商品信息， 这个通过我们前面的分析，对于预测当前广告点击率，并不是所有历史商品都有用，综合所有的商品信息反而会增加一些噪声性的信息，可以联想上面举得那个键盘鼠标的例子，如果加上了各种洗面奶，衣服啥的反而会起到反作用。其次就是这样综合起来，已经没法再看出到底用户历史行为中的哪个商品与当前商品比较相关，也就是丢失了历史行为中各个商品对当前预测的重要性程度。最后一点就是如果所有用户浏览过的历史行为商品，最后都通过embedding和pooling转换成了固定长度的embedding，这样会限制模型学习用户的多样化兴趣。
|
||||
|
||||
那么改进这个问题的思路有哪些呢？ 第一个就是加大embedding的维度，增加之前各个商品的表达能力，这样即使综合起来，embedding的表达能力也会加强， 能够蕴涵用户的兴趣信息，但是这个在大规模的真实推荐场景计算量超级大，不可取。 另外一个思路就是**在当前候选广告和用户的历史行为之间引入注意力的机制**，这样在预测当前广告是否点击的时候，让模型更关注于与当前广告相关的那些用户历史产品，也就是说**与当前商品更加相关的历史行为更能促进用户的点击行为**。 作者这里又举了之前的一个例子：
|
||||
> 想象一下，当一个年轻母亲访问电子商务网站时，她发现展示的新手袋很可爱，就点击它。让我们来分析一下点击行为的驱动力。<br><br>展示的广告通过软搜索这位年轻母亲的历史行为，发现她最近曾浏览过类似的商品，如大手提袋和皮包，从而击中了她的相关兴趣
|
||||
|
||||
第二个思路就是DIN的改进之处了。DIN通过给定一个候选广告，然后去注意与该广告相关的局部兴趣的表示来模拟此过程。 DIN不会通过使用同一向量来表达所有用户的不同兴趣，而是通过考虑历史行为的相关性来自适应地计算用户兴趣的表示向量（对于给的广告）。 该表示向量随不同广告而变化。下面看一下DIN模型。
|
||||
|
||||
### DIN模型架构
|
||||
|
||||
上面分析完了base模型的不足和改进思路之后，DIN模型的结构就呼之欲出了，首先，它依然是采用了基模型的结构，只不过是在这个的基础上加了一个注意力机制来学习用户兴趣与当前候选广告间的关联程度， 用论文里面的话是，引入了一个新的`local activation unit`， 这个东西用在了用户历史行为特征上面， **能够根据用户历史行为特征和当前广告的相关性给用户历史行为特征embedding进行加权**。我们先看一下它的结构，然后看一下这个加权公式。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210118220015871.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" style="zoom: 80%;" />
|
||||
</div>
|
||||
|
||||
这里改进的地方已经框出来了，这里会发现相比于base model， 这里加了一个local activation unit， 这里面是一个前馈神经网络，输入是用户历史行为商品和当前的候选商品， 输出是它俩之间的相关性， 这个相关性相当于每个历史商品的权重，把这个权重与原来的历史行为embedding相乘求和就得到了用户的兴趣表示$\boldsymbol{v}_{U}(A)$, 这个东西的计算公式如下：
|
||||
$$
|
||||
\boldsymbol{v}_{U}(A)=f\left(\boldsymbol{v}_{A}, \boldsymbol{e}_{1}, \boldsymbol{e}_{2}, \ldots, \boldsymbol{e}_{H}\right)=\sum_{j=1}^{H} a\left(\boldsymbol{e}_{j}, \boldsymbol{v}_{A}\right) \boldsymbol{e}_{j}=\sum_{j=1}^{H} \boldsymbol{w}_{j} \boldsymbol{e}_{j}
|
||||
$$
|
||||
这里的$\{\boldsymbol{v}_{A}, \boldsymbol{e}_{1}, \boldsymbol{e}_{2}, \ldots, \boldsymbol{e}_{H}\}$是用户$U$的历史行为特征embedding， $v_{A}$表示的是候选广告$A$的embedding向量， $a(e_j, v_A)=w_j$表示的权重或者历史行为商品与当前广告$A$的相关性程度。$a(\cdot)$表示的上面那个前馈神经网络，也就是那个所谓的注意力机制， 当然，看图里的话，输入除了历史行为向量和候选广告向量外，还加了一个它俩的外积操作，作者说这里是有利于模型相关性建模的显性知识。
|
||||
|
||||
这里有一点需要特别注意，就是这里的权重加和不是1， 准确的说这里不是权重， 而是直接算的相关性的那种分数作为了权重，也就是平时的那种scores(softmax之前的那个值)，这个是为了保留用户的兴趣强度。
|
||||
|
||||
## DIN实现
|
||||
|
||||
下面我们看下DIN的代码复现，这里主要是给大家说一下这个模型的设计逻辑，参考了deepctr的函数API的编程风格， 具体的代码以及示例大家可以去参考后面的GitHub，里面已经给出了详细的注释， 这里主要分析模型的逻辑这块。关于函数API的编程式风格，我们还给出了一份文档， 大家可以先看这个，再看后面的代码部分，会更加舒服些。下面开始：
|
||||
|
||||
这里主要和大家说一下DIN模型的总体运行逻辑，这样可以让大家从宏观的层面去把握模型的编写过程。该模型所使用的数据集是movielens数据集， 具体介绍可以参考后面的GitHub。 因为上面反复强调了DIN的应用场景，需要基于用户的历史行为数据， 所以在这个数据集中会有用户过去对电影评分的一系列行为。这在之前的数据集中往往是看不到的。 大家可以导入数据之后自行查看这种行为特征(hist_behavior)。另外还有一点需要说明的是这种历史行为是序列性质的特征， 并且**不同的用户这种历史行为特征长度会不一样**， 但是我们的神经网络是要求序列等长的，所以这种情况我们一般会按照最长的序列进行padding的操作(不够长的填0)， 而到具体层上进行运算的时候，会用mask掩码的方式标记出这些填充的位置，好保证计算的准确性。 在我们给出的代码中，大家会在AttentionPoolingLayer层的前向传播中看到这种操作。下面开始说编写逻辑：
|
||||
|
||||
首先， DIN模型的输入特征大致上分为了三类： Dense(连续型), Sparse(离散型), VarlenSparse(变长离散型)，也就是指的上面的历史行为数据。而不同的类型特征也就决定了后面处理的方式会不同：
|
||||
|
||||
* Dense型特征：由于是数值型了，这里为每个这样的特征建立Input层接收这种输入， 然后拼接起来先放着，等离散的那边处理好之后，和离散的拼接起来进DNN
|
||||
* Sparse型特征，为离散型特征建立Input层接收输入，然后需要先通过embedding层转成低维稠密向量，然后拼接起来放着，等变长离散那边处理好之后， 一块拼起来进DNN， 但是这里面要注意有个特征的embedding向量还得拿出来用，就是候选商品的embedding向量，这个还得和后面的计算相关性，对历史行为序列加权。
|
||||
* VarlenSparse型特征：这个一般指的用户的历史行为特征，变长数据， 首先会进行padding操作成等长， 然后建立Input层接收输入，然后通过embedding层得到各自历史行为的embedding向量， 拿着这些向量与上面的候选商品embedding向量进入AttentionPoolingLayer去对这些历史行为特征加权合并，最后得到输出。
|
||||
|
||||
通过上面的三种处理， 就得到了处理好的连续特征，离散特征和变长离散特征， 接下来把这三种特征拼接，进DNN网络，得到最后的输出结果即可。所以有了这个解释， 就可以放DIN模型的代码全貌了，大家可以感受下我上面解释的：
|
||||
|
||||
```python
|
||||
# DIN网络搭建
|
||||
def DIN(feature_columns, behavior_feature_list, behavior_seq_feature_list):
|
||||
"""
|
||||
这里搭建DIN网络，有了上面的各个模块，这里直接拼起来
|
||||
:param feature_columns: A list. 里面的每个元素是namedtuple(元组的一种扩展类型，同时支持序号和属性名访问组件)类型，表示的是数据的特征封装版
|
||||
:param behavior_feature_list: A list. 用户的候选行为列表
|
||||
:param behavior_seq_feature_list: A list. 用户的历史行为列表
|
||||
"""
|
||||
# 构建Input层并将Input层转成列表作为模型的输入
|
||||
input_layer_dict = build_input_layers(feature_columns)
|
||||
input_layers = list(input_layer_dict.values())
|
||||
|
||||
# 筛选出特征中的sparse和Dense特征， 后面要单独处理
|
||||
sparse_feature_columns = list(filter(lambda x: isinstance(x, SparseFeat), feature_columns))
|
||||
dense_feature_columns = list(filter(lambda x: isinstance(x, DenseFeat), feature_columns))
|
||||
|
||||
# 获取Dense Input
|
||||
dnn_dense_input = []
|
||||
for fc in dense_feature_columns:
|
||||
dnn_dense_input.append(input_layer_dict[fc.name])
|
||||
|
||||
# 将所有的dense特征拼接
|
||||
dnn_dense_input = concat_input_list(dnn_dense_input) # (None, dense_fea_nums)
|
||||
|
||||
# 构建embedding字典
|
||||
embedding_layer_dict = build_embedding_layers(feature_columns, input_layer_dict)
|
||||
|
||||
# 离散的这些特特征embedding之后，然后拼接，然后直接作为全连接层Dense的输入，所以需要进行Flatten
|
||||
dnn_sparse_embed_input = concat_embedding_list(sparse_feature_columns, input_layer_dict, embedding_layer_dict, flatten=True)
|
||||
|
||||
# 将所有的sparse特征embedding特征拼接
|
||||
dnn_sparse_input = concat_input_list(dnn_sparse_embed_input) # (None, sparse_fea_nums*embed_dim)
|
||||
|
||||
# 获取当前行为特征的embedding， 这里有可能有多个行为产生了行为列表，所以需要列表将其放在一起
|
||||
query_embed_list = embedding_lookup(behavior_feature_list, input_layer_dict, embedding_layer_dict)
|
||||
|
||||
# 获取历史行为的embedding， 这里有可能有多个行为产生了行为列表，所以需要列表将其放在一起
|
||||
keys_embed_list = embedding_lookup(behavior_seq_feature_list, input_layer_dict, embedding_layer_dict)
|
||||
# 使用注意力机制将历史行为的序列池化，得到用户的兴趣
|
||||
dnn_seq_input_list = []
|
||||
for i in range(len(keys_embed_list)):
|
||||
seq_embed = AttentionPoolingLayer()([query_embed_list[i], keys_embed_list[i]]) # (None, embed_dim)
|
||||
dnn_seq_input_list.append(seq_embed)
|
||||
|
||||
# 将多个行为序列的embedding进行拼接
|
||||
dnn_seq_input = concat_input_list(dnn_seq_input_list) # (None, hist_len*embed_dim)
|
||||
|
||||
# 将dense特征，sparse特征， 即通过注意力机制加权的序列特征拼接起来
|
||||
dnn_input = Concatenate(axis=1)([dnn_dense_input, dnn_sparse_input, dnn_seq_input]) # (None, dense_fea_num+sparse_fea_nums*embed_dim+hist_len*embed_dim)
|
||||
|
||||
# 获取最终的DNN的预测值
|
||||
dnn_logits = get_dnn_logits(dnn_input, activation='prelu')
|
||||
|
||||
model = Model(inputs=input_layers, outputs=dnn_logits)
|
||||
|
||||
return model
|
||||
```
|
||||
|
||||
关于每一块的细节，这里就不解释了，在我们给出的GitHub代码中，我们已经加了非常详细的注释，大家看那个应该很容易看明白， 为了方便大家的阅读，我们这里还给大家画了一个整体的模型架构图，帮助大家更好的了解每一块以及前向传播。（画的图不是很规范，先将就看一下，后面我们会统一在优化一下这个手工图）。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片DIN_aaaa.png" alt="DIN_aaaa" style="zoom: 70%;" />
|
||||
</div>
|
||||
|
||||
下面是一个通过keras画的模型结构图，为了更好的显示，数值特征和类别特征都只是选择了一小部分，画图的代码也在github中。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片din.png" alt="DIN_aaaa" style="zoom: 50%;" />
|
||||
</div>
|
||||
|
||||
## 思考
|
||||
DIN模型在工业上的应用还是比较广泛的， 大家可以自由去通过查资料看一下具体实践当中这个模型是怎么用的？ 有什么问题？比如行为序列的制作是否合理， 如果时间间隔比较长的话应不应该分一下段？ 再比如注意力机制那里能不能改成别的计算注意力的方式会好点？(我们也知道注意力机制的方式可不仅DNN这一种)， 再比如注意力权重那里该不该加softmax？ 这些其实都是可以值的思考探索的一些问题，根据实际的业务场景，大家也可以总结一些更加有意思的工业上应用该模型的技巧和tricks，欢迎一块讨论和分享。
|
||||
|
||||
**参考资料**
|
||||
* [DIN原论文](https://arxiv.org/pdf/1706.06978.pdf)
|
||||
* [deepctr](https://github.com/shenweichen/DeepCTR)
|
||||
* [AI上推荐 之 AFM与DIN模型（当推荐系统遇上了注意力机制）](https://blog.csdn.net/wuzhongqiang/article/details/109532346)
|
||||
* 王喆 - 《深度学习推荐系统》
|
||||
731
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.4/DSIN.md
Normal file
731
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.4/DSIN.md
Normal file
@@ -0,0 +1,731 @@
|
||||
## 写在前面
|
||||
DSIN全称是Deep Session Interest Network(深度会话兴趣网络)， 重点在这个Session上，这个是在DIEN的基础上又进行的一次演化，这个模型的改进出发点依然是如何通过用户的历史点击行为，从里面更好的提取用户的兴趣以及兴趣的演化过程，这个模型就是从user历史行为信息挖掘方向上进行演化的。而提出的动机呢？ 就是作者发现用户的行为序列的组成单位，其实应该是会话(按照用户的点击时间划分开的一段行为)，每个会话里面的点击行为呢？ 会高度相似，而会话与会话之间的行为，就不是那么相似了，但是像DIN，DIEN这两个模型，DIN的话，是直接忽略了行为之间的序列关系，使得对用户的兴趣建模或者演化不是很充分，而DIEN的话改进了DIN的序列关系的忽略缺点，但是忽视了行为序列的本质组成结构。所以阿里提出的DSIN模型就是从行为序列的组成结构会话的角度去进行用户兴趣的提取和演化过程的学习，在这个过程中用到了一些新的结构，比如Transformer中的多头注意力，比如双向LSTM结构，再比如前面的局部Attention结构。
|
||||
|
||||
|
||||
## DSIN模型的理论以及论文细节
|
||||
### DSIN的简介与进化动机
|
||||
DSIN模型全称叫做Deep Session Interest Network， 这个是阿里在2019年继DIEN之后的一个新模型， 这个模型依然是研究如何更好的从用户的历史行为中捕捉到用户的动态兴趣演化规律。而这个模型的改进动机呢？ 就是作者认为之前的序列模型，比如DIEN等，忽视了序列的本质结构其实是由会话组成的：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210310143019924.png#pic_center" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
这是个啥意思呢？ 其实举个例子就非常容易明白DIEN存在的问题了(DIN这里就不说了，这个存在的问题在DIEN那里说的挺详细了，这里看看DIEN有啥问题)，上一篇文章中我们说DIEN为了能够更好的利用用户的历史行为信息，把序列模型引进了推荐系统，用来学习用户历史行为之间的关系， 用兴趣提取层来学习各个历史行为之间的关系，而为了更有针对性的模拟与目标广告相关的兴趣进化路径，又在兴趣提取层后面加了注意力机制和兴趣进化层网络。这样理论上就感觉挺完美的了啊。这里依然是把DIEN拿过来，也方便和后面的DSIN对比：<br>
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210221165854948.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
但这个模型存在个啥问题呢？ **就是只关注了如何去改进网络，而忽略了用户历史行为序列本身的特点**， 其实我们仔细想想的话，用户过去可能有很多历史点击行为，比如`[item3, item45, item69, item21, .....]`， 这个按照用户的点击时间排好序了，既然我们说用户的兴趣是非常广泛且多变的，那么这一大串序列的商品中，往往出现的一个规律就是**在比较短的时间间隔内的商品往往会很相似，时间间隔长了之后，商品之间就会出现很大的差别**，这个是很容易理解的，一个用户在半个小时之内的浏览点击的几个商品的相似度和一个用户上午点击和晚上点击的商品的相似度很可能是不一样的。这其实就是作者说的`homogeneous`和`heterogeneous`。而DIEN模型呢？ 它并没有考虑这个问题，而是会直接把这一大串行为序列放入GRU让它自己去学(当然我们其实可以人工考虑这个问题，然后如果发现序列很长的话我们也可以分成多个样本哈，当然这里不考虑这个问题)，如果一大串序列一块让GRU学习的话，往往用户的行为快速改变和突然终止的序列会有很多噪声点，不利于模型的学习。
|
||||
|
||||
所以，作者这里就是从序列本身的特点出发， 把一个用户的行为序列分成了多个会话，所谓会话，其实就是按照时间间隔把序列分段，每一段的商品列表就是一个会话，那这时候，会话里面每个商品之间的相似度就比较大了，而会话与会话之间商品相似度就可能比较小。作者这里给了个例子：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210310144926564.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
这是某个用户过去的历史点击行为，然后按照30分钟的时间间隔进行的分段，分成了3段。这里就一下子看出上面说的那些是啥意思了吧。就像这个女生，前30分钟在看裤子，再过30分钟又停留在了化妆品，又过30分钟，又看衣服。这种现象是非常普遍的啊，反映了一个用户通常在某个会话里面会有非常单一的兴趣但是当过一段时间之后，兴趣就会突然的改变。这个时候如果再统一的考虑所有行为就不合理了呀。**这其实也是DSIN改进的动机了**， DSIN，这次的关键就是在S上。
|
||||
|
||||
那它要怎么改呢？ 如果是我们的话应该怎么改呢？ 那一定会说，这个简单啊，不是说DIEN没考虑序列本身的特点吗？ 既然我们发现了上面用户点击行为的这种会话规律，那么我们把序列进行分段，然后再用DIEN不就完事了？ 哈哈， 那当然可以呀， 如果想用DIEN的话确实可以这么玩， 但那样就没有新模型了啊，那不还是DIEN？ 这样的改进思路是没法发顶会的哟哈哈。 下面分析下人家是怎么改进的。
|
||||
|
||||
简单的说是用了四步，这个也是DSIN模型的整体逻辑：
|
||||
|
||||
1. 首先， 分段这个是必须的了吧，也就是在用户行为序列输入到模型之前，要按照固定的时间间隔(比如30分钟)给他分开段，每一段里面的商品序列称为一个会话Session。 这个叫做**会话划分层**
|
||||
|
||||
2. 然后呢，就是学习商品时间的依赖关系或者序列关系，由于上面把一个整的行为序列划分成了多段，那么在这里就是每一段的商品时间的序列关系要进行学习，当然我们说可以用GRU， 不过这里作者用了**多头的注意力机制**，这个东西是在**多个角度研究一个会话里面各个商品的关联关系**， 相比GRU来讲，没有啥梯度消失，并且可以并行计算，比GRU可强大多了。这个叫做**会话兴趣提取层**
|
||||
3. 上面研究了会话内各个商品之间的关联关系，接下来就是研究会话与会话之间的关系了，虽然我们说各个会话之间的关联性貌似不太大，但是可别忘了会话可是能够表示一段时间内用户兴趣的， 所以研究会话与会话的关系其实就是在学习用户兴趣的演化规律，这里用了**双向的LSTM**，不仅看从现在到未来的兴趣演化，还能学习未来到现在的变化规律， 这个叫做**会话交互层**。
|
||||
4. 既然会话内各个商品之间的关系学到了，会话与会话之间的关系学到了，然后呢？ 当然也是针对性的模拟与目标广告相关的兴趣进化路径了， 所以后面是**会话兴趣局部激活层**， 这个就是注意力机制， 每次关注与当前商品更相关的兴趣。
|
||||
|
||||
所以，我们细品一下，其实DSIN和思路和DIEN的思路是差不多的，无非就是用了一些新的结构，这样，我们就从宏观上感受了一波这个模型。接下来，研究架构细节了。 看看上面那几块到底是怎么玩的。
|
||||
|
||||
### DSIN的架构剖析
|
||||
这里在说DSIN之前，作者也是又复习了一下base model模型架构，这里我就不整理了，其实是和DIEN那里一模一样的，具体的可以参考我上一篇文章。直接看DSIN的架构：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210310151619214.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
这个模型第一印象又是挺吓人的。核心的就是上面剖析的那四块，这里也分别用不同颜色表示出来了。也及时右边的那几块，左边的那两块还是我们之前的套路，用户特征和商品特征的串联。这里主要研究右边那四块，作者在这里又强调了下DSIN的两个目的，而这两个目的就对应着本模型最核心的两个层(会话兴趣提取层和会话交互层)：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210310151921213.png#pic_center" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
#### Session Division Layer
|
||||
这一层是将用户的行为序列进行切分，首先将用户的点击行为按照时间排序，判断两个行为之间的时间间隔，如果前后间隔大于30min，就进行切分(划一刀)， 当然30min不是定死的，具体跟着自己的业务场景来。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210310152906432.png#pic_center" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
划分完了之后，我们就把一个行为序列$\mathbf{S}$转成了Sessions $\mathbf{Q}$，比如上面这个分成了4个会话，会分别用$\mathbf{Q_1}, \mathbf{Q_2}, \mathbf{Q_3}, \mathbf{Q_4}$表示。 第$k$个会话$\mathbf{Q_k}$中，又包含了$T$个行为，即
|
||||
$$
|
||||
\mathbf{Q}_{k}=\left[\mathbf{b}_{1} ; \ldots ; \mathbf{b}_{i} ; \ldots ; \mathbf{b}_{T}\right] \in \mathbb{R}^{T \times d_{\text {model }}}
|
||||
$$
|
||||
$\mathbf{b}_{i}$表示的是第$k$个会话里面的第$i$个点击行为(具体的item)，这个东西是一个$d_{model}$维的embedding向量。所以$\mathbf{Q}_{k}$是一个$T \times d_{\text {model }}$维的。 而整个大$\mathbf{Q}$, 就是一个$K\times T \times d_{\text {model }}$维的矩阵。 这里的$K$指的是session的个数。 这样，就把这个给捋明白了。但要注意，这个层是在embedding层之后呀，也就是各个商品转成了embedding向量之后，我们再进行切割。
|
||||
|
||||
#### Session Interest Extractor Layer
|
||||
这个层是学习每个会话中各个行为之间的关系，之前也分析过，在同一个会话中的各个商品的相关性是非常大的。此外，作者这里还提到，用户的随意的那种点击行为会偏离用户当前会话兴趣的表达，所以**为了捕获同一会话中行为之间的内在关系，同时降低这些不相关行为的影响**，这里采用了multi-head self-attention。关于这个东西， 这里不会详细整理，可以参考我之前的文章。这里只给出两个最核心关键的图，有了这两个图，这里的知识就非常容易理解了哈哈。
|
||||
|
||||
第一个，就是Transformer的编码器的一小块：
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210310154530852.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
拿过来是为了更好的对比，看DSIN的结构的第二层，其实就是这个东西。 而这个东西的整体的计算过程，我在之前的文章中剖析好了：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20200220195348122.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_16,color_FFFFFF,t_70" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
有了上面这两张图，在解释这里就非常好说了。
|
||||
|
||||
这一块其实是分两步的，第一步叫做位置编码，而第二步就是self-attention计算关联。 同样，DSIN中也是这两步，只不过第一步里面的位置编码，作者在这里做了点改进，称为**Bias Encoding**。先看看这个是怎么做的。
|
||||
>这里先解释下为啥要进行位置编码或者Bias Encoding， 这是因为我们说self-attention机制是要去学习会话里面各个商品之间的关系的， 而商品我们知道是一个按照时间排好的小序列，由于后面的self-attention并没有循环神经网络的迭代运算，所以我们必须提供每个字的位置信息给后面的self-attention，这样后面self-attention的输出结果才能蕴含商品之间的顺序信息。
|
||||
|
||||
在Transformer中，对输入的序列会进行Positional Encoding。Positional Encoding对序列中每个物品，以及每个物品对应的Embedding的每个位置，进行了处理，如下：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210310155625208.png#pic_center" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
上式中$pos$指的是某个会话里面item位于第几个位置位置, 取值范围是$[0, max\_len]$, $i$指的是词向量的某个维度, 取值范围是$[0, embed \_ dim]$, 上面有$sin$和$cos$一组公式, 也就是对应着$embed \_ dim$维度的一组奇数和偶数的序号的维度, 例如$0, 1$一组, $2, 3$一组, 分别用上面的$sin$和$cos$函数做处理, 从而产生不同的周期性变化, 而位置嵌入在$embed \_ dim$维度上随着维度序号增大, 周期变化会越来越慢, 而产生一种包含位置信息的纹理, 位置嵌入函数的周期从$2 \pi$到$10000 * 2 \pi$变化, 而每一个位置在$embed \_ dim$维度上都会得到不同周期的$sin$和$cos$函数的取值组合, 从而产生独一的纹理位置信息, 模型从而学到位置之间的依赖关系和自然语言的时序特性。这个在这里说可能有些迷糊，具体可以去另一篇文章看细节，**总结起来，就是通过这个公式，可以让每个item在每个embedding维度上都有独特的位置信息。但注意，位置编码的矩阵和输入的维度是一样的，这样两者加起来之后就相当于原来的序列加上了位置信息** 。
|
||||
|
||||
而这里，作者并不是用的这种方式，这是因为在这里还需要考虑各个会话之间的位置信息，毕竟这里是多个会话，并且各个会话之间也是有位置顺序的呀，所以还需要对每个会话添加一个Positional Encoding， 在DSIN中，这种对位置的处理，称为Bias Encoding。
|
||||
|
||||
于是乎作者在这里提出了个$\mathbf{B E} \in \mathbb{R}^{K \times T \times d_{\text {model }}}$，会发现这个东西的维度和会话分割层得到的$\mathbf{Q}$的维度也是一样的啊，其实这个东西就是这里使用的位置编码。那么这个东西咋计算呢？
|
||||
$$
|
||||
\mathbf{B} \mathbf{E}_{(k, t, c)}=\mathbf{w}_{k}^{K}+\mathbf{w}_{t}^{T}+\mathbf{w}_{c}^{C}
|
||||
$$
|
||||
$\mathbf{B} \mathbf{E}_{(k, t, c)}$表示的是第$k$个会话中，第$t$个物品在第$c$维度这个位置上的偏置项(是一个数), 其中$\mathbf{w}^{K} \in \mathbb{R}^{K}$表示的会话层次上的偏置项(位置信息)。如果有$n$个样本的话，这个应该是$[n, K, 1, 1]$的矩阵， 后面两个维度表示的$T$和$emb \_dim$。$\mathbf{w}^{T} \in \mathbb{R}^{T}$这个是在会话里面时间位置层次上的偏置项(位置信息)，这个应该是$[n, 1, T, 1]$的矩阵。$\mathbf{w}^{C} \in \mathbb{R}^{d_{\text {model }}}$这个是embedding维度层次上的偏置(位置信息)， 这个应该是$[n, 1, 1, d_{model}]$的矩阵。 而上面的$\mathbf{w}_{k}^{K},\mathbf{w}_{t}^{T},\mathbf{w}_{c}^{C}$都是表示某个维度上的具体的数字，所以$\mathbf{B} \mathbf{E}_{(k, t, c)}$也是一个数。
|
||||
|
||||
所以$\mathbf{B} \mathbf{E}$就是一个$[n,K, T, d_{model}]$的矩阵(这里其实是借助了广播机制的)，蕴含了每个会话，每个物品，每个embedding位置的位置信息，所以经过Bias编码之后，得到的结果如下：
|
||||
$$
|
||||
\mathbf{Q}=\mathbf{Q}+\mathbf{B} \mathbf{E}
|
||||
$$
|
||||
这个$\mathbf{Q}$的维度$[n,K, T, d_{model}]$， 当然这里我们先不考虑样本个数，所以是$[K, T, d_{model}]$。相比上面的transformer，这里会多出一个会话的维度来。
|
||||
|
||||
接下来，就是每个会话的序列都通过Transformer进行处理:
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210310163256416.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
一定要注意，这里说的是每个会话，这里我特意把下面的$Q_1$框出来了，就是每个$Q_i$都会走这个自注意力机制，因为我们算的是某个会话当中各个物品之间的关系。这里的计算和Transformer的block的计算是一模一样的了， 我这里就拿一个会话来解释。
|
||||
|
||||
首先$Q_1$这是一个$T\times embed \_dim$的一个矩阵，这个就和上面transformer的那个是一模一样的了，细节的计算过程其实是一样的。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20200220194509277.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_16,color_FFFFFF,t_70" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
这里在拿过更细的个图来解释，首先这个$Q_1$会过一个多头的注意力机制，这个东西干啥用呢？ 原理这里不说，我们只要知道，这里的头其实是从某个角度去看各个物品之间的关系，而多头的意思就是从不同的角度去计算各个物品之间的关系， 比如各个物品在价格上啊，重量上啊，颜色上啊，时尚程度上啊等等这些不同方面的关系。然后就是看这个运算图，我们会发现self-attention的输出维度和输入维度也是一样的，但经过这个多头注意力的东西之后，**就能够得到当前的商品与其他商品在多个角度上的相关性**。怎么得到呢？
|
||||
>拿一个head来举例子：<br>
|
||||
>我们看看这个$QK^T$在表示啥意思：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20200220195022623.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
>假设当前会话有6个物品，embedding的维度是3的话，那么会看到这里一成，得到的结果中的每一行其实表示的是当前商品与其他商品之间的一个相似性大小(embedding内积的形式算的相似)。而沿着最后一个维度softmax归一化之后，得到的是个权重值。这是不是又想起我们的注意力机制来的啊，这个就叫做注意力矩阵，我们看看乘以V会是个啥
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20200220195243968.png#pic_center" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
>这时候，我们从注意力矩阵取出一行（和为1），然后依次点乘V的列，因为矩阵V的每一行代表着每一个字向量的数学表达，这样操作，**得到的正是注意力权重进行数学表达的加权线性组合，从而使每个物品向量都含有当前序列的所有物品向量的信息**。而多头，不过是含有多个角度的信息罢了，这就是Self-attention的魔力了。
|
||||
|
||||
|
||||
好了， 下面再看论文里面的描述就非常舒服了，如果令$\mathbf{Q}_{k}=\left[\mathbf{Q}_{k 1} ; \ldots ; \mathbf{Q}_{k h} ; \ldots ; \mathbf{Q}_{k H}\right]$， 这里面的$\mathbf{Q}_{k h} \in \mathbb{R}^{T \times d_{h}}$代表的就是多头里面的某一个头了，由于这多个头合起来的维度$d_{model}$维度，那么一个头就是$d_{h}=\frac{1}{h} d_{\text {model }}$， 这里必须要保证能整除才行。这里用了$h$个头。某个头$h$的计算为：
|
||||
$$
|
||||
\begin{aligned}
|
||||
\text { head }_{h} &=\text { Attention }\left(\mathbf{Q}_{k h} \mathbf{W}^{Q}, \mathbf{Q}_{k h} \mathbf{W}^{K}, \mathbf{Q}_{k h} \mathbf{W}^{V}\right) \\
|
||||
&=\operatorname{softmax}\left(\frac{\mathbf{Q}_{k h} \mathbf{W}^{Q} \mathbf{W}^{K^{T}} \mathbf{Q}_{k h}^{T}}{\sqrt{d_{m o d e l}}}\right) \mathbf{Q}_{k h} \mathbf{W}^{V}
|
||||
\end{aligned}
|
||||
$$
|
||||
这里是某一个头的计算过程， 这里的$\mathbf{W}^{Q}, \mathbf{W}^{K}, \mathbf{W}^{Q}$是要学习的参数，由于是一个头，维度应该是$\frac{1}{h} d_{\text {model }}\times \frac{1}{h} d_{\text {model }}$, 这样的话softmax那块算出来的是$T \times T$的矩阵， 而后面是一个$T \times \frac{1}{h} d_{\text {model }}$的矩阵，这时候得到的$head_h$是一个$T \times \frac{1}{h} d_{\text {model }}$的矩阵。 而$h$个头的话，正好是$T \times d_{\text {model }}$的维度，也就是我们最后的输出了。即下面这个计算：
|
||||
$$
|
||||
\mathbf{I}_{k}^{Q}=\operatorname{FFN}\left(\text { Concat }\left(\text { head }_{1}, \ldots, \text { head }_{H}\right) \mathbf{W}^{O}\right)
|
||||
$$
|
||||
这个是self-attention 的输出再过一个全连接网络得到的。如果是用残差网络的话，最后的结果依然是个$T \times d_{\text {model }}$的，也就是$\mathbf{I}_{k}^{Q}$的维度。这时候我们在$T$的维度上进行一个avg pooling的操作，就能够把每个session兴趣转成一个$embedding$维的向量了，即
|
||||
$$
|
||||
\mathbf{I}_{k}=\operatorname{Avg}\left(\mathbf{I}_{k}^{Q}\right)
|
||||
$$
|
||||
即这个$\mathbf{I}_{k}$是一个embedding维度的向量， 表示当前用户在第$k$会话的兴趣。这就是一个会话里面兴趣提取的全过程了，如果用我之前的神图总结的话就是：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20200220204538414.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
不同点就是这里用了两个transformer块，开始用的是bias编码。
|
||||
|
||||
接下来就是不同的会话都走这样的一个Transformer网络，就会得到一个$K \times embed \_dim$的矩阵，代表的是某个用户在$K$个会话里面的兴趣信息， 这个就是会话兴趣提取层的结果了。 两个注意点：
|
||||
1. 这$K$个会话是走同一个Transformer网络的，也就是在自注意力机制中不同的会话之间权重共享
|
||||
2. 最后得到的这个矩阵，$K$这个维度上是有时间先后关系的，这为后面用LSTM学习这各个会话之间的兴趣向量奠定了基础。
|
||||
|
||||
#### Session Interest Interacting Layer
|
||||
感觉这篇文章最难的地方在上面这块，所以我用了些篇幅，而下面这些就好说了，因为和之前的东西对上了又。 首先这个会话兴趣交互层
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210310172547359.png#pic_center" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
作者这里就是想通过一个双向的LSTM来学习下会话兴趣之间的关系， 从而增加用户兴趣的丰富度，或许还能学习到演化规律。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/img_convert/8aa8363c1efa5101e578658515df7eba.png#pic_center" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
双向的LSTM这个，这里就不介绍了，关于LSTM之前我也总结过了，无非双向的话，就是先从头到尾计算，在从尾到头回来。所以这里每个时刻隐藏状态的输出计算公式为：
|
||||
$$
|
||||
\mathbf{H}_{t}=\overrightarrow{\mathbf{h}_{f t}} \oplus \overleftarrow{\mathbf{h}_{b t}}
|
||||
$$
|
||||
这是一个$[1,\#hidden\_units]$的维度。相加的两项分别是前向传播和反向传播对应的t时刻的hidden state,这里得到的隐藏层状态$H_t$, 我们可以认为是混合了上下文信息的会话兴趣。
|
||||
#### Session Interest Activating Layer
|
||||
用户的会话兴趣与目标物品越相近，那么应该赋予更大的权重，这里依然使用注意力机制来刻画这种相关性，根据结构图也能看出，这里是用了两波注意力计算：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210310173413453.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
由于这里的这种局部Attention机制，DIN和DIEN里都见识过了， 这里就不详细解释了， 简单看下公式就可以啦。
|
||||
1. 会话兴趣提取层
|
||||
$$
|
||||
\begin{aligned}
|
||||
a_{k}^{I} &=\frac{\left.\exp \left(\mathbf{I}_{k} \mathbf{W}^{I} \mathbf{X}^{I}\right)\right)}{\sum_{k}^{K} \exp \left(\mathbf{I}_{k} \mathbf{W}^{I} \mathbf{X}^{I}\right)} \\
|
||||
\mathbf{U}^{I} &=\sum_{k}^{K} a_{k}^{I} \mathbf{I}_{k}
|
||||
\end{aligned}
|
||||
$$
|
||||
这里$X^I$是候选商品的embedding向量， 是$[embed \_dim,1]$的维度, $I_k$是$[1, embed \_dim]$的，而$W^I$是一个$[embed \_dim, embed \_dim]$， 所以这样能算出个分数，表示当前会话兴趣与候选商品之间的相似性程度。 而最终的$U^I$是各个会话兴趣向量的加权线性组合， 维度是$[1, embed \_dim]$。
|
||||
2. 会话兴趣交互层
|
||||
同样，混合了上下文信息的会话兴趣，也进行同样的处理：
|
||||
$$
|
||||
\begin{aligned}
|
||||
a_{k}^{H} &=\frac{\left.\exp \left(\mathbf{H}_{k} \mathbf{W}^{H} \mathbf{X}^{I}\right)\right)}{\sum_{k}^{K} \exp \left(\mathbf{H}_{k} \mathbf{W}^{H} \mathbf{X}^{I}\right)} \\
|
||||
\mathbf{U}^{H} &=\sum_{k}^{K} a_{k}^{H} \mathbf{H}_{k}
|
||||
\end{aligned}
|
||||
$$
|
||||
这里$X^I$是候选商品的embedding向量， 是$[embed \_dim,1]$的维度, $H_k$是$[1, \# hidden \_units]$的，而$W^I$是一个$[ \# hidden \_units, embed \_dim]$， 所以这样能算出个分数，当然实际实现，这里都是过神经网络的，表示混合了上下文信息的当前会话兴趣与候选商品之间的相似性程度。 而最终的$U^H$是各个混合了上下文信息的会话兴趣向量的加权线性组合， 维度是$[1, \# hidden \_units]$。
|
||||
|
||||
|
||||
#### Output Layer
|
||||
这个就很简单了，上面的用户行为特征， 物品行为特征以及求出的会话兴趣特征进行拼接，然后过一个DNN网络，就可以得到输出了。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210310174905503.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
损失这里依然用的交叉熵损失：
|
||||
$$
|
||||
L=-\frac{1}{N} \sum_{(x, y) \in \mathbb{D}}(y \log p(x)+(1-y) \log (1-p(x)))
|
||||
$$
|
||||
这里的$x$表示的是$\left[\mathbf{X}^{U}, \mathbf{X}^{I}, \mathbf{S}\right]$，分布表示用户特征，物品特征和会话兴趣特征。
|
||||
|
||||
到这里DSIN模型就解释完毕了。
|
||||
|
||||
### 论文的其他细节
|
||||
这里的其他细节，后面就是实验部分了，用的数据集是一个广告数据集一个推荐数据集， 对比了几个比较经典的模型Youtubetnet, W&D, DIN, DIEN, 用了RNN的DIN等。并做了一波消融实验，验证了偏置编码的有效性， 会话兴趣抽取层和会话交互兴趣抽取层的有效性。 最后可视化的self-attention和Action Unit的图比较有意思：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210310175643572.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
好了，下面就是DSIN的代码细节了。
|
||||
## DSIN的代码复现细节
|
||||
下面就是DSIN的代码部分，这里我依然是借鉴了Deepctr进行的简化版本的复现， 这次复现代码会非常多，因为想借着这个机会学习一波Transformer，具体的还是参考我后面的GitHub。 下面开始：
|
||||
|
||||
### 数据处理
|
||||
首先， 这里使用的数据集还是movielens数据集，延续的DIEN那里的，没来得及尝试其他，这里说下数据处理部分和DIEN不一样的地方。最大的区别就是这里的用户历史行为上的处理， 之前的是一个历史行为序列列表，这里得需要把这个列表分解成几个会话的形式， 由于每个用户的会话还不一定一样长，所以这里还需要进行填充。具体的数据格式如下：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210312161159945.png" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
就是把之前的hist_id序列改成了5个session。其他的特征那里没有变化。 而特征封装那里，需要把这5个会话封装起来，同时还得记录**每个用户的有效会话个数以及每个会话里面商品的有效个数， 这个在后面计算里面是有用的，因为目前是padding成了一样长，后面要根据这个个数进行mask， 所以这里有两波mask要做**
|
||||
|
||||
```python
|
||||
feature_columns = [SparseFeat('user_id', max(samples_data["user_id"])+1, embedding_dim=8),
|
||||
SparseFeat('gender', max(samples_data["gender"])+1, embedding_dim=8),
|
||||
SparseFeat('age', max(samples_data["age"])+1, embedding_dim=8),
|
||||
SparseFeat('movie_id', max(samples_data["movie_id"])+1, embedding_dim=8),
|
||||
SparseFeat('movie_type_id', max(samples_data["movie_type_id"])+1, embedding_dim=8),
|
||||
DenseFeat('hist_len', 1)]
|
||||
|
||||
feature_columns += [VarLenSparseFeat('sess1', vocabulary_size=max(samples_data["movie_id"])+1, embedding_dim=8, maxlen=10, length_name='seq_length1'),
|
||||
VarLenSparseFeat('sess2', vocabulary_size=max(samples_data["movie_id"])+1, embedding_dim=8, maxlen=10, length_name='seq_length2'),
|
||||
VarLenSparseFeat('sess3', vocabulary_size=max(samples_data["movie_id"])+1, embedding_dim=8, maxlen=10, length_name='seq_length3'),
|
||||
VarLenSparseFeat('sess4', vocabulary_size=max(samples_data["movie_id"])+1, embedding_dim=8, maxlen=10, length_name='seq_length4'),
|
||||
VarLenSparseFeat('sess5', vocabulary_size=max(samples_data["movie_id"])+1, embedding_dim=8, maxlen=10, length_name='seq_length5'),
|
||||
]
|
||||
feature_columns += ['sess_length']
|
||||
```
|
||||
封装代码变成了上面这个样子， 之所以放这里， 我是想说明一个问题，也是我这次才刚刚发觉的，就是这块封装特征的代码是用于建立模型用的， 也就是不用管有没有数据集，只要基于这个feature_columns就能把模型建立出来。 而这里面有几个重要的细节要梳理下：
|
||||
1. 上面的那一块特征是常规的离散和连续特征，封装起来即可，这个会对应的建立Input层接收后面的数据输入
|
||||
2. 第二块的变长离散特征， 注意后面的`seq_length`，这个东西的作用是标记每个用户在每个会话里面有效商品的真实长度，所以这5个会话建Input层的时候，不仅给前面的sess建立Input，还会给length_name建立Input层来接收每个用户每个会话里面商品的真实长度信息， 这样在后面创建mask的时候才有效。也就是**没有具体数据之前网络就能创建mask信息才行**。这个我是遇到了坑的，之前又忽略了这个`seq_length`， 想着直接用上面的真实数据算出长度来给网络不就行？ 其实不行，因为我们算出来的长度mask给网络的时候，那个样本数已经确定了，这时候会出bug的到后面。 因为真实训练的时候，batch_size是我们自己指定。并且这个思路的话是网络依赖于数据才能建立出来，显然是不合理的。所以一定要切记，**先用`seq_length`在这里占坑，作为一个Input层， 然后过embedding，后面基于传进的序列长度和填充的最大长度用 `tf.sequence_mask`就能建立了**。
|
||||
3. 最后的`sess_length`, 这个标记每个用户的有效会话个数，后面在会话兴趣与当前候选商品算注意力的时候，也得进行mask操作，所以这里和上面这个原理是一样的，**必须先用sess_length在这里占坑，创建一个Input层**。
|
||||
4. 对应关系， 既然我们这里封装的时候是这样封装的，这样就会根据上面的建立出不同的Input层，这时候我们具体用X训练的时候，**一定要注意数据对应，也就是特征必须够且能对应起来，这里是通过名字对应的**， 看下面的X:
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210312163227832.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
真实数据要和Input层接收进行对应好。
|
||||
|
||||
好了，关于数据处理就说这几个细节，感觉mask的那个处理非常需要注意。具体的看代码就可以啦。下面重头戏，剖析模型。
|
||||
|
||||
### DSIN模型全貌
|
||||
有了Deepctr的这种代码风格，使得建立模型会从宏观上看起来非常清晰，简单说下逻辑， 先建立输入层，由于输入的特征有三大类(离散，连续和变长离散)，所以分别建立Input层，然后离散特征还得建立embedding层。下面三大类特征就有了不同的走向：
|
||||
1. 连续特征： 这类特征拼先拼接到一块，然后等待最后往DNN里面输入
|
||||
2. 普通离散特征： 这块从输入 -> embedding -> 拼接到一块，等待DNN里面输入
|
||||
3. 用户的会话特征: 这块从输入 -> embedding -> 会话兴趣分割层(`sess_interest_division`) -> 会话兴趣提取层(`sess_interest_extractor`) -> 会话兴趣交互层(`BiLSTM`) -> 会话兴趣激活层( `AttentionPoolingLayer`) -> 得到两个兴趣性特征
|
||||
|
||||
把上面的连续特征，离散特征和兴趣特征拼接起来，然后过DNN得到输出即可。就是这么个逻辑了，具体代码如下：
|
||||
|
||||
```python
|
||||
def DSIN(feature_columns, sess_feature_list, sess_max_count=5, bias_encoding=True, singlehead_emb_size=1,
|
||||
att_head_nums=8, dnn_hidden_units=(200, 80)):
|
||||
"""
|
||||
建立DSIN网络
|
||||
:param feature_columns: A list， 每个特征的封装 nametuple形式
|
||||
:param behavior_feature_list: A list, 行为特征名称
|
||||
:param sess_max_count: 会话的个数
|
||||
:param bias_encoding: 是否偏置编码
|
||||
:singlehead_emb_size: 每个头的注意力的维度，注意这个和头数的乘积必须等于输入的embedding的维度
|
||||
:att_head_nums: 头的个数
|
||||
:dnn_hidden_units: 这个是全连接网络的神经元个数
|
||||
"""
|
||||
|
||||
# 检查下embedding设置的是否合法，因为这里有了多头注意力机制之后，我们要保证我们的embedding维度 = att_head_nums * att_embedding_size
|
||||
hist_emb_size = sum(
|
||||
map(lambda fc: fc.embedding_dim, filter(lambda fc: fc.name in sess_feature_list, [feature for feature in feature_columns if not isinstance(feature, str)]))
|
||||
)
|
||||
if singlehead_emb_size * att_head_nums != hist_emb_size:
|
||||
raise ValueError(
|
||||
"hist_emb_size must equal to singlehead_emb_size * att_head_nums ,got %d != %d *%d" % (
|
||||
hist_emb_size, singlehead_emb_size, att_head_nums))
|
||||
|
||||
# 建立输入层
|
||||
input_layer_dict = build_input_layers(feature_columns)
|
||||
# 将Input层转化为列表的形式作为model的输入
|
||||
input_layers = list(input_layer_dict.values()) # 各个输入层
|
||||
input_keys = list(input_layer_dict.keys()) # 各个列名
|
||||
user_sess_seq_len = [input_layer_dict['seq_length'+str(i+1)] for i in range(sess_max_count)]
|
||||
user_sess_len = input_layer_dict['sess_length']
|
||||
|
||||
# 筛选出特征中的sparse_fra, dense_fea, varlen_fea
|
||||
sparse_feature_columns = list(filter(lambda x: isinstance(x, SparseFeat), feature_columns)) if feature_columns else []
|
||||
dense_feature_columns = list(filter(lambda x: isinstance(x, DenseFeat), feature_columns)) if feature_columns else []
|
||||
varlen_sparse_feature_columns = list(filter(lambda x: isinstance(x, VarLenSparseFeat), feature_columns)) if feature_columns else []
|
||||
|
||||
# 获取dense
|
||||
dnn_dense_input = []
|
||||
for fc in dense_feature_columns:
|
||||
dnn_dense_input.append(input_layer_dict[fc.name])
|
||||
# 将所有的dense特征拼接
|
||||
dnn_dense_input = concat_input_list(dnn_dense_input)
|
||||
|
||||
# 构建embedding词典
|
||||
embedding_layer_dict = build_embedding_layers(feature_columns, input_layer_dict)
|
||||
|
||||
# 因为这里最终需要将embedding拼接后直接输入到全连接层(Dense)中, 所以需要Flatten
|
||||
dnn_sparse_embed_input = concat_embedding_list(sparse_feature_columns, input_layer_dict, embedding_layer_dict, flatten=True)
|
||||
# 将所有sparse特征的embedding进行拼接
|
||||
dnn_sparse_input = concat_input_list(dnn_sparse_embed_input)
|
||||
# dnn_dense_input和dnn_sparse_input这样就不用管了，等待后面的拼接就完事， 下面主要是会话行为兴趣的提取
|
||||
|
||||
|
||||
# 首先获取当前的行为特征(movie)的embedding，这里有可能有多个行为产生了行为序列，所以需要使用列表将其放在一起
|
||||
# 这个东西最后求局域Attention的时候使用，也就是选择与当前候选物品最相关的会话兴趣
|
||||
query_embed_list = embedding_lookup(sess_feature_list, input_layer_dict, embedding_layer_dict)
|
||||
query_emb = concat_input_list(query_embed_list)
|
||||
|
||||
# 下面就是开始会话行为的处理了，四个层来： 会话分割层，会话兴趣提取层，会话兴趣交互层和局部Attention层，下面一一来做
|
||||
|
||||
# 首先这里是找到会话行为中的特征列的输入层， 其实用input_layer_dict也行
|
||||
user_behavior_input_dict = {}
|
||||
for idx in range(sess_max_count):
|
||||
sess_input = OrderedDict()
|
||||
for i, feat in enumerate(sess_feature_list): # 我这里只有一个movie_id
|
||||
sess_input[feat] = input_layer_dict["sess" + str(idx+1)]
|
||||
|
||||
user_behavior_input_dict['sess'+str(idx+1)] = sess_input # 这里其实是获取那五个会话的输入层
|
||||
|
||||
# 会话兴趣分割层： 拿到每个会话里面各个商品的embedding，并且进行偏置编码，得到transformer的输入
|
||||
transformer_input = sess_interest_division(embedding_layer_dict, user_behavior_input_dict,
|
||||
sparse_feature_columns, sess_feature_list,
|
||||
sess_max_count, bias_encoding=bias_encoding)
|
||||
# 这个transformer_input是个列表，里面的每个元素代表一个会话，维度是(None, max_seq_len, embed_dim)
|
||||
|
||||
# 会话兴趣提取层： 每个会话过transformer，从多个角度得到里面各个商品之间的相关性(交互)
|
||||
self_attention = Transformer(singlehead_emb_size, att_head_nums, dropout_rate=0, use_layer_norm=True,
|
||||
use_positional_encoding=(not bias_encoding), blinding=False)
|
||||
sess_fea = sess_interest_extractor(transformer_input, sess_max_count, self_attention, user_sess_seq_len)
|
||||
# 这里的输出sess_fea是个矩阵，维度(None, sess_max_cout, embed_dim), 这个东西后期要和当前的候选商品求Attention进行sess维度上的加权
|
||||
|
||||
# 会话兴趣交互层 上面的transformer结果，过双向的LSTM
|
||||
lstm_output = BiLSTM(hist_emb_size, layers=2, res_layers=0, dropout_rate=0.2)(sess_fea)
|
||||
# 这个lstm_output是个矩阵，维度是(None, sess_max_count, hidden_units_num)
|
||||
|
||||
# 会话兴趣激活层 这里就是计算两波注意力
|
||||
interest_attention = AttentionPoolingLayer(user_sess_len)([query_emb, sess_fea])
|
||||
lstm_attention = AttentionPoolingLayer(user_sess_len)([query_emb, lstm_output])
|
||||
# 上面这两个的维度分别是(None, embed_size), (None, hidden_units_num) 这里embed_size=hidden_units_num
|
||||
|
||||
# 下面就是把dnn_sense_input, dnn_sparse_input, interest_attention, lstm_attention拼接起来
|
||||
deep_input = Concatenate(axis=-1)([dnn_dense_input, dnn_sparse_input, interest_attention, lstm_attention])
|
||||
|
||||
# 全连接接网络, 获取最终的dnn_logits
|
||||
dnn_logits = get_dnn_logits(deep_input, activation='prelu')
|
||||
|
||||
model = Model(input_layers, dnn_logits)
|
||||
|
||||
# 所有变量需要初始化
|
||||
tf.compat.v1.keras.backend.get_session().run(tf.compat.v1.global_variables_initializer())
|
||||
|
||||
return model
|
||||
```
|
||||
下面开始解释每块的细节实现。
|
||||
|
||||
### 会话兴趣分割层(sess_interest_division)
|
||||
这里面接收的输入是一个每个用户的会话列表， 比如上面那5个会话的时候，每个会话里面是有若干个商品的，当然还不仅仅是有商品id，还有可能有类别id这种。 而这个函数干的事情就是遍历这5个会话，然后对于每个会话，要根据商品id拿到每个会话的商品embedding(有类别id的话也会拿到类别id然后拼起来)， 所以每个会话会得到一个`(None, seq_len, embed_dim)`的一个矩阵，而最后的输出就是5个会话的矩阵放到一个列表里返回来。也就是上面的`transformer_input`， 作为transformer的输入。 这里面的一个细节，就是偏置编码。 如果需要偏置编码的话，要在这里面进行。偏置编码的过程
|
||||
|
||||
```python
|
||||
class BiasEncoding(Layer):
|
||||
"""位置编码"""
|
||||
def __init__(self, sess_max_count, seed=1024):
|
||||
super(BiasEncoding, self).__init__()
|
||||
self.sess_max_count = sess_max_count
|
||||
self.seed = seed
|
||||
|
||||
def build(self, input_shape):
|
||||
# 在该层创建一个可训练的权重 input_shape [None, sess_max_count, max_seq_len, embed_dim]
|
||||
if self.sess_max_count == 1:
|
||||
embed_size = input_shape[2]
|
||||
seq_len_max = input_shape[1]
|
||||
else:
|
||||
embed_size = input_shape[0][2]
|
||||
seq_len_max = input_shape[0][1]
|
||||
# 声明那三个位置偏置编码矩阵
|
||||
self.sess_bias_embedding = self.add_weight('sess_bias_encoding', shape=(self.sess_max_count, 1, 1),
|
||||
initializer=tf.keras.initializers.TruncatedNormal(mean=0.0, stddev=0.0001, seed=self.seed)) # 截断产生正太随机数
|
||||
self.seq_bias_embedding = self.add_weight('seq_bias_encoding', shape=(1, seq_len_max, 1),
|
||||
initializer=tf.keras.initializers.TruncatedNormal(mean=0.0, stddev=0.0001, seed=self.seed))
|
||||
self.embed_bias_embedding = self.add_weight('embed_beas_encoding', shape=(1, 1, embed_size),
|
||||
initializer=tf.keras.initializers.TruncatedNormal(mean=0.0, stddev=0.0001, seed=self.seed))
|
||||
super(BiasEncoding, self).build(input_shape)
|
||||
|
||||
def call(self, inputs, mask=None):
|
||||
"""
|
||||
:param inputs: A list 长度是会话数量，每个元素表示一个会话矩阵，维度是[None, max_seq_len, embed_dim]
|
||||
"""
|
||||
bias_encoding_out = []
|
||||
for i in range(self.sess_max_count):
|
||||
bias_encoding_out.append(
|
||||
inputs[i] + self.embed_bias_embedding + self.seq_bias_embedding + self.sess_bias_embedding[i] # 这里会广播
|
||||
)
|
||||
return bias_encoding_out
|
||||
```
|
||||
这里的核心就是build里面的那三个偏置矩阵，对应论文里面的$\mathbf{w}_{k}^{K},\mathbf{w}_{t}^{T},\mathbf{w}_{c}^{C}$, 这里之所以放到build里面建立，是为了让这些参数可学习， 而前向传播里面就是论文里面的公式加就完事，这里面会用到广播机制。
|
||||
|
||||
### 会话兴趣提取层(sess_interest_extractor)
|
||||
这里面就是复现了大名鼎鼎的Transformer了， 这也是我第一次看transformer的代码，果真与之前的理论分析还是有很多不一样的点，下面得一一梳理一下，Transformer是非常重要的。
|
||||
|
||||
首先是位置编码， 代码如下：
|
||||
|
||||
```python
|
||||
def positional_encoding(inputs, pos_embedding_trainable=True,scale=True):
|
||||
"""
|
||||
inputs: (None, max_seq_len, embed_dim)
|
||||
"""
|
||||
_, T, num_units = inputs.get_shape().as_list() # [None, max_seq_len, embed_dim]
|
||||
|
||||
position_ind = tf.expand_dims(tf.range(T), 0) # [1, max_seq_len]
|
||||
|
||||
# First part of the PE function: sin and cos argument
|
||||
position_enc = np.array([
|
||||
[pos / np.power(1000, 2. * i / num_units) for i in range(num_units)] for pos in range(T)
|
||||
])
|
||||
|
||||
# Second part, apply the cosine to even columns and sin to odds. # 这个操作秀
|
||||
position_enc[:, 0::2] = np.sin(position_enc[:, 0::2]) # dim 2i
|
||||
position_enc[:, 1::2] = np.cos(position_enc[:, 1::2]) # dim 2i+1
|
||||
|
||||
# 转成张量
|
||||
if pos_embedding_trainable:
|
||||
lookup_table = K.variable(position_enc, dtype=tf.float32)
|
||||
|
||||
outputs = tf.nn.embedding_lookup(lookup_table, position_ind)
|
||||
if scale:
|
||||
outputs = outputs * num_units ** 0.5
|
||||
return outputs + inputs
|
||||
```
|
||||
这一块的话没有啥好说的东西感觉，这个就是在按照论文里面的公式sin, cos变换， 这里面比较秀的操作感觉就是dim2i和dim 2i+1的赋值了。
|
||||
|
||||
接下来，LayerNormalization， 这个也是按照论文里面的公式实现的代码，求均值和方差的维度都是embedding：
|
||||
|
||||
```python
|
||||
class LayerNormalization(Layer):
|
||||
def __init__(self, axis=-1, eps=1e-9, center=True, scale=True):
|
||||
super(LayerNormalization, self).__init__()
|
||||
self.axis = axis
|
||||
self.eps = eps
|
||||
self.center = center
|
||||
self.scale = scale
|
||||
def build(self, input_shape):
|
||||
"""
|
||||
input_shape: [None, max_seq_len, singlehead_emb_dim*head_num]
|
||||
"""
|
||||
self.gamma = self.add_weight(name='gamma', shape=input_shape[-1:], # [1, max_seq_len, singlehead_emb_dim*head_num]
|
||||
initializer=tf.keras.initializers.Ones(), trainable=True)
|
||||
self.beta = self.add_weight(name='beta', shape=input_shape[-1:],
|
||||
initializer=tf.keras.initializers.Zeros(), trainable=True) # [1, max_seq_len, singlehead_emb_dim*head_num]
|
||||
super(LayerNormalization, self).build(input_shape)
|
||||
|
||||
def call(self, inputs):
|
||||
"""
|
||||
[None, max_seq_len, singlehead_emb_dim*head_num]
|
||||
"""
|
||||
mean = K.mean(inputs, axis=self.axis, keepdims=True) # embed_dim维度上求均值
|
||||
variance = K.mean(K.square(inputs-mean), axis=-1, keepdims=True) # embed_dim维度求方差
|
||||
std = K.sqrt(variance + self.eps)
|
||||
outputs = (inputs - mean) / std
|
||||
|
||||
if self.scale:
|
||||
outputs *= self.gamma
|
||||
if self.center:
|
||||
outputs += self.beta
|
||||
return outputs
|
||||
```
|
||||
下面就是伟大的Transformer网络，下面我先把整体代码放上来，然后解释一些和我之前见到过的一样的地方，也是通过看具体代码学习到的点：
|
||||
|
||||
```python
|
||||
class Transformer(Layer):
|
||||
"""Transformer网络"""
|
||||
def __init__(self, singlehead_emb_size=1, att_head_nums=8, dropout_rate=0.0, use_positional_encoding=False,use_res=True,
|
||||
use_feed_forword=True, use_layer_norm=False, blinding=False, seed=1024):
|
||||
super(Transformer, self).__init__()
|
||||
self.singlehead_emb_size = singlehead_emb_size
|
||||
self.att_head_nums = att_head_nums
|
||||
self.num_units = self.singlehead_emb_size * self.att_head_nums
|
||||
self.use_res = use_res
|
||||
self.use_feed_forword = use_feed_forword
|
||||
self.dropout_rate = dropout_rate
|
||||
self.use_positional_encoding = use_positional_encoding
|
||||
self.use_layer_norm = use_layer_norm
|
||||
self.blinding = blinding # 如果为True的话表明进行attention的时候未来的units都被屏蔽， 解码器的时候用
|
||||
self.seed = seed
|
||||
|
||||
# 这里需要为该层自定义可训练的参数矩阵 WQ, WK, WV
|
||||
def build(self, input_shape):
|
||||
# input_shape: [None, max_seq_len, embed_dim]
|
||||
embedding_size= int(input_shape[0][-1])
|
||||
# 检查合法性
|
||||
if self.num_units != embedding_size:
|
||||
raise ValueError(
|
||||
"att_embedding_size * head_num must equal the last dimension size of inputs,got %d * %d != %d" % (
|
||||
self.singlehead_emb_size, att_head_nums, embedding_size))
|
||||
self.seq_len_max = int(input_shape[0][-2])
|
||||
# 定义三个矩阵
|
||||
self.W_Query = self.add_weight(name='query', shape=[embedding_size, self.singlehead_emb_size*self.att_head_nums],
|
||||
dtype=tf.float32,initializer=tf.keras.initializers.TruncatedNormal(seed=self.seed))
|
||||
self.W_Key = self.add_weight(name='key', shape=[embedding_size, self.singlehead_emb_size*self.att_head_nums],
|
||||
dtype=tf.float32,initializer=tf.keras.initializers.TruncatedNormal(seed=self.seed+1))
|
||||
self.W_Value = self.add_weight(name='value', shape=[embedding_size, self.singlehead_emb_size*self.att_head_nums],
|
||||
dtype=tf.float32,initializer=tf.keras.initializers.TruncatedNormal(seed=self.seed+2))
|
||||
# 用神经网络的话，加两层训练参数
|
||||
if self.use_feed_forword:
|
||||
self.fw1 = self.add_weight('fw1', shape=[self.num_units, 4 * self.num_units], dtype=tf.float32,
|
||||
initializer=tf.keras.initializers.glorot_uniform(seed=self.seed))
|
||||
self.fw2 = self.add_weight('fw2', shape=[4 * self.num_units, self.num_units], dtype=tf.float32,
|
||||
initializer=tf.keras.initializers.glorot_uniform(seed=self.seed+1))
|
||||
self.dropout = tf.keras.layers.Dropout(self.dropout_rate)
|
||||
self.ln = LayerNormalization()
|
||||
super(Transformer, self).build(input_shape)
|
||||
|
||||
def call(self, inputs, mask=None, training=None):
|
||||
"""
|
||||
:param inputs: [当前会话sessi, 当前会话sessi] 维度 (None, max_seq_len, embed_dim)
|
||||
:param mask: 当前会话mask 这是个1维数组， 维度是(None, ), 表示每个样本在当前会话里面的行为序列长度
|
||||
"""
|
||||
# q和k其实是一样的矩阵
|
||||
queries, keys = inputs
|
||||
query_masks, key_masks = mask, mask
|
||||
|
||||
# 这里需要对Q和K进行mask操作，
|
||||
# key masking目的是让key值的unit为0的key对应的attention score极小，这样加权计算value时相当于对结果不产生影响
|
||||
# Query Masking 要屏蔽的是被0所填充的内容。
|
||||
query_masks = tf.sequence_mask(query_masks, self.seq_len_max, dtype=tf.float32) # (None, 1, seq_len_max)
|
||||
key_masks = tf.sequence_mask(key_masks, self.seq_len_max, dtype=tf.float32) # (None, 1, seq_len_max), 注意key_masks开始是(None,1)
|
||||
key_masks = key_masks[:, 0, :] # 所以上面会多出个1维度来， 这里去掉才行，(None, seq_len_max)
|
||||
query_masks = query_masks[:, 0, :] # 这个同理
|
||||
|
||||
# 是否位置编码
|
||||
if self.use_positional_encoding:
|
||||
queries = positional_encoding(queries)
|
||||
keys = positional_encoding(queries)
|
||||
|
||||
# tensordot 是矩阵乘，好处是当两个矩阵维度不同的时候，只要指定axes也可以乘
|
||||
# 这里表示的是queries的-1维度与W_Query的0维度相乘
|
||||
# (None, max_seq_len, embedding_size) * [embedding_size, singlehead_emb_size*head_num]
|
||||
querys = tf.tensordot(queries, self.W_Query, axes=(-1, 0)) # [None, max_seq_len_q, singlehead_emb_size*head_num]
|
||||
|
||||
keys = tf.tensordot(keys, self.W_Key, axes=(-1, 0)) # [None, max_seq_len_k, singlehead_emb_size*head_num]
|
||||
values = tf.tensordot(keys, self.W_Value, axes=(-1, 0)) # [None, max_seq_len_k, singlehead_emb_size*head_num]
|
||||
|
||||
# tf.split切分张量 这里从头那里切分成head_num个张量， 然后从0维拼接
|
||||
querys = tf.concat(tf.split(querys, self.att_head_nums, axis=2), axis=0) # [head_num*None, max_seq_len_q, singlehead_emb_size]
|
||||
keys = tf.concat(tf.split(keys, self.att_head_nums, axis=2), axis=0) # [head_num*None, max_seq_len_k, singlehead_emb_size]
|
||||
values = tf.concat(tf.split(values, self.att_head_nums, axis=2), axis=0) # [head_num*None, max_seq_len_k, singlehead_emb_size]
|
||||
|
||||
# Q*K keys后两维转置然后再乘 [head_num*None, max_seq_len_q, max_seq_len_k]
|
||||
outputs = tf.matmul(querys, keys, transpose_b=True)
|
||||
outputs = outputs / (keys.get_shape().as_list()[-1] ** 0.5)
|
||||
|
||||
# 从0维度上复制head_num次
|
||||
key_masks = tf.tile(key_masks, [self.att_head_nums, 1]) # [head_num*None, max_seq_len_k]
|
||||
key_masks = tf.tile(tf.expand_dims(key_masks, 1), [1, tf.shape(queries)[1], 1]) # [head_num*None, max_seq_len_q,max_seq_len_k]
|
||||
paddings = tf.ones_like(outputs) * (-2**32+1)
|
||||
|
||||
outputs = tf.where(tf.equal(key_masks, 1), outputs, paddings) # 被填充的部分赋予极小的权重
|
||||
|
||||
# 标识是否屏蔽未来序列的信息(解码器self attention的时候不能看到自己之后的哪些信息)
|
||||
# 这里通过下三角矩阵的方式进行，依此表示预测第一个词，第二个词，第三个词...
|
||||
if self.blinding:
|
||||
diag_vals = tf.ones_like(outputs[0, :, :]) # (T_q, T_k)
|
||||
tril = tf.linalg.LinearOperatorLowerTriangular(diag_vals).to_dense() # (T_q, T_k) 这是个下三角矩阵
|
||||
masks = tf.tile(tf.expand_dims(tril, 0), [tf.shape(outputs)[0], 1, 1]) # (h*N, T_q, T_k)
|
||||
|
||||
paddings = tf.ones_like(masks) * (-2 ** 32 + 1)
|
||||
outputs = tf.where(tf.equal(masks, 0), paddings, outputs) # (h*N, T_q, T_k)
|
||||
|
||||
outputs -= tf.reduce_max(outputs, axis=-1, keepdims=True)
|
||||
outputs = tf.nn.softmax(outputs, axis=-1) # 最后一个维度求softmax，换成权重
|
||||
|
||||
query_masks = tf.tile(query_masks, [self.att_head_nums, 1]) # [head_num*None, max_seq_len_q]
|
||||
query_masks = tf.tile(tf.expand_dims(query_masks, -1), [1, 1, tf.shape(keys)[1]]) # [head_num*None, max_seq_len_q, max_seq_len_k]
|
||||
|
||||
outputs *= query_masks
|
||||
|
||||
# 权重矩阵过下dropout [head_num*None, max_seq_len_q, max_seq_len_k]
|
||||
outputs = self.dropout(outputs, training=training)
|
||||
|
||||
# weighted sum [head_num*None, max_seq_len_q, max_seq_len_k] * # [head_num*None, max_seq_len_k, singlehead_emb_size]
|
||||
result = tf.matmul(outputs, values) # [head_num*None, max_seq_len_q, singlehead_emb_size]
|
||||
# 换回去了
|
||||
result = tf.concat(tf.split(result, self.att_head_nums, axis=0), axis=2) # [None, max_seq_len_q, head_num*singlehead_emb_size]
|
||||
|
||||
if self.use_res: # 残差连接
|
||||
result += queries
|
||||
if self.use_layer_norm:
|
||||
result = self.ln(result)
|
||||
if self.use_feed_forword: # [None, max_seq_len_q, head_num*singlehead_emb_size] 与 [num_units, self.num_units]
|
||||
fw1 = tf.nn.relu(tf.tensordot(result, self.fw1, axes=[-1, 0])) # [None, max_seq_len_q, 4*num_units]
|
||||
fw1 = self.dropout(fw1, training=training)
|
||||
fw2 = tf.tensordot(fw1, self.fw2, axes=[-1, 0]) # [None, max_seq_len_q, num_units] 这个num_units其实就等于head_num*singlehead_emb_size
|
||||
|
||||
if self.use_res:
|
||||
result += fw2
|
||||
if self.use_layer_norm:
|
||||
result = self.ln(result)
|
||||
|
||||
return tf.reduce_mean(result, axis=1, keepdims=True) # [None, 1, head_num*singleh]
|
||||
```
|
||||
这里面的整体逻辑， 首先在build里面会构建3个矩阵`WQ, WK, WV`，在这里定义依然是为了这些参数可训练， 而出乎我意料的是残差网络的参数w也是这里定义， 之前还以为这个是单独写出来，后面看了前向传播的逻辑时候明白了。
|
||||
|
||||
前向传播的逻辑和我之前画的图上差不多，不一样的细节是这里的具体实现上， 就是这里的**把多个头分开，采用堆叠的方式进行计算(堆叠到第一个维度上去了)**。这个是我之前忽略的一个问题， 只有这样才能使得每个头与每个头之间的自注意力运算是独立不影响的。如果不这么做的话，最后得到的结果会含有当前单词在这个头和另一个单词在另一个头上的关联，这是不合理的。**这是看了源码之后才发现的细节**。
|
||||
|
||||
另外就是mask操作这里，Q和K都需要进行mask操作，因为我们接受的输入序列是经过填充的，这里必须通过指明长度在具体计算的时候进行遮盖，否则softmax那里算的时候会有影响，因为e的0次方是1，所以这里需要找到序列里面填充的那些地方，给他一个超级大的负数，这样e的负无穷接近0，才能没有影响。但之前不知道这里的细节，这次看发现是Q和K都进行mask操作，且目的还不一样。
|
||||
|
||||
第三个细节，就是对未来序列的屏蔽，这个在这里是用不到的，这个是Transformer的解码器用的一个操作，就是在解码的时候，我们不能让当前的序列看到自己之后的信息。这里也需要进行mask遮盖住后面的。而具体实现，竟然使用了一个下三角矩阵， 这个东西的感觉是这样：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/20210312171321963.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="在这里插入图片描述" style="zoom:90%;" />
|
||||
</div>
|
||||
|
||||
解码的时候，只能看到自己及以前的相关性，然后加权，这个学到了哈哈。
|
||||
|
||||
transformer这里接收的是会话兴趣分割层传下来的兴趣列表，返回的是个矩阵，维度是`(None, sess_nums, embed_dim)`， 因为这里每个会话都要过Transformer， 输入的维度是(None, seq_len, embed_dim)， 而经过transformer之后，本来输出的维度也是这个，但是最后返回的时候在seq_len的维度上求了个平均。所以每个会话得到的输出是(None, 1, embed_dim), 相当于兴趣综合了下。而5个会话，就会得到5个这样的结果，然后再会话维度上拼接，就是上面的这个矩阵结果了，这个东西作为双向LSTM的输入。
|
||||
|
||||
### 会话兴趣交互层(BiLSTM)
|
||||
这里主要是值得记录下多层双向LSTM的实现过程， 用下面的这种方式非常的灵活：
|
||||
|
||||
```python
|
||||
class BiLSTM(Layer):
|
||||
def __init__(self, units, layers=2, res_layers=0, dropout_rate=0.2, merge_mode='ave'):
|
||||
super(BiLSTM, self).__init__()
|
||||
self.units = units
|
||||
self.layers = layers
|
||||
self.res_layers = res_layers
|
||||
self.dropout_rate = dropout_rate
|
||||
self.merge_mode = merge_mode
|
||||
|
||||
# 这里要构建正向的LSTM和反向的LSTM， 因为我们是要两者的计算结果最后加和，所以这里需要分别计算
|
||||
def build(self, input_shape):
|
||||
"""
|
||||
input_shape: (None, sess_max_count, embed_dim)
|
||||
"""
|
||||
self.fw_lstm = []
|
||||
self.bw_lstm = []
|
||||
for _ in range(self.layers):
|
||||
self.fw_lstm.append(
|
||||
LSTM(self.units, dropout=self.dropout_rate, bias_initializer='ones', return_sequences=True, unroll=True)
|
||||
)
|
||||
# go_backwards 如果为真，则反向处理输入序列并返回相反的序列
|
||||
# unroll 布尔(默认错误)。如果为真，则网络将展开，否则使用符号循环。展开可以提高RNN的速度，尽管它往往会占用更多的内存。展开只适用于较短的序列。
|
||||
self.bw_lstm.append(
|
||||
LSTM(self.units, dropout=self.dropout_rate, bias_initializer='ones', return_sequences=True, go_backwards=True, unroll=True)
|
||||
)
|
||||
super(BiLSTM, self).build(input_shape)
|
||||
|
||||
def call(self, inputs):
|
||||
|
||||
input_fw = inputs
|
||||
input_bw = inputs
|
||||
for i in range(self.layers):
|
||||
output_fw = self.fw_lstm[i](input_fw)
|
||||
output_bw = self.bw_lstm[i](input_bw)
|
||||
output_bw = Lambda(lambda x: K.reverse(x, 1), mask=lambda inputs, mask:mask)(output_bw)
|
||||
|
||||
if i >= self.layers - self.res_layers:
|
||||
output_fw += input_fw
|
||||
output_bw += input_bw
|
||||
|
||||
input_fw = output_fw
|
||||
input_bw = output_bw
|
||||
|
||||
if self.merge_mode == "fw":
|
||||
output = output_fw
|
||||
elif self.merge_mode == "bw":
|
||||
output = output_bw
|
||||
elif self.merge_mode == 'concat':
|
||||
output = K.concatenate([output_fw, output_bw])
|
||||
elif self.merge_mode == 'sum':
|
||||
output = output_fw + output_bw
|
||||
elif self.merge_mode == 'ave':
|
||||
output = (output_fw + output_bw) / 2
|
||||
elif self.merge_mode == 'mul':
|
||||
output = output_fw * output_bw
|
||||
elif self.merge_mode is None:
|
||||
output = [output_fw, output_bw]
|
||||
|
||||
return output
|
||||
```
|
||||
这里这个操作是比较骚的，以后建立双向LSTM就用这个模板了，具体也不用解释，并且这里之所以说灵活，是因为最后前向LSTM的结果和反向LSTM的结果都能单独的拿到，且可以任意的两者运算。 我记得Keras里面应该是也有直接的函数实现双向LSTM的，但依然感觉不如这种灵活。 这个层数自己定，单元自己定看，最后结果形式自己定，太帅了简直。 关于LSTM，可以看[官方文档](https://tensorflow.google.cn/versions/r2.0/api_docs/python/tf/keras/layers/LSTM)
|
||||
|
||||
这个的输入是`(None, sess_nums, embed_dim)`， 输出是`(None, sess_nums, hidden_units_num)`。
|
||||
|
||||
### 会话兴趣局部激活
|
||||
这里就是局部Attention的操作了，这个在这里就不解释了，和之前的DIEN，DIN的操作就一样了， 代码也不放在这里了，剩下的代码都看后面的GitHub链接吧， 这里我只记录下我觉得后面做别的项目会有用的代码哈哈。
|
||||
|
||||
## 总结
|
||||
DSIN的核心创新点就是把用户的历史行为按照时间间隔进行切分，以会话为单位进行学习， 而学习的方式首先是会话之内的行为自学习，然后是会话之间的交互学习，最后是与当前候选商品相关的兴趣演进，总体上还是挺清晰的。
|
||||
|
||||
具体的实际使用场景依然是有丰富的用户历史行为序列才可以，而会话之间的划分间隔，也得依据具体业务场景。 具体的使用可以调deepctr的包。
|
||||
|
||||
**参考资料**：
|
||||
* [DSIN原论文](https://arxiv.org/abs/1905.06482)
|
||||
* [自然语言处理之Attention大详解（Attention is all you need）](https://blog.csdn.net/wuzhongqiang/article/details/104414239?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522161512240816780357259240%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=161512240816780357259240&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_v1~rank_blog_v1-1-104414239.pc_v1_rank_blog_v1&utm_term=Attention+is+all)
|
||||
* [推荐系统遇上深度学习(四十五)-探秘阿里之深度会话兴趣网络](https://www.jianshu.com/p/82ccb10f9ede)
|
||||
* [深度兴趣网络模型探索——DIN+DIEN+DSIN](https://blog.csdn.net/baymax_007/article/details/91130374)
|
||||
* [Transformer解读](https://www.cnblogs.com/flightless/p/12005895.html)
|
||||
* [Welcome to DeepCTR’s documentation!](https://deepctr-doc.readthedocs.io/en/latest/)
|
||||
129
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.5/2.2.5.0.md
Normal file
129
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.5/2.2.5.0.md
Normal file
@@ -0,0 +1,129 @@
|
||||
## 背景与动机
|
||||
|
||||
在推荐系统的精排模块，多任务学习的模型结构已成业界的主流，获得了广阔的应用。多任务学习（multi-task learning），本质上是希望使用一个模型完成多个任务的建模。在推荐系统中，多任务学习一般即指多目标学习（multi-label learning），不同目标输入相同的feature进行联合训练，是迁移学习的一种。他们之间的关系如图：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://pic1.zhimg.com/80/v2-130d040474f34095ec6d8c81133da538_1440w.jpg" style="zoom:60%;" />
|
||||
</div>
|
||||
|
||||
下面我们先讨论三个问题
|
||||
|
||||
**一、为什么要用多任务学习？**
|
||||
|
||||
（1）很多业界推荐的业务，天然就是一个多目标的建模场景，需要多目标共同优化。以微信视频号推荐为例，打开一个视频，如图，首页上除了由于视频自动播放带来的“播放时长”、“完播率”（用户播放时长占视频长度的比例）目标之外，还有大量的互动标签，例如“点击好友头像”、“进入主页”、“关注”、“收藏”、“分享”、“点赞”、“评论”等。究竟哪一个标签最符合推荐系统的建模目标呢？
|
||||
|
||||
<div align=center>
|
||||
<img src="https://pic4.zhimg.com/80/v2-c18fc1ec65e308ee2e1477d7868007db_1440w.jpg" style="zoom:30%;" />
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
如果要用一个词来概括所有各式各样的推荐系统的终极目标，那就是“用户满意度”，但我们无法找到一个显示的指标量化用户满意度。业界一般使用“DAU”、“用户日均使用时长”、“留存率”来作为客观的间接的“用户满意度”（或者说算法工程师绩效）评价指标。而这些指标都是难以通过单一目标建模的，以使用时长为例，长视频播放长度天然大于短视频。所幸的是，虽然没有显式的用户满意度评价指标，但是现在的app都存在类似上述视频号推荐场景的丰富具体的隐式反馈。但这些独立的隐式反馈也存在一些挑战：
|
||||
|
||||
- 目标偏差：点赞、分享表达的满意度可能比播放要高
|
||||
- 物品偏差：不同视频的播放时长体现的满意度不一样，有的视频可能哄骗用户看到尾部（类似新闻推荐中的标题党）
|
||||
- 用户偏差：有的用户表达满意喜欢用点赞，有的用户可能喜欢用收藏
|
||||
|
||||
因此我们需要使用多任务学习模型针对多个目标进行预测，并在线上融合多目标的预测结果进行排序。多任务学习也不能直接表达用户满意度，但是可以最大限度利用能得到的用户反馈信息进行充分的表征学习，并且可建模业务之间的关系，从而高效协同学习具体任务。
|
||||
|
||||
（2）工程便利，不用针对不同的任务训练不同的模型。一般推荐系统中排序模块延时需求在40ms左右，如果分别对每个任务单独训练一个模型，难以满足需求。出于控制成本的目的，需要将部分模型进行合并。合并之后，能更高效的利用训练资源和进行模型的迭代升级。
|
||||
|
||||
**二、为什么多任务学习有效？**
|
||||
|
||||
当把业务独立建模变成多任务联合建模之后，有可能带来四种结果：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://pic1.zhimg.com/80/v2-44927ccdd6caf9685d3d9d5367af98dc_1440w.jpg" style="zoom:60%;" />
|
||||
</div>
|
||||
|
||||
多任务学习的优势在于通过部分参数共享，联合训练，能在保证“还不错”的前提下，实现多目标共同提升。原因有以下几种：
|
||||
|
||||
- 任务互助：对于某个任务难学到的特征，可通过其他任务学习
|
||||
- 隐式数据增强：不同任务有不同的噪声，一起学习可抵消部分噪声
|
||||
- 学到通用表达，提高泛化能力：模型学到的是对所有任务都偏好的权重，有助于推广到未来的新任务
|
||||
- 正则化：对于一个任务而言，其他任务的学习对该任务有正则化效果
|
||||
|
||||
**三、多任务学习都在研究什么问题**？
|
||||
|
||||
如上所述，多任务的核心优势在于通过不同任务的网络参数共享，实现1+1>2的提升，因此多任务学习的一大主流研究方向便是如何设计有效的网络结构。多个label的引入自然带来了多个loss，那么如何在联合训练中共同优化多个loss则是关键问题。
|
||||
|
||||
- 网络结构设计：主要研究哪些参数共享、在什么位置共享、如何共享。这一方向我们认为可以分为两大类，第一类是在设计网络结构时，考虑目标间的显式关系（例如淘宝中，点击之后才有购买行为发生），以阿里提出的ESMM为代表；另一类是目标间没有显示关系（例如短视频中的收藏与分享），在设计模型时不考虑label之间的量化关系，以谷歌提出的MMOE为代表。
|
||||
- 多loss的优化策略：主要解决loss数值有大有小、学习速度有快有慢、更新方向时而相反的问题。最经典的两个工作有UWL（Uncertainty Weight）：通过自动学习任务的uncertainty，给uncertainty大的任务小权重，uncertainty小的任务大权重；GradNorm：结合任务梯度的二范数和loss下降梯度，引入带权重的损失函数Gradient Loss，并通过梯度下降更新该权重。
|
||||
|
||||
## loss加权融合
|
||||
|
||||
一种最简单的实现多任务学习的方式是对不同任务的loss进行加权。例如谷歌的Youtube DNN论文中提到的一种加权交叉熵：
|
||||
$$
|
||||
\text { Weighted CE Loss }=-\sum_{i}\left[T_{i} y_{i} \log p_{i}+\left(1-y_{i}\right) \log \left(1-p_{i}\right)\right]
|
||||
$$
|
||||
其中![[公式]](https://www.zhihu.com/equation?tex=T_i) 为观看时长。在原始训练数据中，正样本是视频展示后用户点击了该视频，负样本则是展示后未点击，这个一个标准的CTR预估问题。该loss通过改变训练样本的权重，让所有负样本的权重都为 1，而正样本的权重为点击后的视频观看时长 ![[公式]](https://www.zhihu.com/equation?tex=T_i) 。作者认为按点击率排序会倾向于把诱惑用户点击（用户未必真感兴趣)的视频排前面，而观看时长能更好地反映出用户对视频的兴趣，通过重新设计loss使得该模型在保证主目标点击的同时，将视频观看时长转化为样本的权重，达到优化平均观看时长的效果。
|
||||
|
||||
另一种更为简单粗暴的加权方式是人工手动调整权重，例如 0.3\*L(点击)+0.7*L\*(视频完播)
|
||||
|
||||
这种loss加权的方式优点如下：
|
||||
|
||||
- 模型简单，仅在训练时通过梯度乘以样本权重实现对其它目标的加权
|
||||
- 模型上线简单，和base完全相同，不需要额外开销
|
||||
|
||||
缺点：
|
||||
|
||||
- 本质上并不是多目标建模，而是将不同的目标转化为同一个目标。样本的加权权重需要根据AB测试才能确定。
|
||||
|
||||
## Shared-Bottom
|
||||
|
||||
最早的多任务学习模型是底层共享结构（Shared-Bottom），如图所示。
|
||||
|
||||
通过共享底层模块，学习任务间通用的特征表征，再往上针对每一个任务设置一个Tower网络，每个Tower网络的参数由自身对应的任务目标进行学习。Shared Bottom可以根据自身数据特点，使用MLP、DeepFM、DCN、DIN等，Tower网络一般使用简单的MLP。
|
||||
|
||||
代码如下，共享特征embedding，共享底层DNN网络，任务输出层独立，loss直接使用多个任务的loss值之和。
|
||||
|
||||
```python
|
||||
def Shared_Bottom(dnn_feature_columns, num_tasks=None, task_types=None, task_names=None,
|
||||
bottom_dnn_units=[128, 128], tower_dnn_units_lists=[[64,32], [64,32]],
|
||||
l2_reg_embedding=0.00001, l2_reg_dnn=0, seed=1024,dnn_dropout=0,
|
||||
dnn_activation='relu', dnn_use_bn=False):
|
||||
|
||||
features = build_input_features(dnn_feature_columns)
|
||||
inputs_list = list(features.values())
|
||||
|
||||
sparse_embedding_list, dense_value_list = input_from_feature_columns(features, dnn_feature_columns, l2_reg_embedding,seed)
|
||||
#共享输入特征
|
||||
dnn_input = combined_dnn_input(sparse_embedding_list, dense_value_list)
|
||||
#共享底层网络
|
||||
shared_bottom_output = DNN(bottom_dnn_units, dnn_activation, l2_reg_dnn, dnn_dropout, dnn_use_bn, seed=seed)(dnn_input)
|
||||
#任务输出层
|
||||
tasks_output = []
|
||||
for task_type, task_name, tower_dnn in zip(task_types, task_names, tower_dnn_units_lists):
|
||||
tower_output = DNN(tower_dnn, dnn_activation, l2_reg_dnn, dnn_dropout, dnn_use_bn, seed=seed, name='tower_'+task_name)(shared_bottom_output)
|
||||
|
||||
logit = tf.keras.layers.Dense(1, use_bias=False, activation=None)(tower_output)
|
||||
output = PredictionLayer(task_type, name=task_name)(logit)
|
||||
tasks_output.append(output)
|
||||
|
||||
model = tf.keras.models.Model(inputs=inputs_list, outputs=tasks_output)
|
||||
return model
|
||||
```
|
||||
|
||||
优点：
|
||||
|
||||
- 浅层参数共享，互相补充学习，任务相关性越高，模型loss优化效果越明显，也可以加速训练。
|
||||
|
||||
缺点：
|
||||
|
||||
- 任务不相关甚至优化目标相反时（例如新闻的点击与阅读时长），可能会带来负收益，多个任务性能一起下降。
|
||||
|
||||
一般把Shared-Bottom的结构称作“参数硬共享”，多任务学习网络结构设计的发展方向便是如何设计更灵活的共享机制，从而实现“参数软共享”。
|
||||
|
||||
|
||||
|
||||
参考资料：
|
||||
|
||||
[https://developer.aliyun.com/article/793252](https://developer.aliyun.com/article/793252)
|
||||
|
||||
https://zhuanlan.zhihu.com/p/291406172
|
||||
|
||||
Gradnorm: Gradient normalization for adaptive loss balancing in deep multitask networks (ICML'2018)
|
||||
|
||||
UWL: Multi-task learning using uncertainty to weigh losses for scene geometry and semantics (CVPR'2018)
|
||||
|
||||
YoutubeDNN: Deep neural networks for youtube recommendations (RecSys'2016)
|
||||
162
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.5/ESMM.md
Normal file
162
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.5/ESMM.md
Normal file
@@ -0,0 +1,162 @@
|
||||
# ESMM
|
||||
|
||||
不同的目标由于业务逻辑，有显式的依赖关系，例如**曝光→点击→转化**。用户必然是在商品曝光界面中，先点击了商品，才有可能购买转化。阿里提出了ESMM(Entire Space Multi-Task Model)网络，显式建模具有依赖关系的任务联合训练。该模型虽然为多任务学习模型，但本质上是以CVR为主任务，引入CTR和CTCVR作为辅助任务，解决CVR预估的挑战。
|
||||
|
||||
## 背景与动机
|
||||
|
||||
传统的CVR预估问题存在着两个主要的问题：**样本选择偏差**和**稀疏数据**。下图的白色背景是曝光数据，灰色背景是点击行为数据，黑色背景是购买行为数据。传统CVR预估使用的训练样本仅为灰色和黑色的数据。
|
||||
<div align=center>
|
||||
<img src="https://pic4.zhimg.com/80/v2-2f0df0f6933dd8405c478fcce91f7b6f_1440w.jpg" alt="img" style="zoom:33%;" />
|
||||
</div>
|
||||
|
||||
这会导致两个问题：
|
||||
- 样本选择偏差（sample selection bias，SSB）：如图所示，CVR模型的正负样本集合={点击后未转化的负样本+点击后转化的正样本}，但是线上预测的时候是样本一旦曝光，就需要预测出CVR和CTR以排序，样本集合={曝光的样本}。构建的训练样本集相当于是从一个与真实分布不一致的分布中采样得到的，这一定程度上违背了机器学习中训练数据和测试数据独立同分布的假设。
|
||||
- 训练数据稀疏（data sparsity，DS）：点击样本只占整个曝光样本的很小一部分，而转化样本又只占点击样本的很小一部分。如果只用点击后的数据训练CVR模型，可用的样本将极其稀疏。
|
||||
|
||||
## 解决方案
|
||||
|
||||
阿里妈妈团队提出ESMM，借鉴多任务学习的思路，引入两个辅助任务CTR、CTCVR(已点击然后转化)，同时消除以上两个问题。
|
||||
|
||||
三个预测任务如下：
|
||||
|
||||
- **pCTR**：p(click=1 | impression)；
|
||||
- **pCVR**: p(conversion=1 | click=1,impression)；
|
||||
- **pCTCVR**: p(conversion=1, click=1 | impression) = p(click=1 | impression) * p(conversion=1 | click=1, impression)；
|
||||
|
||||
> 注意：其中只有CTR和CVR的label都同时为1时，CTCVR的label才是正样本1。如果出现CTR=0，CVR=1的样本，则为不合法样本，需删除。
|
||||
> pCTCVR是指，当用户已经点击的前提下，用户会购买的概率；pCVR是指如果用户点击了，会购买的概率。
|
||||
|
||||
三个任务之间的关系为：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://pic1.zhimg.com/80/v2-7bbeb8767db5d6a157852c8cd4221548_1440w.jpg" alt="img" style="zoom: 50%;" />
|
||||
</div>
|
||||
|
||||
其中x表示曝光，y表示点击，z表示转化。针对这三个任务，设计了如图所示的模型结构：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://pic1.zhimg.com/80/v2-6d8189bfe378dc4bf6f0db2ba0255eac_1440w.jpg" alt="img" style="zoom:50%;" />
|
||||
</div>
|
||||
|
||||
|
||||
如图，主任务和辅助任务共享特征，不同任务输出层使用不同的网络，将cvr的预测值*ctr的预测值作为ctcvr任务的预测值，利用ctcvr和ctr的label构造损失函数：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://pic3.zhimg.com/80/v2-0098ab4556a8c67a1c12322ea3f89606_1440w.jpg" alt="img" style="zoom: 33%;" />
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
该架构具有两大特点，分别给出上述两个问题的解决方案：
|
||||
|
||||
- 帮助CVR模型在完整样本空间建模（即曝光空间X）。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://pic1.zhimg.com/80/v2-0b0c6dc7d4c38fa422a2876b7c4cc638_1440w.jpg" alt="img" style="zoom:33%;" />
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
从公式中可以看出，pCVR 可以由pCTR 和pCTCVR推导出。从原理上来说，相当于分别单独训练两个模型拟合出pCTR 和pCTCVR，再通过pCTCVR 除以pCTR 得到最终的拟合目标pCVR 。在训练过程中，模型只需要预测pCTCVR和pCTR，利用两种相加组成的联合loss更新参数。pCVR 只是一个中间变量。而pCTCVR和pCTR的数据是在完整样本空间中提取的，从而相当于pCVR也是在整个曝光样本空间中建模。
|
||||
|
||||
- 提供特征表达的迁移学习（embedding层共享）。CVR和CTR任务的两个子网络共享embedding层，网络的embedding层把大规模稀疏的输入数据映射到低维的表示向量，该层的参数占了整个网络参数的绝大部分，需要大量的训练样本才能充分学习得到。由于CTR任务的训练样本量要大大超过CVR任务的训练样本量，ESMM模型中特征表示共享的机制能够使得CVR子任务也能够从只有展现没有点击的样本中学习，从而能够极大地有利于缓解训练数据稀疏性问题。
|
||||
|
||||
模型训练完成后，可以同时预测cvr、ctr、ctcvr三个指标，线上根据实际需求进行融合或者只采用此模型得到的cvr预估值。
|
||||
|
||||
## 总结与拓展
|
||||
|
||||
可以思考以下几个问题
|
||||
|
||||
1. 能不能将乘法换成除法？
|
||||
即分别训练CTR和CTCVR模型，两者相除得到pCVR。论文提供了消融实验的结果，表中的DIVISION模型，比起BASE模型直接建模CTCVRR和CVR，有显著提高，但低于ESMM。原因是pCTR 通常很小，除以一个很小的浮点数容易引起数值不稳定问题。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://pic3.zhimg.com/80/v2-c0b2c860bd63a680d27c911c2e1ba8a2_1440w.jpg" alt="img" style="zoom:53%;" />
|
||||
</div>
|
||||
|
||||
2. 网络结构优化，Tower模型更换？两个塔不一致？
|
||||
原论文中的子任务独立的Tower网络是纯MLP模型，事实上业界在使用过程中一般会采用更为先进的模型（例如DeepFM、DIN等），两个塔也完全可以根据自身特点设置不一样的模型。这也是ESMM框架的优势，子网络可以任意替换，非常容易与其他学习模型集成。
|
||||
|
||||
3. 比loss直接相加更好的方式？
|
||||
原论文是将两个loss直接相加，还可以引入动态加权的学习机制。
|
||||
|
||||
4. 更长的序列依赖建模？
|
||||
有些业务的依赖关系不止有曝光-点击-转化三层，后续的改进模型提出了更深层次的任务依赖关系建模。
|
||||
|
||||
阿里的ESMM2: 在点击到购买之前，用户还有可能产生加入购物车（Cart）、加入心愿单（Wish）等行为。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://pic2.zhimg.com/80/v2-4f9f5508412086315f85d1b7fda733e9_1440w.jpg" alt="img" style="zoom:53%;" />
|
||||
</div>
|
||||
|
||||
相较于直接学习 click->buy (稀疏度约2.6%)，可以通过Action路径将目标分解，以Cart为例：click->cart (稀疏 度为10%)，cart->buy(稀疏度为12%)，通过分解路径，建立多任务学习模型来分步求解CVR模型，缓解稀疏问题，该模型同样也引入了特征共享机制。
|
||||
|
||||
美团的[AITM](https://zhuanlan.zhihu.com/p/508876139/[https://cloud.tencent.com/developer/article/1868117](https://cloud.tencent.com/developer/article/1868117))：信用卡业务中，用户转化通常是一个**曝光->点击->申请->核卡->激活**的过程，具有5层的链路。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://pic4.zhimg.com/80/v2-0ecf42e999795511f40ac6cd7b85eccf_1440w.jpg" alt="img" style="zoom:50%;" />
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
美团提出了一种自适应信息迁移多任务（**Adaptive Information Transfer Multi-task，AITM**）框架，该框架通过自适应信息迁移（AIT)模块对用户多步转化之间的序列依赖进行建模。AIT模块可以自适应地学习在不同的转化阶段需要迁移什么和迁移多少信息。
|
||||
|
||||
总结：
|
||||
|
||||
ESMM首创了利用用户行为序列数据在完整样本空间建模，并提出利用学习CTR和CTCVR的辅助任务，迂回学习CVR，避免了传统CVR模型经常遭遇的样本选择偏差和训练数据稀疏的问题，取得了显著的效果。
|
||||
|
||||
## 代码实践
|
||||
|
||||
与Shared-Bottom同样的共享底层机制，之后两个独立的Tower网络，分别输出CVR和CTR，计算loss时只利用CTR与CTCVR的loss。CVR Tower完成自身网络更新，CTR Tower同时完成自身网络和Embedding参数更新。在评估模型性能时，重点是评估主任务CVR的auc。
|
||||
|
||||
```python
|
||||
def ESSM(dnn_feature_columns, task_type='binary', task_names=['ctr', 'ctcvr'],
|
||||
tower_dnn_units_lists=[[128, 128],[128, 128]], l2_reg_embedding=0.00001, l2_reg_dnn=0,
|
||||
seed=1024, dnn_dropout=0,dnn_activation='relu', dnn_use_bn=False):
|
||||
|
||||
features = build_input_features(dnn_feature_columns)
|
||||
inputs_list = list(features.values())
|
||||
|
||||
sparse_embedding_list, dense_value_list = input_from_feature_columns(features, dnn_feature_columns, l2_reg_embedding,seed)
|
||||
|
||||
dnn_input = combined_dnn_input(sparse_embedding_list, dense_value_list)
|
||||
|
||||
ctr_output = DNN(tower_dnn_units_lists[0], dnn_activation, l2_reg_dnn, dnn_dropout, dnn_use_bn, seed=seed)(dnn_input)
|
||||
cvr_output = DNN(tower_dnn_units_lists[1], dnn_activation, l2_reg_dnn, dnn_dropout, dnn_use_bn, seed=seed)(dnn_input)
|
||||
|
||||
ctr_logit = tf.keras.layers.Dense(1, use_bias=False, activation=None)(ctr_output)
|
||||
cvr_logit = tf.keras.layers.Dense(1, use_bias=False, activation=None)(cvr_output)
|
||||
|
||||
ctr_pred = PredictionLayer(task_type, name=task_names[0])(ctr_logit)
|
||||
cvr_pred = PredictionLayer(task_type)(cvr_logit)
|
||||
|
||||
ctcvr_pred = tf.keras.layers.Multiply(name=task_names[1])([ctr_pred, cvr_pred])#CTCVR = CTR * CVR
|
||||
|
||||
model = tf.keras.models.Model(inputs=inputs_list, outputs=[ctr_pred, cvr_pred, ctcvr_pred])
|
||||
return model
|
||||
```
|
||||
|
||||
测试数据集：
|
||||
|
||||
adult：[https://archive.ics.uci.edu/ml/datasets/census+income](https://archive.ics.uci.edu/dataset/20/census+income)
|
||||
|
||||
将里面两个特征转为label，完成两个任务的预测：
|
||||
|
||||
- 任务1预测该用户收入是否大于50K，
|
||||
- 任务2预测该用户的婚姻是否未婚。
|
||||
|
||||
以上两个任务均为二分类任务，使用交叉熵作为损失函数。在ESMM框架下，我们把任务1作为CTR任务，任务2作为CVR任务，两者label相乘得到CTCVR任务的标签。
|
||||
|
||||
除ESSM之外，之后的MMOE、PLE模型都使用本数据集做测试。
|
||||
|
||||
> 注意上述代码，并未实现论文模型图中提到的field element-wise +模块。该模块实现较为简单，即分别把用户、商品相关特征的embedding求和再拼接，然后输入Tower网络。我们使用数据不具有该属性，暂未区分。
|
||||
|
||||
参考资料：
|
||||
|
||||
https://www.zhihu.com/question/475787809
|
||||
|
||||
https://zhuanlan.zhihu.com/p/37562283
|
||||
|
||||
美团：[https://cloud.tencent.com/developer/article/1868117](https://cloud.tencent.com/developer/article/1868117)
|
||||
|
||||
Entire Space Multi-Task Model: An Effective Approach for Estimating Post-Click Conversion Rate (SIGIR'2018)
|
||||
178
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.5/MMOE.md
Normal file
178
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.5/MMOE.md
Normal file
@@ -0,0 +1,178 @@
|
||||
# MMOE
|
||||
|
||||
## 写在前面
|
||||
|
||||
MMOE是2018年谷歌提出的，全称是Multi-gate Mixture-of-Experts， 对于多个优化任务，引入了多个专家进行不同的决策和组合，最终完成多目标的预测。解决的是硬共享里面如果多个任务相似性不是很强，底层的embedding学习反而相互影响，最终都学不好的痛点。
|
||||
|
||||
本篇文章首先是先了解下Hard-parameter sharing以及存在的问题，然后引出MMOE，对理论部分进行整理，最后是参考deepctr简单复现。
|
||||
|
||||
## 背景与动机
|
||||
|
||||
推荐系统中，即使同一个场景，常常也不只有一个业务目标。 在Youtube的视频推荐中，推荐排序任务不仅需要考虑到用户点击率，完播率，也需要考虑到一些满意度指标，例如，对视频是否喜欢，用户观看后对视频的评分；在淘宝的信息流商品推荐中，需要考虑到点击率，也需要考虑转化率；而在一些内容场景中，需要考虑到点击和互动、关注、停留时长等指标。
|
||||
|
||||
模型中，如果采用一个网络同时完成多个任务，就可以把这样的网络模型称为多任务模型， 这种模型能在不同任务之间学习共性以及差异性，能够提高建模的质量以及效率。 常见的多任务模型的设计范式大致可以分为三大类：
|
||||
* hard parameter sharing 方法： 这是非常经典的一种方式，底层是共享的隐藏层，学习各个任务的共同模式，上层用一些特定的全连接层学习特定任务模式。
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/ed10df1df313413daf2a6a6174ef4f8c.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA57-75rua55qE5bCPQOW8ug==,size_1,color_FFFFFF,t_70,g_se,x_16#pic_center" alt="在这里插入图片描述" style="zoom:70%;" />
|
||||
</div>
|
||||
这种方法目前用的也有，比如美团的猜你喜欢，知乎推荐的Ranking等， 这种方法最大的优势是Task越多， 单任务更加不可能过拟合，即可以减少任务之间过拟合的风险。 但是劣势也非常明显，就是底层强制的shared layers难以学习到适用于所有任务的有效表达。 **尤其是任务之间存在冲突的时候**。MMOE中给出了实验结论，当两个任务相关性没那么好(比如排序中的点击率与互动，点击与停留时长)，此时这种结果会遭受训练困境，毕竟所有任务底层用的是同一组参数。
|
||||
* soft parameter sharing: 硬的不行，那就来软的，这个范式对应的结果从`MOE->MMOE->PLE`等。 即底层不是使用共享的一个shared bottom，而是有多个tower， 称为多个专家，然后往往再有一个gating networks在多任务学习时，给不同的tower分配不同的权重，那么这样对于不同的任务，可以允许使用底层不同的专家组合去进行预测，相较于上面所有任务共享底层，这个方式显得更加灵活
|
||||
* 任务序列依赖关系建模：这种适合于不同任务之间有一定的序列依赖关系。比如电商场景里面的ctr和cvr，其中cvr这个行为只有在点击之后才会发生。所以这种依赖关系如果能加以利用，可以解决任务预估中的样本选择偏差(SSB)和数据稀疏性(DS)问题
|
||||
* 样本选择偏差: 后一阶段的模型基于上一阶段采样后的样本子集训练，但最终在全样本空间进行推理，带来严重泛化性问题
|
||||
* 样本稀疏： 后一阶段的模型训练样本远小于前一阶段任务
|
||||
|
||||
<br>ESSM是一种较为通用的任务序列依赖关系建模的方法，除此之外，阿里的DBMTL，ESSM2等工作都属于这一个范式。 这个范式可能后面会进行整理，本篇文章不过多赘述。
|
||||
|
||||
通过上面的描述，能大体上对多任务模型方面的几种常用建模范式有了解，然后也知道了hard parameter sharing存在的一些问题，即不能很好的权衡特定任务的目标与任务之间的冲突关系。而这也就是MMOE模型提出的一个动机所在了， 那么下面的关键就是MMOE模型是怎么建模任务之间的关系的，又是怎么能使得特定任务与任务关系保持平衡的？
|
||||
|
||||
带着这两个问题，下面看下MMOE的细节。
|
||||
|
||||
## MMOE模型的理论及论文细节
|
||||
MMOE模型结构图如下。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://img-blog.csdnimg.cn/29c5624f2c8a46c097f097af7dbf4b45.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA57-75rua55qE5bCPQOW8ug==,size_2,color_FFFFFF,t_70,g_se,x_16#pic_center" alt="在这里插入图片描述" style="zoom:70%;" />
|
||||
</div>
|
||||
|
||||
这其实是一个演进的过程，首先hard parameter sharing这个就不用过多描述了， 下面主要是看MOE模型以及MMOE模型。
|
||||
|
||||
### 混合专家模型
|
||||
我们知道共享的这种模型结构，会遭受任务之间冲突而导致可能无法很好的收敛，从而无法学习到任务之间的共同模式。这个结构也可以看成是多个任务共用了一个专家。
|
||||
|
||||
先抛开任务关系， 我们发现一个专家在多任务学习上的表达能力很有限，于是乎，尝试引入多个专家，这就慢慢的演化出了混合专家模型。 公式表达如下：
|
||||
$$
|
||||
y=\sum_{i=1}^{n} g(x)_{i} f_{i}(x)
|
||||
$$
|
||||
这里的$y$表示的是多个专家的汇总输出，接下来这个东西要过特定的任务塔去得到特定任务的输出。 这里还加了一个门控网络机制，就是一个注意力网络， 来学习各个专家的重要性权重$\sum_{i=1}^{n} g(x)_{i}=1$。$f_i(x)$就是每个专家的输出， 而$g(x)_i$就是每个专家对应的权重。 虽然感觉这个东西，无非就是在单个专家的基础上多引入了几个全连接网络，然后又给这几个全连接网络加权，但是在我看来，这里面至少蕴含了好几个厉害的思路：
|
||||
1. 模型集成思想： 这个东西很像bagging的思路，即训练多个模型进行决策，这个决策的有效性显然要比单独一个模型来的靠谱一点，不管是从泛化能力，表达能力，学习能力上，应该都强于一个模型
|
||||
2. 注意力思想: 为了增加灵活性， 为不同的模型还学习了重要性权重，这可能考虑到了在学习任务的共性模式上， 不同的模型学习的模式不同，那么聚合的时候，显然不能按照相同的重要度聚合，所以为各个专家学习权重，默认了不同专家的决策地位不一样。这个思想目前不过也非常普遍了。
|
||||
3. multi-head机制: 从另一个角度看， 多个专家其实代表了多个不同head, 而不同的head代表了不同的非线性空间，之所以说表达能力增强了，是因为把输入特征映射到了不同的空间中去学习任务之间的共性模式。可以理解成从多个角度去捕捉任务之间的共性特征模式。
|
||||
|
||||
MOE使用了多个混合专家增加了各种表达能力，但是， 一个门控并不是很灵活，因为这所有的任务，最终只能选定一组专家组合，即这个专家组合是在多个任务上综合衡量的结果，并没有针对性了。 如果这些任务都比较相似，那就相当于用这一组专家组合确实可以应对这多个任务，学习到多个相似任务的共性。 但如果任务之间差的很大，这种单门控控制的方式就不行了，因为此时底层的多个专家学习到的特征模式相差可能会很大，毕竟任务不同，而单门控机制选择专家组合的时候，肯定是选择出那些有利于大多数任务的专家， 而对于某些特殊任务，可能学习的一塌糊涂。
|
||||
|
||||
所以，这种方式的缺口很明显，这样，也更能理解为啥提出多门控控制的专家混合模型了。
|
||||
|
||||
### MMOE结构
|
||||
Multi-gate Mixture-of-Experts(MMOE)的魅力就在于在OMOE的基础上，对于每个任务都会涉及一个门控网络，这样，对于每个特定的任务，都能有一组对应的专家组合去进行预测。更关键的时候，参数量还不会增加太多。公式如下：
|
||||
|
||||
$$
|
||||
y_{k}=h^{k}\left(f^{k}(x)\right),
|
||||
$$
|
||||
where $f^{k}(x)=\sum_{i=1}^{n} g^{k}(x)_{i} f_{i}(x)$. 这里的$k$表示任务的个数。 每个门控网络是一个注意力网络：
|
||||
$$
|
||||
g^{k}(x)=\operatorname{softmax}\left(W_{g k} x\right)
|
||||
$$
|
||||
$W_{g k} \in \mathbb{R}^{n \times d}$表示权重矩阵， $n$是专家的个数， $d$是特征的维度。
|
||||
|
||||
上面的公式这里不用过多解释。
|
||||
|
||||
这个改造看似很简单，只是在OMOE上额外多加了几个门控网络，但是却起到了杠杆般的效果，我这里分享下我的理解。
|
||||
* 首先，就刚才分析的OMOE的问题，在专家组合选取上单门控会产生限制，此时如果多个任务产生了冲突，这种结构就无法进行很好的权衡。 而MMOE就不一样了。MMOE是针对每个任务都单独有个门控选择专家组合，那么即使任务冲突了，也能根据不同的门控进行调整，选择出对当前任务有帮助的专家组合。所以，我觉得单门控做到了**针对所有任务在专家选择上的解耦**，而多门控做到了**针对各个任务在专家组合选择上的解耦**。
|
||||
* 多门控机制能够建模任务之间的关系了。如果各个任务都冲突， 那么此时有多门控的帮助， 此时让每个任务独享一个专家，如果任务之间能聚成几个相似的类，那么这几类之间应该对应的不同的专家组合，那么门控机制也可以选择出来。如果所有任务都相似，那这几个门控网络学习到的权重也会相似，所以这种机制把任务的无关，部分相关和全相关进行了一种统一。
|
||||
* 灵活的参数共享， 这个我们可以和hard模式或者是针对每个任务单独建模的模型对比，对于hard模式，所有任务共享底层参数，而每个任务单独建模，是所有任务单独有一套参数，算是共享和不共享的两个极端，对于都共享的极端，害怕任务冲突，而对于一点都不共享的极端，无法利用迁移学习的优势，模型之间没法互享信息，互为补充，容易遭受过拟合的困境，另外还会增加计算量和参数量。 而MMOE处于两者的中间，既兼顾了如果有相似任务，那就参数共享，模式共享，互为补充，如果没有相似任务，那就独立学习，互不影响。 又把这两种极端给进行了统一。
|
||||
* 训练时能快速收敛，这是因为相似的任务对于特定的专家组合训练都会产生贡献，这样进行一轮epoch，相当于单独任务训练时的多轮epoch。
|
||||
|
||||
OK， 到这里就把MMOE的故事整理完了，模型结构本身并不是很复杂，非常符合"大道至简"原理，简单且实用。
|
||||
|
||||
|
||||
那么， 为什么多任务学习为什么是有效的呢？ 这里整理一个看到比较不错的答案：
|
||||
>多任务学习有效的原因是引入了归纳偏置，两个效果：
|
||||
> - 互相促进： 可以把多任务模型之间的关系看作是互相 先验知识，也称为归纳迁移，有了对模型的先验假设，可以更好提升模型的效果。解决数据稀疏性其实本身也是迁移学习的一个特性，多任务学习中也同样会体现
|
||||
> - 泛化作用：不同模型学到的表征不同，可能A模型学到的是B模型所没有学好的，B模型也有其自身的特点，而这一点很可能A学不好，这样一来模型健壮性更强
|
||||
|
||||
## MMOE模型的简单复现之多任务预测
|
||||
### 模型概貌
|
||||
这里是MMOE模型的简单复现，参考的deepctr。
|
||||
|
||||
由于MMOE模型不是很复杂，所以这里就可以直接上代码，然后简单解释：
|
||||
|
||||
```python
|
||||
def MMOE(dnn_feature_columns, num_experts=3, expert_dnn_hidden_units=(256, 128), tower_dnn_hidden_units=(64,),
|
||||
gate_dnn_hidden_units=(), l2_reg_embedding=0.00001, l2_reg_dnn=0, dnn_dropout=0, dnn_activation='relu',
|
||||
dnn_use_bn=False, task_types=('binary', 'binary'), task_names=('ctr', 'ctcvr')):
|
||||
|
||||
num_tasks = len(task_names)
|
||||
|
||||
# 构建Input层并将Input层转成列表作为模型的输入
|
||||
input_layer_dict = build_input_layers(dnn_feature_columns)
|
||||
input_layers = list(input_layer_dict.values())
|
||||
|
||||
# 筛选出特征中的sparse和Dense特征， 后面要单独处理
|
||||
sparse_feature_columns = list(filter(lambda x: isinstance(x, SparseFeat), dnn_feature_columns))
|
||||
dense_feature_columns = list(filter(lambda x: isinstance(x, DenseFeat), dnn_feature_columns))
|
||||
|
||||
# 获取Dense Input
|
||||
dnn_dense_input = []
|
||||
for fc in dense_feature_columns:
|
||||
dnn_dense_input.append(input_layer_dict[fc.name])
|
||||
|
||||
# 构建embedding字典
|
||||
embedding_layer_dict = build_embedding_layers(dnn_feature_columns)
|
||||
# 离散的这些特特征embedding之后，然后拼接，然后直接作为全连接层Dense的输入，所以需要进行Flatten
|
||||
dnn_sparse_embed_input = concat_embedding_list(sparse_feature_columns, input_layer_dict, embedding_layer_dict, flatten=False)
|
||||
|
||||
# 把连续特征和离散特征合并起来
|
||||
dnn_input = combined_dnn_input(dnn_sparse_embed_input, dnn_dense_input)
|
||||
|
||||
# 建立专家层
|
||||
expert_outputs = []
|
||||
for i in range(num_experts):
|
||||
expert_network = DNN(expert_dnn_hidden_units, dnn_activation, l2_reg_dnn, dnn_dropout, dnn_use_bn, seed=2022, name='expert_'+str(i))(dnn_input)
|
||||
expert_outputs.append(expert_network)
|
||||
|
||||
expert_concat = Lambda(lambda x: tf.stack(x, axis=1))(expert_outputs)
|
||||
|
||||
# 建立多门控机制层
|
||||
mmoe_outputs = []
|
||||
for i in range(num_tasks): # num_tasks=num_gates
|
||||
# 建立门控层
|
||||
gate_input = DNN(gate_dnn_hidden_units, dnn_activation, l2_reg_dnn, dnn_dropout, dnn_use_bn, seed=2022, name='gate_'+task_names[i])(dnn_input)
|
||||
gate_out = Dense(num_experts, use_bias=False, activation='softmax', name='gate_softmax_'+task_names[i])(gate_input)
|
||||
gate_out = Lambda(lambda x: tf.expand_dims(x, axis=-1))(gate_out)
|
||||
|
||||
# gate multiply the expert
|
||||
gate_mul_expert = Lambda(lambda x: reduce_sum(x[0] * x[1], axis=1, keep_dims=False), name='gate_mul_expert_'+task_names[i])([expert_concat, gate_out])
|
||||
|
||||
mmoe_outputs.append(gate_mul_expert)
|
||||
|
||||
# 每个任务独立的tower
|
||||
task_outputs = []
|
||||
for task_type, task_name, mmoe_out in zip(task_types, task_names, mmoe_outputs):
|
||||
# 建立tower
|
||||
tower_output = DNN(tower_dnn_hidden_units, dnn_activation, l2_reg_dnn, dnn_dropout, dnn_use_bn, seed=2022, name='tower_'+task_name)(mmoe_out)
|
||||
logit = Dense(1, use_bias=False, activation=None)(tower_output)
|
||||
output = PredictionLayer(task_type, name=task_name)(logit)
|
||||
task_outputs.append(output)
|
||||
|
||||
model = Model(inputs=input_layers, outputs=task_outputs)
|
||||
return model
|
||||
```
|
||||
这个其实比较简单， 首先是传入封装好的dnn_features_columns， 这个是
|
||||
|
||||
```python
|
||||
dnn_features_columns = [SparseFeat(feat, feature_max_idx[feat], embedding_dim=4) for feat in sparse_features] \
|
||||
+ [DenseFeat(feat, 1) for feat in dense_features]
|
||||
```
|
||||
就是数据集先根据特征类别分成离散型特征和连续型特征，然后通过sparseFeat或者DenseFeat进行封装起来，组成的一个列表。
|
||||
|
||||
传入之后， 首先为这所有的特征列建立Input层，然后选择出离散特征和连续特征来，连续特征直接拼接即可， 而离散特征需要过embedding层得到连续型输入。把这个输入与连续特征拼接起来，就得到了送入专家的输入。
|
||||
|
||||
接下来，建立MMOE的多个专家， 这里的专家直接就是DNN，当然这个可以替换，比如MOSE里面就用了LSTM，这样的搭建模型方式非常灵活，替换起来非常简单。 把输入过多个专家得到的专家的输出，这里放到了列表里面。
|
||||
|
||||
接下来，建立多个门控网络，由于MMOE里面是每个任务会有一个单独的门控进行控制，所以这里的门控网络个数和任务数相同，门控网络也是DNN，接收输入，得到专家个输出作为每个专家的权重，把每个专家的输出加权组合得到门控网络最终的输出，放到列表中，这里的列表长度和task_num对应。
|
||||
|
||||
接下来， 为每个任务建立tower，学习特定的feature信息。同样也是DNN，接收的输入是上面列表的输出，每个任务的门控输出输入到各自的tower里面，得到最终的输出即可。 最终的输出也是个列表，对应的每个任务最终的网络输出值。
|
||||
|
||||
这就是整个MMOE网络的搭建逻辑。
|
||||
|
||||
|
||||
**参考资料**:
|
||||
* [MMOE论文](https://dl.acm.org/doi/pdf/10.1145/3219819.3220007)
|
||||
* [Recommending What Video to Watch Next: A Multitask
|
||||
Ranking System](https://dl.acm.org/doi/pdf/10.1145/3298689.3346997)
|
||||
* [Multitask Mixture of Sequential Experts for User Activity Streams](https://research.google/pubs/pub49274/)
|
||||
* [推荐系统中的多目标学习](https://zhuanlan.zhihu.com/p/183760759)
|
||||
* [推荐精排模型之多目标](https://zhuanlan.zhihu.com/p/221738556)
|
||||
* [Youtube视频推荐中应用MMOE模型](http://t.zoukankan.com/Lee-yl-p-13274642.html)
|
||||
* [多任务学习论文导读：Recommending What Video to Watch Next-A Multitask Ranking System](https://blog.csdn.net/fanzitao/article/details/104525843/)
|
||||
* [多任务模型之MoSE](https://zhuanlan.zhihu.com/p/161628342)
|
||||
389
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.5/PLE.md
Normal file
389
2023旧版内容/4.人工智能/ch02/ch2.2/ch2.2.5/PLE.md
Normal file
@@ -0,0 +1,389 @@
|
||||
# PLE
|
||||
|
||||
**PLE**(Progressive Layered Extraction)模型由腾讯PCG团队在2020年提出，主要为了解决跷跷板问题，该论文获得了RecSys'2020的最佳长论文（Best Lone Paper Award）。
|
||||
|
||||
## 背景与动机
|
||||
|
||||
文章首先提出多任务学习中不可避免的两个缺点：
|
||||
|
||||
- 负迁移（Negative Transfer）：针对相关性较差的任务，使用shared-bottom这种硬参数共享的机制会出现负迁移现象，不同任务之间存在冲突时，会导致模型无法有效进行参数的学习，不如对多个任务单独训练。
|
||||
- 跷跷板现象（Seesaw Phenomenon）：针对相关性较为复杂的场景，通常不可避免出现跷跷板现象。多任务学习模式下，往往能够提升一部分任务的效果，但同时需要牺牲其他任务的效果。即使通过MMOE这种方式减轻负迁移现象，跷跷板问题仍然广泛存在。
|
||||
|
||||
在腾讯视频推荐场景下，有两个核心建模任务：
|
||||
|
||||
- VCR(View Completion Ratio)：播放完成率，播放时间占视频时长的比例，回归任务
|
||||
- VTR(View Through Rate) ：有效播放率，播放时间是否超过某个阈值，分类任务
|
||||
|
||||
这两个任务之间的关系是复杂的，在应用以往的多任务模型中发现，要想提升VTR准确率，则VCR准确率会下降，反之亦然。
|
||||
|
||||
上一小节提到的MMOE网络存在如下几个缺点
|
||||
|
||||
- MMOE中所有的Expert是被所有任务所共享，这可能无法捕捉到任务之间更复杂的关系，从而给部分任务带来一定的噪声。
|
||||
- 在复杂任务机制下，MMOE不同专家在不同任务的权重学的差不多
|
||||
- 不同的Expert之间没有交互，联合优化的效果有所折扣
|
||||
|
||||
## 解决方案
|
||||
|
||||
为了解决跷跷板现象，以及优化MMOE模型，PLE在网络结构设计上提出两大改进：
|
||||
|
||||
**一、CGC**(Customized Gate Control) 定制门控
|
||||
|
||||
PLE将共享的部分和每个任务特定的部分**显式的分开**，强化任务自身独立特性。把MMOE中提出的Expert分成两种，任务特定task-specific和任务共享task-shared。保证expert“各有所得”，更好的降低了弱相关性任务之间参数共享带来的问题。
|
||||
|
||||
网络结构如图所示，同样的特征输入分别送往三类不同的专家模型（任务A专家、任务B专家、任务共享专家），再通过门控机制加权聚合之后输入各自的Tower网络。门控网络，把原始数据和expert网络输出共同作为输入，通过单层全连接网络+softmax激活函数，得到分配给expert的加权权重，与attention机制类型。
|
||||
|
||||
|
||||
|
||||
<div align=center>
|
||||
<img src="https://pic3.zhimg.com/80/v2-c92975f7c21cc568a13cd9447adc757a_1440w.jpg" style="zoom:40%;" />
|
||||
</div>
|
||||
|
||||
任务A有 ![[公式]](https://www.zhihu.com/equation?tex=m_A) 个expert，任务B有 ![[公式]](https://www.zhihu.com/equation?tex=m_B) 个expert，另外还有 ![[公式]](https://www.zhihu.com/equation?tex=m_S) 个任务A、B共享的Expert。这样对Expert做一个显式的分割，可以让task-specific expert只受自己任务梯度的影响，不会受到其他任务的干扰（每个任务保底有一个独立的网络模型)，而只有task-shared expert才受多个任务的混合梯度影响。
|
||||
|
||||
MMOE则是将所有Expert一视同仁，都加权输入到每一个任务的Tower，其中任务之间的关系完全交由gate自身进行学习。虽然MMOE提出的门控机制理论上可以捕捉到任务之间的关系，比如任务A可能与任务B确实无关，则MMOE中gate可以学到，让个别专家对于任务A的权重趋近于0，近似得到PLE中提出的task-specific expert。如果说MMOE是希望让expert网络可以对不同的任务各有所得，则PLE是保证让expert网络各有所得。
|
||||
|
||||
二、**PLE** (progressive layered extraction) 分层萃取
|
||||
|
||||
PLE就是上述CGC网络的多层纵向叠加，以获得更加丰富的表征能力。在分层的机制下，Gate设计成两种类型，使得不同类型Expert信息融合交互。task-share gate融合所有Expert信息，task-specific gate只融合specific expert和share expert。模型结构如图：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://pic2.zhimg.com/80/v2-ff3b4aff3511e6e56a3b509f244c5ab1_1440w.jpg" style="zoom:40%;" />
|
||||
</div>
|
||||
|
||||
将任务A、任务B和shared expert的输出输入到下一层，下一层的gate是以这三个上一层输出的结果作为门控的输入，而不是用原始input特征作为输入。这使得gate同时融合task-shares expert和task-specific expert的信息，论文实验中证明这种不同类型expert信息的交叉，可以带来更好的效果。
|
||||
|
||||
三、多任务loss联合优化
|
||||
|
||||
该论文专门讨论了loss设计的问题。在传统的多任务学习模型中，多任务的loss一般为
|
||||
|
||||
<div align=center>
|
||||
<img src="https://pic4.zhimg.com/80/v2-ec1a0ae2a4001fea296662a9a5a1942b_1440w.jpg" style="zoom:33%;" />
|
||||
</div>
|
||||
|
||||
其中K是指任务数， ![[公式]](https://www.zhihu.com/equation?tex=w_k) 是每个任务各自对应的权重。这种loss存在两个关键问题：
|
||||
|
||||
- 不同任务之间的样本空间不一致：在视频推荐场景中，目标之间的依赖关系如图，曝光→播放→点击→(分享、评论），不同任务有不同的样本空间。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://pic3.zhimg.com/80/v2-bdf39ef6fcaf000924294cb010642fce_1440w.jpg" style="zoom:63%;" />
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
PLE将训练样本空间作为全部任务样本空间的并集，在分别针对每个任务算loss时，只考虑该任务的样本的空 间，一般需对这种数据集会附带一个样本空间标签。loss公式如下：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://pic2.zhimg.com/80/v2-8defd1e5d1ba896bb2d18bdb1db4e3cd_1440w.jpg" style="zoom:40%;" />
|
||||
</div>
|
||||
|
||||
|
||||
其中， ![[公式]](https://www.zhihu.com/equation?tex=%5Cdelta_%7Bk%7D%5E%7Bi%7D+%5Cin%5C%7B0%2C1%5C%7D%2C+%5Cdelta_%7Bk%7D%5E%7Bi%7D+) 表示样本i是否处于任务k的样本空间。
|
||||
|
||||
- 不同任务各自独立的权重设定：PLE提出了一种加权的规则，它的思想是随着迭代次数的增加，任务的权重应当不断衰减。它为每个任务设定一个初始权重 ![[公式]](https://www.zhihu.com/equation?tex=w_%7Bk%2C0%7D) ，再按该公式进行更新：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://pic1.zhimg.com/80/v2-2fbd23599bd2cd62222607e76cb975ec_1440w.jpg" style="zoom:40%;" />
|
||||
</div>
|
||||
|
||||
## 实验
|
||||
|
||||
该论文的一大特点是提供了极其丰富的实验，首先是在自身大规模数据集上的离线实验。
|
||||
|
||||
第一组实验是两个关系复杂的任务VTR（回归）与VCR（分类），如表1，实验结果证明PLE可以实现多任务共赢，而其他的硬共享或者软共享机制，则会导致部分任务受损。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://pic1.zhimg.com/80/v2-4a190a8a3bcd810fbe1e810171ddc25c_1440w.jpg" alt="img" style="zoom: 33%;" />
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
第二组实验是两个关系简单清晰的任务，CTR与VCR，都是分类任务，且CTR→VCR存在任务依赖关系，如表2，这种多任务下，基本上所有参数共享的模型都能得到性能的提升，而PLE的提升效果最为明显。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://pic4.zhimg.com/80/v2-29baaf461d29a4eff32e7ea324ef7f77_1440w.jpg" alt="img" style="zoom: 50%;" />
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
第三组实验则是线上的A/B Test，上面两组离线实验中，其实PLE相比于其他baseline模型，无论是回归任务的mse，还是分类任务的auc，提升都不是特别显著。在推荐场景中，评估模型性能的最佳利器还是线上的A/B Test。作者在pcg视频推荐的场景中，将部分用户随机划分到不同的实验组中，用PLE模型预估VTR和VCR，进行四周的实验。如表3所示，线上评估指标（总播放完成视频数量和总播放时间）均得到了较为显著的提升，而硬参数共享模型则带对两个指标都带来显著的下降。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://pic3.zhimg.com/80/v2-d6daf1d58fa5edd9fa96aefd254f71ee_1440w.jpg" alt="img" style="zoom: 50%;" />
|
||||
</div>
|
||||
|
||||
第四组实验中，作者引入了更多的任务，验证PLE分层结构的必要性。如表4，随着任务数量的增加，PLE对比CGC的优势更加显著。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://pic4.zhimg.com/80/v2-0b13558bc7e95f601c60a26deaff9acf_1440w.jpg" alt="img" style="zoom:50%;" />
|
||||
</div>
|
||||
|
||||
文中也设计实验，单独对MMOE和CGC的专家利用率进行对比分析，为了实现方便和公平，每个expert都是一个一层网络，每个expert module都只有一个expert，每一层只有3个expert。如图所示，柱子的高度和竖直短线分别表示expert权重的均值和方差。
|
||||
|
||||
<div align=center>
|
||||
<img src="https://pic4.zhimg.com/80/v2-557473be41f7f6fa5efc1ff17e21bab7_1440w.jpg" alt="img" style="zoom:50%;" />
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
可以看到，无论是 MMoE 还是 ML-MMoE，不同任务在三个 Expert 上的权重都是接近的，但对于 CGC & PLE 来说，不同任务在共享 Expert 上的权重是有较大差异的。PLE针对不同的任务，能够有效利用共享 Expert 和独有 Expert 的信息，解释了为什么其能够达到比 MMoE 更好的训练结果。CGC理论上是MMOE的子集，该实验表明，现实中MMOE很难收敛成这个CGC的样子，所以PLE模型就显式的规定了CGC这样的结构。
|
||||
|
||||
## 总结与拓展
|
||||
|
||||
总结：
|
||||
|
||||
CGC在结构上设计的分化，实现了专家功能的分化，而PLE则是通过分层叠加，使得不同专家的信息进行融合。整个结构的设计，是为了让多任务学习模型，不仅可以学习到各自任务独有的表征，还能学习不同任务共享的表征。
|
||||
|
||||
论文中也对大多数的MTL模型进行了抽象，总结如下图：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://pic2.zhimg.com/80/v2-d607cd8e14d4a0fadb4dbef06dc2ffa9_1440w.jpg" alt="img" style="zoom:50%;" />
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
不同的MTL模型即不同的参数共享机制，CGC的结构最为灵活。
|
||||
|
||||
可以思考下以下几个问题：
|
||||
|
||||
1. 多任务模型线上如何打分融合？
|
||||
在论文中，作者分享了腾讯视频的一种线上打分机制
|
||||
|
||||
<div align=center>
|
||||
<img src="https://pic2.zhimg.com/80/v2-9a412b82d45877287df2429fc89afac5_1440w.jpg" alt="img" style="zoom:33%;" />
|
||||
</div>
|
||||
|
||||
每个目标的预估值有一个固定的权重，通过乘法进行融合，并在最后未来排除视频自身时长的影响，使用 $ f(videolen)$对视频时长进行了非线性变化。其实在业界的案例中，也基本是依赖乘法或者加法进行融合，爱奇艺曾经公开分享过他们使用过的打分方法：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://pic1.zhimg.com/80/v2-661030ad194ae2059eace0804ef0f774_1440w.jpg" alt="img" style="zoom: 67%;" />
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
在业务目标较少时，通过加法方式融合新增目标可以短期内快速获得收益。但是随着目标增多，加法融合会 逐步弱化各字母表的重要性影响，而乘法融合则具有一定的模板独立性，乘法机制更加灵活，效益更好。融 合的权重超参一般在线上通过A/B test调试。
|
||||
|
||||
2. 专家的参数如何设置？
|
||||
PLE模型存在的超参数较多，其中专家和门控网络都有两种类型。一般来说，task-specific expert每个任务1-2个，shared expert个数在任务个数的1倍以上。原论文中的gate网络即单层FC，可以适当增加，调试。
|
||||
|
||||
3. ESMM、MMOE、PLE模型如何选择？
|
||||
|
||||
- 个人经验，无论任务之间是否有依赖关系，皆可以优先尝试CGC。而多层CGC（即PLE）未必比CGC效果好，且在相同参数规模小，CGC普遍好于MMOE。对于相关性特别差的多任务，CGC相对MMOE而言有多个专有expert兜底。
|
||||
|
||||
- 对于典型的label存在路径依赖的多任务，例如CTR与CVR，可尝试ESMM。
|
||||
|
||||
- 而在业界的实践案例中，更多的是两种范式的模型进行融合。例如美团在其搜索多业务排序场景上提出的模型：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://pic2.zhimg.com/80/v2-af16e969a0149aef9c2a1291de5c65d5_1440w.jpg" alt="img" style="zoom:50%;" />
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
总框架是ESMM的架构，以建模下单（CVR）为主任务，CTR和CTCVR为辅助任务。在底层的模块中，则使用了CGC模块，提取多任务模式下的特征表达信息。
|
||||
|
||||
4. 不同Tower能否输入不同的特征？不同的expert使用不同的特征？不同的门控使用不同的特征？
|
||||
MMOE、PLE原论文中介绍的模型均是使用同样的原始特征输入各个不同的expert，也输入给第一层的gate。最顶层的Tower网络中则均是由一个gate融合所有expert输出作为输入。在实践中，可以根据业务需求进行调整。
|
||||
|
||||
- 例如上图中美团提出的模型，在CTR的tower下，设置了五个子塔：闪购子网络、买菜子网络、外卖子网络、优选子网络和团好货子网络，并且对不同的子塔有额外输入不同的特征。
|
||||
对于底层输入给expert的特征，美团提出通过增加一个自适应的特征选择门，使得选出的特征对不同的业务权重不同。例如“配送时间”这个特征对闪购业务比较重要，但对于团好货影响不是很大。模型结构如图：
|
||||
|
||||
<div align=center>
|
||||
<img src="https://pic2.zhimg.com/80/v2-2e2370794bbd69ded636a248d8c36255_1440w.jpg" alt="img" style="zoom:50%;" />
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
特征选择门与控制expert信息融合的gate类似，由一层FC和softmax组成，输出是特征维度的权重。对于每一个特征通过该门都得到一个权重向量，权重向量点乘原始特征的embedding作为expert的输入。
|
||||
|
||||
5. 多任务loss更高效的融合机制
|
||||
|
||||
推荐首先尝试两种简单实用的方法，GrandNorm和UWL，具体实现细节查看下文所附的参考资料。
|
||||
|
||||
- UWL（Uncertainty Weight）：通过自动学习任务的uncertainty，给uncertainty大的任务小权重，uncertainty小的任务大权重；
|
||||
- GradNorm：结合任务梯度的二范数和loss下降梯度，引入带权重的损失函数Gradient Loss，并通过梯度下降更新该权重。
|
||||
|
||||
## 代码实践
|
||||
|
||||
主要是分两个层级，在PLE的层级下，由于PLE是分层，上一层是输出是下一层的输入，代码逻辑为：
|
||||
|
||||
```python
|
||||
# build Progressive Layered Extraction
|
||||
ple_inputs = [dnn_input] * (num_tasks + 1) # [task1, task2, ... taskn, shared task]
|
||||
ple_outputs = []
|
||||
for i in range(num_levels):
|
||||
if i == num_levels - 1: # the last level
|
||||
ple_outputs = cgc_net(inputs=ple_inputs, level_name='level_' + str(i) + '_', is_last=True)
|
||||
else:
|
||||
ple_outputs = cgc_net(inputs=ple_inputs, level_name='level_' + str(i) + '_', is_last=False)
|
||||
ple_inputs = ple_outputs
|
||||
```
|
||||
|
||||
其中cgc_net函数则对应论文中提出的CGC模块，我们把expert分成两类，task-specific和task-shared，为了方便索引，expert list中expert的排列顺序为[task1-expert1, task1-expert2,...task2-expert1, task2-expert2,...shared expert 1... ]，则可以通过双重循环创建专家网络:
|
||||
|
||||
```python
|
||||
for i in range(num_tasks): #任务个数
|
||||
for j in range(specific_expert_num): #每个任务对应的task-specific专家个数
|
||||
pass
|
||||
```
|
||||
|
||||
注意门控网络也分为两种类型，task-specific gate的输入是每个任务对应的expert的输出和共享expert的输出，我们同样把共享expert的输出放在最后，方便索引
|
||||
|
||||
```python
|
||||
for i in range(num_tasks):
|
||||
# concat task-specific expert and task-shared expert
|
||||
cur_expert_num = specific_expert_num + shared_expert_num
|
||||
# task_specific + task_shared
|
||||
cur_experts = specific_expert_outputs[
|
||||
i * specific_expert_num:(i + 1) * specific_expert_num] + shared_expert_outputs
|
||||
```
|
||||
|
||||
在最后一层中，由于CGC模块的输出需要分别输入给不同任务各自的Tower模块，所以不需要创建task-shared gate。完整代码如下
|
||||
|
||||
```python
|
||||
def PLE(dnn_feature_columns, shared_expert_num=1, specific_expert_num=1, num_levels=2,
|
||||
expert_dnn_hidden_units=(256,), tower_dnn_hidden_units=(64,), gate_dnn_hidden_units=(),
|
||||
l2_reg_embedding=0.00001,
|
||||
l2_reg_dnn=0, seed=1024, dnn_dropout=0, dnn_activation='relu', dnn_use_bn=False,
|
||||
task_types=('binary', 'binary'), task_names=('ctr', 'ctcvr')):
|
||||
"""Instantiates the multi level of Customized Gate Control of Progressive Layered Extraction architecture.
|
||||
:param dnn_feature_columns: An iterable containing all the features used by deep part of the model.
|
||||
:param shared_expert_num: integer, number of task-shared experts.
|
||||
:param specific_expert_num: integer, number of task-specific experts.
|
||||
:param num_levels: integer, number of CGC levels.
|
||||
:param expert_dnn_hidden_units: list,list of positive integer or empty list, the layer number and units in each layer of expert DNN.
|
||||
:param tower_dnn_hidden_units: list,list of positive integer or empty list, the layer number and units in each layer of task-specific DNN.
|
||||
:param gate_dnn_hidden_units: list,list of positive integer or empty list, the layer number and units in each layer of gate DNN.
|
||||
:param l2_reg_embedding: float. L2 regularizer strength applied to embedding vector.
|
||||
:param l2_reg_dnn: float. L2 regularizer strength applied to DNN.
|
||||
:param seed: integer ,to use as random seed.
|
||||
:param dnn_dropout: float in [0,1), the probability we will drop out a given DNN coordinate.
|
||||
:param dnn_activation: Activation function to use in DNN.
|
||||
:param dnn_use_bn: bool. Whether use BatchNormalization before activation or not in DNN.
|
||||
:param task_types: list of str, indicating the loss of each tasks, ``"binary"`` for binary logloss, ``"regression"`` for regression loss. e.g. ['binary', 'regression']
|
||||
:param task_names: list of str, indicating the predict target of each tasks
|
||||
:return: a Keras model instance.
|
||||
"""
|
||||
num_tasks = len(task_names)
|
||||
if num_tasks <= 1:
|
||||
raise ValueError("num_tasks must be greater than 1")
|
||||
|
||||
if len(task_types) != num_tasks:
|
||||
raise ValueError("num_tasks must be equal to the length of task_types")
|
||||
|
||||
for task_type in task_types:
|
||||
if task_type not in ['binary', 'regression']:
|
||||
raise ValueError("task must be binary or regression, {} is illegal".format(task_type))
|
||||
|
||||
features = build_input_features(dnn_feature_columns)
|
||||
|
||||
inputs_list = list(features.values())
|
||||
|
||||
sparse_embedding_list, dense_value_list = input_from_feature_columns(features, dnn_feature_columns,
|
||||
l2_reg_embedding, seed)
|
||||
dnn_input = combined_dnn_input(sparse_embedding_list, dense_value_list)
|
||||
|
||||
# single Extraction Layer
|
||||
def cgc_net(inputs, level_name, is_last=False):
|
||||
# inputs: [task1, task2, ... taskn, shared task]
|
||||
specific_expert_outputs = []
|
||||
# build task-specific expert layer
|
||||
for i in range(num_tasks):
|
||||
for j in range(specific_expert_num):
|
||||
expert_network = DNN(expert_dnn_hidden_units, dnn_activation, l2_reg_dnn, dnn_dropout, dnn_use_bn,
|
||||
seed=seed,
|
||||
name=level_name + 'task_' + task_names[i] + '_expert_specific_' + str(j))(
|
||||
inputs[i])
|
||||
specific_expert_outputs.append(expert_network)
|
||||
|
||||
# build task-shared expert layer
|
||||
shared_expert_outputs = []
|
||||
for k in range(shared_expert_num):
|
||||
expert_network = DNN(expert_dnn_hidden_units, dnn_activation, l2_reg_dnn, dnn_dropout, dnn_use_bn,
|
||||
seed=seed,
|
||||
name=level_name + 'expert_shared_' + str(k))(inputs[-1])
|
||||
shared_expert_outputs.append(expert_network)
|
||||
|
||||
# task_specific gate (count = num_tasks)
|
||||
cgc_outs = []
|
||||
for i in range(num_tasks):
|
||||
# concat task-specific expert and task-shared expert
|
||||
cur_expert_num = specific_expert_num + shared_expert_num
|
||||
# task_specific + task_shared
|
||||
cur_experts = specific_expert_outputs[
|
||||
i * specific_expert_num:(i + 1) * specific_expert_num] + shared_expert_outputs
|
||||
|
||||
expert_concat = tf.keras.layers.Lambda(lambda x: tf.stack(x, axis=1))(cur_experts)
|
||||
|
||||
# build gate layers
|
||||
gate_input = DNN(gate_dnn_hidden_units, dnn_activation, l2_reg_dnn, dnn_dropout, dnn_use_bn,
|
||||
seed=seed,
|
||||
name=level_name + 'gate_specific_' + task_names[i])(
|
||||
inputs[i]) # gate[i] for task input[i]
|
||||
gate_out = tf.keras.layers.Dense(cur_expert_num, use_bias=False, activation='softmax',
|
||||
name=level_name + 'gate_softmax_specific_' + task_names[i])(gate_input)
|
||||
gate_out = tf.keras.layers.Lambda(lambda x: tf.expand_dims(x, axis=-1))(gate_out)
|
||||
|
||||
# gate multiply the expert
|
||||
gate_mul_expert = tf.keras.layers.Lambda(lambda x: reduce_sum(x[0] * x[1], axis=1, keep_dims=False),
|
||||
name=level_name + 'gate_mul_expert_specific_' + task_names[i])(
|
||||
[expert_concat, gate_out])
|
||||
cgc_outs.append(gate_mul_expert)
|
||||
|
||||
# task_shared gate, if the level not in last, add one shared gate
|
||||
if not is_last:
|
||||
cur_expert_num = num_tasks * specific_expert_num + shared_expert_num
|
||||
cur_experts = specific_expert_outputs + shared_expert_outputs # all the expert include task-specific expert and task-shared expert
|
||||
|
||||
expert_concat = tf.keras.layers.Lambda(lambda x: tf.stack(x, axis=1))(cur_experts)
|
||||
|
||||
# build gate layers
|
||||
gate_input = DNN(gate_dnn_hidden_units, dnn_activation, l2_reg_dnn, dnn_dropout, dnn_use_bn,
|
||||
seed=seed,
|
||||
name=level_name + 'gate_shared')(inputs[-1]) # gate for shared task input
|
||||
|
||||
gate_out = tf.keras.layers.Dense(cur_expert_num, use_bias=False, activation='softmax',
|
||||
name=level_name + 'gate_softmax_shared')(gate_input)
|
||||
gate_out = tf.keras.layers.Lambda(lambda x: tf.expand_dims(x, axis=-1))(gate_out)
|
||||
|
||||
# gate multiply the expert
|
||||
gate_mul_expert = tf.keras.layers.Lambda(lambda x: reduce_sum(x[0] * x[1], axis=1, keep_dims=False),
|
||||
name=level_name + 'gate_mul_expert_shared')(
|
||||
[expert_concat, gate_out])
|
||||
|
||||
cgc_outs.append(gate_mul_expert)
|
||||
return cgc_outs
|
||||
|
||||
# build Progressive Layered Extraction
|
||||
ple_inputs = [dnn_input] * (num_tasks + 1) # [task1, task2, ... taskn, shared task]
|
||||
ple_outputs = []
|
||||
for i in range(num_levels):
|
||||
if i == num_levels - 1: # the last level
|
||||
ple_outputs = cgc_net(inputs=ple_inputs, level_name='level_' + str(i) + '_', is_last=True)
|
||||
else:
|
||||
ple_outputs = cgc_net(inputs=ple_inputs, level_name='level_' + str(i) + '_', is_last=False)
|
||||
ple_inputs = ple_outputs
|
||||
|
||||
task_outs = []
|
||||
for task_type, task_name, ple_out in zip(task_types, task_names, ple_outputs):
|
||||
# build tower layer
|
||||
tower_output = DNN(tower_dnn_hidden_units, dnn_activation, l2_reg_dnn, dnn_dropout, dnn_use_bn, seed=seed,
|
||||
name='tower_' + task_name)(ple_out)
|
||||
logit = tf.keras.layers.Dense(1, use_bias=False, activation=None)(tower_output)
|
||||
output = PredictionLayer(task_type, name=task_name)(logit)
|
||||
task_outs.append(output)
|
||||
|
||||
model = tf.keras.models.Model(inputs=inputs_list, outputs=task_outs)
|
||||
return model
|
||||
```
|
||||
|
||||
参考资料
|
||||
|
||||
Progressive Layered Extraction (PLE): A Novel Multi-Task Learning (MTL) Model for Personalized Recommendations (RecSys'2020)
|
||||
|
||||
https://zhuanlan.zhihu.com/p/291406172
|
||||
|
||||
爱奇艺：[https://www.6aiq.com/article/1624916831286](https://www.6aiq.com/article/1624916831286)
|
||||
|
||||
美团：[https://mp.weixin.qq.com/s/WBwvfqOTDKCwGgoaGoSs6Q](https://mp.weixin.qq.com/s/WBwvfqOTDKCwGgoaGoSs6Q)
|
||||
|
||||
多任务loss优化：[https://blog.csdn.net/wuzhongqi](https://blog.csdn.net/wuzhongqi)
|
||||
BIN
2023旧版内容/4.人工智能/code/1-Lecture.zip
Normal file
BIN
2023旧版内容/4.人工智能/code/1-Lecture.zip
Normal file
Binary file not shown.
BIN
2023旧版内容/4.人工智能/code/1-Projects.zip
Normal file
BIN
2023旧版内容/4.人工智能/code/1-Projects.zip
Normal file
Binary file not shown.
BIN
2023旧版内容/4.人工智能/code/2-Lecture.zip
Normal file
BIN
2023旧版内容/4.人工智能/code/2-Lecture.zip
Normal file
Binary file not shown.
BIN
2023旧版内容/4.人工智能/code/2-Projects.zip
Normal file
BIN
2023旧版内容/4.人工智能/code/2-Projects.zip
Normal file
Binary file not shown.
BIN
2023旧版内容/4.人工智能/code/3-Lecture.zip
Normal file
BIN
2023旧版内容/4.人工智能/code/3-Lecture.zip
Normal file
Binary file not shown.
BIN
2023旧版内容/4.人工智能/code/3-Projects.zip
Normal file
BIN
2023旧版内容/4.人工智能/code/3-Projects.zip
Normal file
Binary file not shown.
BIN
2023旧版内容/4.人工智能/code/4-Lecture.zip
Normal file
BIN
2023旧版内容/4.人工智能/code/4-Lecture.zip
Normal file
Binary file not shown.
BIN
2023旧版内容/4.人工智能/code/4-Projects.zip
Normal file
BIN
2023旧版内容/4.人工智能/code/4-Projects.zip
Normal file
Binary file not shown.
BIN
2023旧版内容/4.人工智能/static/4.3-0.jpg
Normal file
BIN
2023旧版内容/4.人工智能/static/4.3-0.jpg
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 26 KiB |
BIN
2023旧版内容/4.人工智能/static/4.3.4-0.png
Normal file
BIN
2023旧版内容/4.人工智能/static/4.3.4-0.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 41 KiB |
BIN
2023旧版内容/4.人工智能/static/4.3.4-1.png
Normal file
BIN
2023旧版内容/4.人工智能/static/4.3.4-1.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 42 KiB |
BIN
2023旧版内容/4.人工智能/static/4.3.4-10.png
Normal file
BIN
2023旧版内容/4.人工智能/static/4.3.4-10.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 186 KiB |
BIN
2023旧版内容/4.人工智能/static/4.3.4-11.png
Normal file
BIN
2023旧版内容/4.人工智能/static/4.3.4-11.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 304 KiB |
BIN
2023旧版内容/4.人工智能/static/4.3.4-12.png
Normal file
BIN
2023旧版内容/4.人工智能/static/4.3.4-12.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 148 KiB |
BIN
2023旧版内容/4.人工智能/static/4.3.4-13.png
Normal file
BIN
2023旧版内容/4.人工智能/static/4.3.4-13.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 183 KiB |
BIN
2023旧版内容/4.人工智能/static/4.3.4-14.png
Normal file
BIN
2023旧版内容/4.人工智能/static/4.3.4-14.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 137 KiB |
BIN
2023旧版内容/4.人工智能/static/4.3.4-2.png
Normal file
BIN
2023旧版内容/4.人工智能/static/4.3.4-2.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 40 KiB |
BIN
2023旧版内容/4.人工智能/static/4.3.4-3.png
Normal file
BIN
2023旧版内容/4.人工智能/static/4.3.4-3.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 27 KiB |
BIN
2023旧版内容/4.人工智能/static/4.3.4-4.png
Normal file
BIN
2023旧版内容/4.人工智能/static/4.3.4-4.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 26 KiB |
BIN
2023旧版内容/4.人工智能/static/4.3.4-5.png
Normal file
BIN
2023旧版内容/4.人工智能/static/4.3.4-5.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 26 KiB |
BIN
2023旧版内容/4.人工智能/static/4.3.4-6.png
Normal file
BIN
2023旧版内容/4.人工智能/static/4.3.4-6.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 86 KiB |
BIN
2023旧版内容/4.人工智能/static/4.3.4-7.png
Normal file
BIN
2023旧版内容/4.人工智能/static/4.3.4-7.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 76 KiB |
BIN
2023旧版内容/4.人工智能/static/4.3.4-8.png
Normal file
BIN
2023旧版内容/4.人工智能/static/4.3.4-8.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 141 KiB |
BIN
2023旧版内容/4.人工智能/static/4.3.4-9.png
Normal file
BIN
2023旧版内容/4.人工智能/static/4.3.4-9.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 127 KiB |
BIN
2023旧版内容/4.人工智能/static/4.3.4.2-0.png
Normal file
BIN
2023旧版内容/4.人工智能/static/4.3.4.2-0.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 57 KiB |
BIN
2023旧版内容/4.人工智能/static/4.3.4.2-1.png
Normal file
BIN
2023旧版内容/4.人工智能/static/4.3.4.2-1.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 4.6 KiB |
BIN
2023旧版内容/4.人工智能/static/4.6.9.3.1.png
Normal file
BIN
2023旧版内容/4.人工智能/static/4.6.9.3.1.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 21 KiB |
BIN
2023旧版内容/4.人工智能/static/4.6.9.3.2.png
Normal file
BIN
2023旧版内容/4.人工智能/static/4.6.9.3.2.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 575 KiB |
BIN
2023旧版内容/4.人工智能/static/4.6.9.3.3.png
Normal file
BIN
2023旧版内容/4.人工智能/static/4.6.9.3.3.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 16 KiB |
BIN
2023旧版内容/4.人工智能/static/A7OubowqYo11O3xn0KbcRoscnEh.png
Normal file
BIN
2023旧版内容/4.人工智能/static/A7OubowqYo11O3xn0KbcRoscnEh.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 385 KiB |
BIN
2023旧版内容/4.人工智能/static/AMU7bSgh4o8tEIxk82icvtbDn0c.png
Normal file
BIN
2023旧版内容/4.人工智能/static/AMU7bSgh4o8tEIxk82icvtbDn0c.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 35 KiB |
BIN
2023旧版内容/4.人工智能/static/AdOVbwCGhoVcWVx21TMcdhbDnIg.png
Normal file
BIN
2023旧版内容/4.人工智能/static/AdOVbwCGhoVcWVx21TMcdhbDnIg.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 30 KiB |
BIN
2023旧版内容/4.人工智能/static/Am3Iwb1ggnyUkB1b9osh.png
Normal file
BIN
2023旧版内容/4.人工智能/static/Am3Iwb1ggnyUkB1b9osh.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 143 KiB |
BIN
2023旧版内容/4.人工智能/static/AptYbb5MZoylvex7LvPcSqivnef.png
Normal file
BIN
2023旧版内容/4.人工智能/static/AptYbb5MZoylvex7LvPcSqivnef.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 124 KiB |
BIN
2023旧版内容/4.人工智能/static/BKZPbpDrIo95amxDZANccwHZnpd.png
Normal file
BIN
2023旧版内容/4.人工智能/static/BKZPbpDrIo95amxDZANccwHZnpd.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 826 KiB |
BIN
2023旧版内容/4.人工智能/static/BbIiba1pwo3uI7x4k7QcwicznGc.png
Normal file
BIN
2023旧版内容/4.人工智能/static/BbIiba1pwo3uI7x4k7QcwicznGc.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 50 KiB |
BIN
2023旧版内容/4.人工智能/static/BcfWbqCNKoXpTHxPQVqczsvcnBd.png
Normal file
BIN
2023旧版内容/4.人工智能/static/BcfWbqCNKoXpTHxPQVqczsvcnBd.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 9.8 KiB |
BIN
2023旧版内容/4.人工智能/static/ByeFbxTfToxFlgxh6xmcIKeRnzd.png
Normal file
BIN
2023旧版内容/4.人工智能/static/ByeFbxTfToxFlgxh6xmcIKeRnzd.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 38 KiB |
BIN
2023旧版内容/4.人工智能/static/CQmGb6QTjoeyVCx9vjncYF2QnQe.png
Normal file
BIN
2023旧版内容/4.人工智能/static/CQmGb6QTjoeyVCx9vjncYF2QnQe.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 58 KiB |
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user