diff --git a/.vitepress/config.js b/.vitepress/config.js
index 140610e..7572a1b 100644
--- a/.vitepress/config.js
+++ b/.vitepress/config.js
@@ -394,7 +394,7 @@ export default defineConfig({
{ text: '4.6.6.2.3序列化推荐', link: '/4.人工智能/4.6.6.2.3序列化推荐' },
]
},
- { text: '4.6.6.3知识图谱', link: '/4.人工智能/4.6.6.3知识图谱' }
+ { text: '4.6.6.3知识图谱', link: '/4.人工智能/4.6.6.3知识图谱' },
]
},
{
@@ -441,6 +441,114 @@ export default defineConfig({
{ text: '4.10科研论文写作', link: '/4.人工智能/4.10科研论文写作' },
{ text: '4.11从 AI 到 智能系统 —— 从 LLMs 到 Agents', link: '/4.人工智能/4.11从 AI 到 智能系统 —— 从 LLMs 到 Agents' },
{ text: '4.12本章节内容的局限性', link: '/4.人工智能/4.12本章节内容的局限性' },
+ {
+ text: 'FunRec',
+ collapsed: true,
+ items: [
+ { text: 'FunRec概述', link: '/4.人工智能/FunRec概述' },
+ {
+ text: '推荐系统概述',
+ collapsed: true,
+ items: [
+ { text: '推荐系统的意义', link: '/4.人工智能/ch01/ch1.1.md' },
+ { text: '推荐系统架构', link: '/4.人工智能/ch01/ch1.2.md' },
+ { text: '推荐系统技术栈', link: '/4.人工智能/ch01/ch1.3.md' },
+ ]
+ },
+ {
+ text: '推荐系统算法基础',
+ collapsed: true,
+ items: [
+ {
+ text: '经典召回模型',
+ collapsed: true,
+ items: [
+ {
+ text: '基于协同过滤的召回', collapsed: true, items: [
+ { text: 'UserCF', link: '/4.人工智能/ch02/ch2.1/ch2.1.1/usercf.md' },
+ { text: 'ItemCF', link: '/4.人工智能/ch02/ch2.1/ch2.1.1/itemcf.md' },
+ { text: 'Swing', link: '/4.人工智能/ch02/ch2.1/ch2.1.1/Swing.md' },
+ { text: '矩阵分解', link: '/4.人工智能/ch02/ch2.1/ch2.1.1/mf.md' },
+ ]
+ },
+ { text: 'FM召回', link: '/4.人工智能/ch02/ch2.1/ch2.1.2/FM.md' },
+ {
+ text: 'item2vec召回系列', collapsed: true, items: [
+ { text: 'word2vec原理', link: '/4.人工智能/ch02/ch2.1/ch2.1.2/word2vec.md' },
+ { text: 'item2vec召回', link: '/4.人工智能/ch02/ch2.1/ch2.1.2/item2vec.md' },
+ { text: 'Airbnb召回', link: '/4.人工智能/ch02/ch2.1/ch2.1.2/Airbnb.md' },
+ ]
+ },
+ { text: 'YoutubeDNN召回', link: '/4.人工智能/ch02/ch2.1/ch2.1.2/YoutubeDNN.md' },
+ {
+ text: '双塔召回', collapsed: true, items: [
+ { text: '经典双塔', link: '/4.人工智能/ch02/ch2.1/ch2.1.2/DSSM.md' },
+ { text: 'Youtube双塔', link: '/4.人工智能/ch02/ch2.1/ch2.1.2/YoutubeTwoTower.md' },
+ ]
+ },
+ {
+ text: '图召回', collapsed: true, items: [
+ { text: 'EGES', link: '/4.人工智能/ch02/ch2.1/ch2.1.3/EGES.md' },
+ { text: 'PinSAGE', link: '/4.人工智能/ch02/ch2.1/ch2.1.3/PinSage.md' },
+ ]
+ },
+ {
+ text: '序列召回', collapsed: true, items: [
+ { text: 'MIND', link: '/4.人工智能/ch02/ch2.1/ch2.1.4/MIND.md' },
+ { text: 'SDM', link: '/4.人工智能/ch02/ch2.1/ch2.1.4/SDM.md' },
+ ]
+ },
+ {
+ text: '树模型召回', collapsed: true, items: [
+ { text: 'TDM', link: '/4.人工智能/ch02/ch2.1/ch2.1.5/TDM.md' },
+ ]
+ }
+ ]
+ },
+ {
+ text: '经典排序模型',
+ collapsed: true,
+ items: [
+ { text: 'GBDT+LR', link: '/4.人工智能/ch02/ch2.2/ch2.2.1.md' },
+ {
+ text: '特征交叉', collapsed: true, items: [
+ { text: 'FM', link: '/4.人工智能/ch02/ch2.2/ch2.2.2/FM.md' },
+ { text: 'PNN', link: '/4.人工智能/ch02/ch2.2/ch2.2.2/PNN.md' },
+ { text: 'DCN', link: '/4.人工智能/ch02/ch2.2/ch2.2.2/DCN.md' },
+ { text: 'AutoInt', link: '/4.人工智能/ch02/ch2.2/ch2.2.2/AutoInt.md' },
+ { text: 'FiBiNET', link: '/4.人工智能/ch02/ch2.2/ch2.2.2/FiBiNet.md' },
+ ]
+ },
+ {
+ text: 'WideNDeep系列', collapsed: true, items: [
+ { text: 'Wide&Deep', link: '/4.人工智能/ch02/ch2.2/ch2.2.3/WideNDeep.md' },
+ { text: 'NFM', link: '/4.人工智能/ch02/ch2.2/ch2.2.3/NFM.md' },
+ { text: 'AFM', link: '/4.人工智能/ch02/ch2.2/ch2.2.3/AFM.md' },
+ { text: 'DeepFM', link: '/4.人工智能/ch02/ch2.2/ch2.2.3/DeepFM.md' },
+ { text: 'xDeepFM', link: '/4.人工智能/ch02/ch2.2/ch2.2.3/xDeepFM.md' },
+ ]
+ },
+ {
+ text: '序列模型', collapsed: true, items: [
+ { text: 'DIN', link: '/4.人工智能/ch02/ch2.2/ch2.2.4/DIN.md' },
+ { text: 'DIEN', link: '/4.人工智能/ch02/ch2.2/ch2.2.4/DIEN.md' },
+ { text: 'DSIN', link: '/4.人工智能/ch02/ch2.2/ch2.2.4/DSIN.md' },
+ ]
+ },
+ {
+ text: '多任务学习', collapsed: true, items: [
+ { text: '多任务学习概述', link: '/4.人工智能/ch02/ch2.2/ch2.2.5/2.2.5.0.md' },
+ { text: 'ESMM', link: '/4.人工智能/ch02/ch2.2/ch2.2.5/ESMM.md' },
+ { text: 'MMOE', link: '/4.人工智能/ch02/ch2.2/ch2.2.5/MMOE.md' },
+ { text: 'PLE', link: '/4.人工智能/ch02/ch2.2/ch2.2.5/PLE.md' },
+ ]
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ }
]
},
{
diff --git a/4.人工智能/FunRec概述.md b/4.人工智能/FunRec概述.md
new file mode 100644
index 0000000..52819b2
--- /dev/null
+++ b/4.人工智能/FunRec概述.md
@@ -0,0 +1,16 @@
+# FunRec概述
+
+本教程主要是针对具有机器学习基础并想找推荐算法岗位的同学。教程内容由推荐系统概述、推荐算法基础、推荐系统实战和推荐系统面经四个部分组成。本教程对于入门推荐算法的同学来说，可以从推荐算法的基础到实战再到面试，形成一个闭环。每个部分的详细内容如下：
+
+- **推荐系统概述。** 这部分内容会从推荐系统的意义及应用，到架构及相关的技术栈做一个概述性的总结，目的是为了让初学者更加了解推荐系统。
+- **推荐系统算法基础。** 这部分会介绍推荐系统中对于算法工程师来说基础并且重要的相关算法，如经典的召回、排序算法。随着项目的迭代，后续还会不断的总结其他的关键算法和技术，如重排、冷启动等。
+- **推荐系统实战。** 这部分内容包含推荐系统竞赛实战和新闻推荐系统的实践。其中推荐系统竞赛实战是结合阿里天池上的新闻推荐入门赛做的相关内容。新闻推荐系统实践是实现一个具有前后端交互及整个推荐链路的项目，该项目是一个新闻推荐系统的demo没有实际的商业化价值。
+- **推荐系统算法面经。** 这里会将推荐算法工程师面试过程中常考的一些基础知识、热门技术等面经进行整理，方便同学在有了一定推荐算法基础之后去面试，因为对于初学者来说只有在公司实习学到的东西才是最有价值的。
+
+**特别说明**：项目内容是由一群热爱分享的同学一起花时间整理而成，**大家的水平都非常有限，内容难免存在一些错误和问题，如果学习者发现问题，也欢迎及时反馈，避免让后学者踩坑！** 如果对该项目有改进或者优化的建议，还希望通过下面的二维码找到项目负责人或者在交流社区中提出，我们会参考大家的意见进一步对该项目进行修改和调整！如果想对该项目做一些贡献，也可以通过上述同样的方法找到我们！
+
+为了方便学习和交流，**我们建立了FunRec学习社区（微信群+知识星球）**，微信群方便大家平时日常交流和讨论，知识星球方便沉淀内容。由于我们的内容面向的人群主要是学生，所以**知识星球永久免费**，感兴趣的可以加入星球讨论（加入星球的同学先看置定的必读帖）！**FunRec学习社区内部会不定期分享(FunRec社区中爱分享的同学)技术总结、个人管理等内容，[跟技术相关的分享内容都放在了B站](https://space.bilibili.com/431850986/channel/collectiondetail?sid=339597)上面**。由于微信群的二维码只有7天内有效，所以直接加下面这个微信，备注：**Fun-Rec**，会被拉到Fun-Rec交流群，如果觉得微信群比较吵建议直接加知识星球！。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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)
+ ```
+
+ ```
+ 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}')
+ ```
+
+ ```
+ 与物品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}')
+ ```
+
+ ```
+ 用户 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)
+* [协同过滤算法概述：https://chenk.tech/posts/8ad63d9d.html](https://chenk.tech/posts/8ad63d9d.html)
+* B站黑马推荐系统实战课程
+
+
+
+
+
diff --git a/4.人工智能/ch02/ch2.1/ch2.1.1/mf.md b/4.人工智能/ch02/ch2.1/ch2.1.1/mf.md
new file mode 100644
index 0000000..7065d45
--- /dev/null
+++ b/4.人工智能/ch02/ch2.1/ch2.1.1/mf.md
@@ -0,0 +1,370 @@
+# 隐语义模型与矩阵分解
+
+协同过滤算法的特点：
+
++ 协同过滤算法的特点就是完全没有利用到物品本身或者是用户自身的属性， 仅仅利用了用户与物品的交互信息就可以实现推荐，是一个可解释性很强， 非常直观的模型。
++ 但是也存在一些问题，处理稀疏矩阵的能力比较弱。
+
+为了使得协同过滤更好处理稀疏矩阵问题， 增强泛化能力。从协同过滤中衍生出矩阵分解模型(Matrix Factorization, MF)或者叫隐语义模型：
+
++ 在协同过滤共现矩阵的基础上， 使用更稠密的隐向量表示用户和物品。
++ 通过挖掘用户和物品的隐含兴趣和隐含特征， 在一定程度上弥补协同过滤模型处理稀疏矩阵能力不足的问题。
+
+
+
+# 隐语义模型
+
+隐语义模型最早在文本领域被提出，用于找到文本的隐含语义。在2006年， 被用于推荐中， 它的核心思想是通过隐含特征（latent factor）联系用户兴趣和物品（item）， 基于用户的行为找出潜在的主题和分类， 然后对物品进行自动聚类，划分到不同类别/主题(用户的兴趣)。
+
+以项亮老师《推荐系统实践》书中的内容为例：
+
+>如果我们知道了用户A和用户B两个用户在豆瓣的读书列表， 从他们的阅读列表可以看出，用户A的兴趣涉及侦探小说、科普图书以及一些计算机技术书， 而用户B的兴趣比较集中在数学和机器学习方面。 那么如何给A和B推荐图书呢？ 先说说协同过滤算法， 这样好对比不同：
+>* 对于UserCF，首先需要找到和他们看了同样书的其他用户（兴趣相似的用户），然后给他们推荐那些用户喜欢的其他书。
+>* 对于ItemCF，需要给他们推荐和他们已经看的书相似的书，比如作者B看了很多关于数据挖掘的书，可以给他推荐机器学习或者模式识别方面的书。
+>
+>而如果是隐语义模型的话， 它会先通过一些角度把用户兴趣和这些书归一下类， 当来了用户之后， 首先得到他的兴趣分类， 然后从这个分类中挑选他可能喜欢的书籍。
+
+隐语义模型和协同过滤的不同主要体现在隐含特征上， 比如书籍的话它的内容， 作者， 年份， 主题等都可以算隐含特征。
+
+以王喆老师《深度学习推荐系统》中的一个原理图为例，看看是如何通过隐含特征来划分开用户兴趣和物品的。
+
+
+
+## 音乐评分实例
+
+假设每个用户都有自己的听歌偏好， 比如用户 A 喜欢带有**小清新的**， **吉他伴奏的**， **王菲**的歌曲，如果一首歌正好**是王菲唱的， 并且是吉他伴奏的小清新**， 那么就可以将这首歌推荐给这个用户。 也就是说是**小清新， 吉他伴奏， 王菲**这些元素连接起了用户和歌曲。
+
+当然每个用户对不同的元素偏好不同， 每首歌包含的元素也不一样， 所以我们就希望找到下面的两个矩阵：
+
+1. 潜在因子—— 用户矩阵Q
+ 这个矩阵表示不同用户对于不同元素的偏好程度， 1代表很喜欢， 0代表不喜欢， 比如下面这样：
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+## 计算过程
+
+以下图为例，给用户推荐物品的过程可以形象化为一个猜测用户对物品进行打分的任务，表格里面是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。
+
+ 
+
+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)
+ ```
+
+ ```
+ 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}')
+ ```
+
+ ```
+ 与用户 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}')
+ ```
+
+ ```
+ 用户 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)
+* [协同过滤算法概述：https://chenk.tech/posts/8ad63d9d.html](https://chenk.tech/posts/8ad63d9d.html)
+* B站黑马推荐系统实战课程
diff --git a/4.人工智能/ch02/ch2.1/ch2.1.2/Airbnb.md b/4.人工智能/ch02/ch2.1/ch2.1.2/Airbnb.md
new file mode 100644
index 0000000..65ce7bc
--- /dev/null
+++ b/4.人工智能/ch02/ch2.1/ch2.1.2/Airbnb.md
@@ -0,0 +1,332 @@
+# 前言
+这是 Airbnb 于2018年发表的一篇论文，主要介绍了 Airbnb 在 Embedding 技术上的应用，并获得了 KDD 2018 的 Best Paper。Airbnb 是全球最大的短租平台，包含了数百万种不同的房源。这篇论文介绍了 Airbnb 如何使用 Embedding 来实现相似房源推荐以及实时个性化搜索。在本文中，Airbnb 在用户和房源的 Embedding 上的生成都是基于谷歌的 Word2Vec 模型，故阅读本文要求大家了解 Word2Vec 模型，特别是 Skip-Gram 模型**（重点*）**。
+本文将从以下几个方面来介绍该论文：
+
+- 了解 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 技术团队通过复杂的机器学习模型，并使用上百种信号对搜索结果中的房源进行排序。
+- 当用户在查看某一个房源时，接下来的有两种方式继续搜索：
+ - 返回搜索结果页，继续查看其他搜索结果。
+
+
+
+ - 在当前房源的详情页下，「相似房源」板块（你可能还喜欢）所推荐的房源。
+
+
+
+- Airbnb 平台 99% 的房源预订来自于搜索排序和相似房源推荐。
+# Embedding 方法
+Airbnb 描述了两种 Embedding 的构建方法，分别为：
+
+- 用于描述短期实时性的个性化特征 Embedding：**listing Embeddings**
+ - **listing 表示房源的意思，它将贯穿全文，请务必了解。**
+- 用于描述长期的个性化特征 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。
+
+
+
+ - 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个集群，来验证类似位置的房源是否聚集在一起。
+
+
+
+- 评估不同类型、价格区间的房源之间的相似性。
+ - 简而言之，我们希望类型相同、价格区间一致的房源它们之间的相似度更高。
+
+
+
+- 评估房源的隐式特征
+ - Airbnb 在训练房源（listing）的 Embedding时，并没有用到房源的图像信息。
+ - 对于一些隐式信息，例如架构、风格、观感等是无法直接学习。
+ - 为了验证基于 Word2Vec 学习到的 Embedding是否隐含了它们在外观等隐式信息上的相似性，Airbnb 内部开发了一款内部相似性探索工具。
+ - 大致原理就是，利用训练好的 Embedding 进行 K 近邻相似度检索。
+ - 如下，与查询房源在 Embedding 相似性高的其他房源，它们之间的外观风格也很相似。
+
+
+
+## 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行，因为预定之前没有历史预定相关的信息。
+
+
+
+看到过前面那个简单的例子后，现在可以看一个原文的 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}
+ $$
+
+
+
+# 实验部分
+
+前面介绍了两种 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种类型的特征计算方式相同。
+
+
+
+**① 基于 Listing Embedding Features 的特征构建**
+
+- Airbnb 保留了用户过去两周6种不同类型的历史行为，如下图：
+
+
+
+- 对于每个行为，还要将其按照 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 还做了特征重要性排序，如下表：
+
+
+
+**（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)
diff --git a/4.人工智能/ch02/ch2.1/ch2.1.2/DSSM.md b/4.人工智能/ch02/ch2.1/ch2.1.2/DSSM.md
new file mode 100644
index 0000000..8c94c46
--- /dev/null
+++ b/4.人工智能/ch02/ch2.1/ch2.1.2/DSSM.md
@@ -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，可以预测两句话的语义相似度。模型结构如下所示：
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
召回侧， 目前根据我的理解，大致上有两大类召回方式，一类是策略规则，一类是监督模型+embedding，其中策略规则，往往和真实场景有关，比如热度，历史重定向等等，不同的场景会有不同的召回方式，这种属于"特异性"知识。
+
后面的模型+embedding思路是一种"普适"方法，我上面图里面梳理出了目前给用户和物品打embedding的主流方法， 这些方法大致成几个系列，比如FM系列(FM,FFM等)， 用户行为序列，基于图和知识图谱系列，经典双塔系列等，这些方法看似很多很复杂，其实本质上还是给用户或者是物品打embedding而已，只不过考虑的角度方式不同。 这里的YouTubeDNN召回模型，也是这里的一种方式而已。
+2. 精排侧
+
+
+
+ 精排侧，这一块的大致发展趋势，从ctr预估到多目标， 而模型演化上，从人工特征工程到特征工程自动化。主要是三大块， CTR预估主要分为了传统的LR，FM大家族，以及后面自动特征交叉的DNN家族，而多目标优化，目前是很多大公司的研究现状，更是未来的一大发展趋势，如何能让模型在各个目标上面的学习都能"游刃有余"是一件非常具有挑战的事情，毕竟不同的目标可能会互相冲突，互相影响，所以这里的研究热点又可以拆分成网络结构演化以及loss设计优化等， 而网络结构演化中，又可以再一次细分。 当然这每个模型或者技术几乎都有对应paper，我们依然可以通过读paper的方式，把这些关键技术学习到。
+
+这两阶段的方法， 就能保证我们从大规模视频库中实时推荐， 又能保证个性化，吸引用户。 当然，随着时间的发展， 可能数据量非常非常大了， 此时召回结果规模精排依然无法处理，所以现在一般还会在召回和精排之间，加一个粗排进一步筛选作为过渡， 而随着场景越来越复杂， 精排产生的结果也不是直接给到用户，而是会再后面加一个重排后处理下，这篇paper里面其实也简单的提了下这种思想，在排序那块会整理到。 所以如今的漏斗， 也变得长了些。
+
+
+
+
+
除了这种算好embedding方式之外，还可以过embedding层，跟上面的DNN一起训练，这些都是常规操作，之前整理的精排模型里面大都是用这种方式。
+
+ 论文里面使用了用户最近的50次观看历史，用户最近50次搜索历史token， embedding维度是256维， 采用的average pooling。 当然，这里还可以把item的类别信息也隐射到embedding， 与前面的concat起来。
+* 用户人文特征， 这种特征处理方式就是离散型的依然是labelEncoder，然后embedding转成低维稠密， 而连续型特征，一般是先归一化操作，然后直接输入，当然有的也通过分桶，转成离散特征，这里不过多整理，特征工程做的事情了。 当然，这里还有一波操作值得注意，就是连续型特征除了用了$x$本身，还用了$x^2$，$logx$这种， 可以加入更多非线性，增加模型表达能力。
+ 这些特征对新用户的推荐会比较有帮助，常见的用户的地理位置， 设备， 性别，年龄等。
+* 这里一个比较特色的特征是example age，这个特征后面需要单独整理。
+
+这些特征处理好了之后，拼接起来，就成了一个非常长的向量，然后就是过DNN，这里用了一个三层的DNN， 得到了输出， 这个输出也是向量。
+
+Ok，到这里平淡无奇， 前向传播也大致上快说完了， 还差最后一步。 最后这一步，就是做多分类问题，然后求损失，这就是training那边做的事情。 但是在详细说这个之前， 我想先简单回忆下word2vec里面的skip-gram Model， 这个模型，如果回忆起来，这里理解起来就非常的简单了。
+
+这里只需要看一张图即可， 这个来自cs231N公开课PPT， 我之前整理w2v的时候用到的，详细内容可看我[这篇博客](https://zhongqiang.blog.csdn.net/article/details/106948860)， 这里的思想其实也是从w2v那边过来的。
+
+
+
+
然后就是$v_c$和上下文矩阵$W'$相乘， 这里的$W'$是$V\times d$的一个矩阵， 每一行代表每个单词作为上下文的时候的词向量表示， 也就是$u_w$， 每一列是词嵌入的维度。 这样通过$W'*v_c$就会得到一个$V\times 1$的向量，这个表示的就是中心单词$w_t$与每个单词的相似程度。
+>
最后，我们通过softmax操作把这个相似程度转成概率， 选择概率最大的index输出。
+
+这就是这个模型的前向传播过程。
+
+有了这个过程， 再理解YouTubeDNN顶部就非常容易了， 我单独截出来:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
那么这样的操作为啥会work呢？ example age这个我理解，是有了这个特征， 就可以把某视频的热度分布信息传递给模型了， 比如某个example age时间段该视频播放较多， 而另外的时间段播放较少， 这样模型就能发现用户的这种新颖偏好， 消除热度偏见。
这个地方看了一些文章写说， 这样做有利于让模型推新热内容， 总感觉不是很通。 我这里理解是类似让模型消除位置偏见那样， 这里消除一种热度偏见。
我理解是这样，假设没有这样一个example age特征表示视频新颖信息，或者一个位置特征表示商品的位置信息，那模型训练的样本，可能是用户点击了这个item，就是正样本， 但此时有可能是用户真的喜欢这个item， 也有可能是因为一些bias， 比如用户本身喜欢新颖， 用户本身喜欢点击上面位置的item等， 但模型推理的时候，都会误认为是用户真的喜欢这个item。 所以，为了让模型了解到可能是存在后面这种bias， 我们就把item的新颖信息， item的位置信息等做成特征， 在模型训练的时候就告诉模型，用户点了这个东西可能是它比较新或者位置比较靠上面等，这样模型在训练的时候， 就了解到了这些bias，等到模型在线推理的时候呢， 我们把这些bias特征都弄成一样的，这样每个样品在模型看来，就没有了新颖信息和位置信息bias(一视同仁了)，只能靠着相关性去推理， 这样才能推到用户真正感兴趣的东西吧。
而有些文章记录的， 能够推荐更热门的视频啥的， 我很大一个疑问就是推理的时候，不是把example age用0表示吗？ 模型应该不知道这些视频哪个新不新吧。 当然，这是我自己的看法，感兴趣的可以帮我解答下呀。
+
+`example age`这个特征到这里还没完， 原来加入这种时间bias的传统方法是使用`video age`， 即一个video上传到样本生成的这段时间跨度， 这么说可能有些懵， 看个图吧， 原来这是两个东西:
+
+
+
+
+
+
+
+
我这里面加入的一些策略，负样本候选集生成我单独写成一个函数，因为尝试了随机采样和打压热门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做召回的整个流程。 效果如下:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
这个空档利用，一定要提前在todo里面写好，而不是跑模型的时候再想，这个时候往往啥也干不下去，并且还会时不时的看模型跑，或者盯着进度条发呆，那这段时间就有些浪费了呀，即使这段时间不学习，看个久违的电视剧， 久违的书，或者keep下不香吗哈哈， 但得提前规划。
可能每个人习惯不一样，对于我，是这样哈，所以记录下 ;)
+
+## 总结
+
+由于这篇文章里面的工程经验太多啦，我前面介绍的时候，可能涉及到知识的一些扩展补充，把经验整理的比较凌乱，这里再统一整理下， 这些也都是工业界常用的一些经验了:
+
+召回部分:
+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/)
diff --git a/4.人工智能/ch02/ch2.1/ch2.1.2/YoutubeTwoTower.md b/4.人工智能/ch02/ch2.1/ch2.1.2/YoutubeTwoTower.md
new file mode 100644
index 0000000..4bdabd9
--- /dev/null
+++ b/4.人工智能/ch02/ch2.1/ch2.1.2/YoutubeTwoTower.md
@@ -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$ 子集用于后续排序推荐任务。
+
+
+
+## 模型目标
+
+模型结构如上图所示，论文旨在对用户和物品建立两个不同的模型，将它们投影到相同维度的空间：
+$$
+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 方法更新参数。
+
+
+
+## 流频估计算法
+
+考虑一个随机的数据 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)]
+ $$
+
+
+
+
+**从数学理论上证明这种迭代更新的有效性：**
+
+假设物品 $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\}
+$$
+
+
+
+
+
+# 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)
diff --git a/4.人工智能/ch02/ch2.1/ch2.1.2/item2vec.md b/4.人工智能/ch02/ch2.1/ch2.1.2/item2vec.md
new file mode 100644
index 0000000..472b8e6
--- /dev/null
+++ b/4.人工智能/ch02/ch2.1/ch2.1.2/item2vec.md
@@ -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)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/4.人工智能/ch02/ch2.1/ch2.1.2/word2vec.md b/4.人工智能/ch02/ch2.1/ch2.1.2/word2vec.md
new file mode 100644
index 0000000..2ed19ec
--- /dev/null
+++ b/4.人工智能/ch02/ch2.1/ch2.1.2/word2vec.md
@@ -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，如下图，那么通过点积等数学计算就可以获得单词之间的某种联系
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+**下面分析一下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点击率预估，即预测当给用户推送的广告会不会被用户点击。
+
+有了上面的铺垫， 这个模型解释起来就比较容易了， 模型的总体结构长下面这样：
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+可以看到， 每一层增加了一个$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$的权重为$$。在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中。
+
+ 
+
+
+## 思考
+
+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)
+
diff --git a/4.人工智能/ch02/ch2.2/ch2.2.2/FM.md b/4.人工智能/ch02/ch2.2/ch2.2.2/FM.md
new file mode 100644
index 0000000..44a713f
--- /dev/null
+++ b/4.人工智能/ch02/ch2.2/ch2.2.2/FM.md
@@ -0,0 +1,147 @@
+### FM模型的引入
+
+#### 逻辑回归模型及其缺点
+
+FM模型其实是一种思路，具体的应用稍少。一般来说做推荐CTR预估时最简单的思路就是将特征做线性组合（逻辑回归LR），传入sigmoid中得到一个概率值，本质上这就是一个线性模型，因为sigmoid是单调增函数不会改变里面的线性模型的CTR预测顺序，因此逻辑回归模型效果会比较差。也就是LR的缺点有：
+
+* 是一个线性模型
+* 每个特征对最终输出结果独立，需要手动特征交叉（$x_i*x_j$），比较麻烦
+
+
+
+#### 二阶交叉项的考虑及改进
+
+由于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！
+
+
+
+### 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}{x_{i}x_{j}}}
+$$
+
+需要估计的参数有$\omega_{0}∈ R$，$\omega_{i}∈ R$，$V∈ R$，$< \cdot, \cdot>$是长度为$k$的两个向量的点乘，公式如下：
+
+$$
+ = \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<x_ix_j}}
+&= \frac{1}{2}\sum_{i=1}^{n}{\sum_{j=1}^{n}{x_ix_j}} - \frac{1}{2} {\sum_{i=1}^{n}{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$ 相当于是一样的，表示成平方过程。
+
+
+
+### 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](https://www.csie.ntu.edu.tw/~b97053/paper/Rendle2010FM.pdf))
+* [AI上推荐 之 FM和FFM](https://blog.csdn.net/wuzhongqiang/article/details/108719417)
\ No newline at end of file
diff --git a/4.人工智能/ch02/ch2.2/ch2.2.2/FiBiNet.md b/4.人工智能/ch02/ch2.2/ch2.2.2/FiBiNet.md
new file mode 100644
index 0000000..f4552be
--- /dev/null
+++ b/4.人工智能/ch02/ch2.2/ch2.2.2/FiBiNet.md
@@ -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模型的理论以及论文细节
+这里我们直接分析模型架构即可， 因为这个模型不是很复杂，也非常好理解前向传播的过程：
+
+
+
+
+>首先，我们输入的特征有离散和连续，对于连续的特征，输入完了之后，先不用管，等待后面拼起来进DNN即可，这里也没有刻意处理连续特征。
+>
对于离散特征，过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)`矩阵。 结构如下：
+
+
+
+
+>推荐领域里面的特征有个特点，就是海量稀疏，意思是大量长尾特征是低频的，而这些低频特征，去学一个靠谱的Embedding是基本没希望的，但是你又不能把低频的特征全抛掉，因为有一些又是有效的。既然这样，**如果我们把SENet用在特征Embedding上，类似于做了个对特征的Attention，弱化那些不靠谱低频特征Embedding的负面影响，强化靠谱低频特征以及重要中高频特征的作用，从道理上是讲得通的**
+
+所以拿来用了再说， 把SENet放在Embedding层之上，通过SENet网络，动态地学习这些特征的重要性。**对于每个特征学会一个特征权重，然后再把学习到的权重乘到对应特征的Embedding里，这样就可以动态学习特征权重，通过小权重抑制噪音或者无效低频特征，通过大权重放大重要特征影响的目的**。在推荐系统里面， 结构长这个样子：
+
+
+
+
这样，经过两层MLP映射，就会产生$f$个权重数值，第$i$个数值对应第$i$个特征Embedding的权重$a_i$ 。
这个东西有没有感觉和自动编码器很像，虽然不是一样的作用， 但网络结构是一样的。这就是知识串联的功效哈哈。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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) =
+$$
+将内积的表达式带入$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}
+
+\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} 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 \\
+ &= \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中。
+
+ 
+
+
+## 思考题
+
+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)
\ No newline at end of file
diff --git a/4.人工智能/ch02/ch2.2/ch2.2.3/AFM.md b/4.人工智能/ch02/ch2.2/ch2.2.3/AFM.md
new file mode 100644
index 0000000..8216485
--- /dev/null
+++ b/4.人工智能/ch02/ch2.2/ch2.2.3/AFM.md
@@ -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模型原理
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
初始输入$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的好处啥的都分析完了， 下面得分析点不好的地方了，否则就没法引出这次的主角了。作者直接说：
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
再看DNN，第一层是$m\times D\times H_1$， 中间层$H_k\times H_{k-1}$，T-1层，这是一个$O(mDH+TH^2)$的空间复杂度，并且参数量会随着$D$的增加而增加。
所以空间上来说，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)$
对于普通的DNN，花费时间$O(mHD+H^2T)$
**所以时间复杂度会是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. 推荐系统中，是否需要显性和隐性的高阶特征交互都存在?
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
展示的广告通过软搜索这位年轻母亲的历史行为，发现她最近曾浏览过类似的商品，如大手提袋和皮包，从而击中了她的相关兴趣
+
+第二个思路就是DIN的改进之处了。DIN通过给定一个候选广告，然后去注意与该广告相关的局部兴趣的表示来模拟此过程。 DIN不会通过使用同一向量来表达所有用户的不同兴趣，而是通过考虑历史行为的相关性来自适应地计算用户兴趣的表示向量（对于给的广告）。 该表示向量随不同广告而变化。下面看一下DIN模型。
+
+### DIN模型架构
+
+上面分析完了base模型的不足和改进思路之后，DIN模型的结构就呼之欲出了，首先，它依然是采用了基模型的结构，只不过是在这个的基础上加了一个注意力机制来学习用户兴趣与当前候选广告间的关联程度， 用论文里面的话是，引入了一个新的`local activation unit`， 这个东西用在了用户历史行为特征上面， **能够根据用户历史行为特征和当前广告的相关性给用户历史行为特征embedding进行加权**。我们先看一下它的结构，然后看一下这个加权公式。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+>我们看看这个$QK^T$在表示啥意思：
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
ESSM是一种较为通用的任务序列依赖关系建模的方法，除此之外，阿里的DBMTL，ESSM2等工作都属于这一个范式。 这个范式可能后面会进行整理，本篇文章不过多赘述。
+
+通过上面的描述，能大体上对多任务模型方面的几种常用建模范式有了解，然后也知道了hard parameter sharing存在的一些问题，即不能很好的权衡特定任务的目标与任务之间的冲突关系。而这也就是MMOE模型提出的一个动机所在了， 那么下面的关键就是MMOE模型是怎么建模任务之间的关系的，又是怎么能使得特定任务与任务关系保持平衡的？
+
+带着这两个问题，下面看下MMOE的细节。
+
+## MMOE模型的理论及论文细节
+MMOE模型结构图如下。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+