Celyn's Blog

常用软件和项目

Fri, 09 Oct 2026 00:00:00 GMT

记录常用的软件与工具，按用途分类，持续补充。

下载与传输#

1. Free Download Manager：下载加速与管理#

Free Download Manager Windows 软件界面截图

Free Download Manager（FDM）是一款免费的下载管理器，支持 Windows、macOS、Android 和 Linux。它可以把文件分成多个片段并行下载，支持断点续传，也内置 BitTorrent 和磁力链接下载功能。

它还提供浏览器集成，适合集中管理日常下载任务，尤其是较大的文件、视频和种子任务。软件官网提供无广告、无恶意软件的版本；安装时仍建议从官方网站下载，并留意下载来源与文件类型。截图来自 FDM 官网的 Windows 界面。

图像与视频#

1. Upscayl：图像超分辨率#

GitHub：Upscayl

Upscayl 软件界面截图

Upscayl 是一款免费、开源的 AI 图像超分辨率工具，用于放大低分辨率图片并增强画面细节，支持 Windows、macOS 和 Linux。

适合需要提高图片分辨率时使用。运行需要兼容 Vulkan 的显卡，部分集成显卡可能无法使用，使用前应确认设备兼容性。

2. video-parser：视频解析与下载#

GitHub：video-parser

video-parser 视频解析下载器界面

这是一个基于 FastAPI、Gradio 和 Qwen3-VL 的视频解析、下载与 AI 内容提取工具。项目提供抖音、哔哩哔哩、小红书、快手、好看视频等平台的视频链接解析、下载及在线播放功能，还可借助视觉语言模型提取视频内容并生成文字描述。

界面支持输入视频链接、选择或自动检测平台，并展示解析状态、视频标题和封面。具体解析效果可能受平台接口变化影响；下载和使用视频时应尊重版权与平台规则，仅处理自己有权使用的内容。

3. OpenScreen：屏幕录制与演示视频制作#

GitHub：OpenScreen

OpenScreen 演示视频编辑界面

OpenScreen 是一款免费、开源的屏幕录制与演示视频制作工具，适合制作产品演示和操作教程。可以录制窗口或整个屏幕，再通过画面缩放、光标效果、自定义背景和时间轴剪辑整理录屏，导出 MP4 或 GIF。

它提供部分与 Screen Studio 类似的核心功能，但不是功能完全一致的替代品。项目说明提示软件仍可能存在问题，制作重要视频时应先测试录制与导出流程。

维护状态提醒：该仓库 README 已注明原项目归档、不再维护，并提供社区接续版本入口；下载前建议查看仓库中的维护说明和发布记录。

4. video-use：用 Coding Agent 剪辑视频#

GitHub：video-use

video-use 视频时间轴、音频波形与剪切点示意

video-use 是一个面向 Coding Agent 的开源视频剪辑项目。把原始视频放到目录中，用自然语言描述剪辑目标，让 Agent 整理素材、提出剪辑方案，确认后完成渲染与检查。

它支持删除口头填充词和停顿、添加字幕、调色及制作动画叠加。它不是传统的图形化剪辑软件；截图展示的是辅助剪辑判断的时间轴视图。使用需要配置 FFmpeg 等依赖，项目的转写流程还依赖 ElevenLabs API，应留意素材上传与服务费用。

浏览器与网页体验#

1. BewlyBewly：哔哩哔哩界面美化#

GitHub：BewlyBewly · Chrome 应用商店：安装 BewlyBewly

BewlyBewly 哔哩哔哩首页深色界面

BewlyBewly 是一个开源的哔哩哔哩浏览器扩展，主要通过重新设计网页界面改善浏览体验。它调整首页布局、视频卡片和导航，并为常用页面提供深色模式；截图展示的是扩展启用后的首页效果。

适合想让 B 站网页界面更简洁、统一的场景。项目侧重页面调整与视觉优化，并不是视频下载工具，也不意味着所有页面都已适配深色模式。

维护状态提醒：该 GitHub 仓库已于 2025 年 2 月 26 日归档，处于只读状态。安装前建议查看应用商店说明与项目维护状态，留意 B 站页面变化可能带来的兼容性问题。

阅读与收藏#

1. Omnivore：稍后阅读与文章管理#

GitHub：Omnivore

Omnivore 文章收藏与阅读界面

Omnivore 是一款开源的稍后阅读工具，用于集中保存文章，并通过标签、搜索、高亮和笔记整理阅读内容。它也支持 PDF、邮件订阅内容和 RSS，并提供 Obsidian 集成。

适合先收藏、再集中阅读和整理的场景。需要注意，原有云服务已于 2024 年 11 月停止，目前项目以自托管方式使用；截图展示的是界面示例，不代表原在线服务仍可用。

市场与行情#

1. OpenStock：股票行情与市场信息#

GitHub：OpenStock

OpenStock 市场概览与股票热力图界面

OpenStock 是一款开源的股票市场信息应用，用于查看市场概览、股票行情、热力图及公司信息，也支持搜索股票和建立个人关注列表。

适合把关注的股票与市场信息集中到一个界面中查看。自行部署需要配置数据库和行情数据接口；数据更新频率、覆盖范围与实时性取决于数据源和部署配置，不能默认所有行情都是实时的。

它不是证券交易平台，页面中的行情与信息也不构成投资建议。

AI 与工作流#

1. TongFlow：多模态 AI 工作台#

GitHub：TongFlow

TongFlow 多模态生成工作流界面

TongFlow 是一个开源的多模态生成式 AI 工作台，把文本、图像、音频、视频等输入与模型能力组织成画布上的节点，通过添加、转换和组合构建创作流程。

适合将多个生成步骤放到同一个工作流里，例如先根据文字生成图片，再组合多张图片，或串联脚本、语音和视频生成。不同能力由插件提供，实际可用功能取决于插件和模型服务配置。

项目提供浏览器云端工作台及桌面入口，也支持从源码或通过 Docker 自托管。桌面入口不等于所有模型都在本地运行，使用时应区分云端服务与自托管配置。

2. ComfyUI：节点式 AI 生成工作流#

GitHub：ComfyUI

ComfyUI 图像生成节点工作流界面

ComfyUI 是一个开源的节点式 AI 生成界面与后端。通过连接模型加载、提示词编码、采样、解码和保存等节点，把生成过程组织成可以保存、复用和调整的工作流。

适合需要控制生成步骤、组合不同模型和反复调试参数的场景。可用能力取决于模型、节点和扩展配置，运行前需要确认相应的硬件与依赖要求；安装第三方节点时也应留意来源与安全性。

3. img2threejs：从参考图重建 Three.js 模型#

GitHub：img2threejs

img2threejs 参考图与 Three.js 场景展示

img2threejs 是一个从参考图重建 Three.js 模型的开源项目与 Agent Skill。它强调用可检查、可修改的程序化代码构建几何体，通过分阶段检查与参考图对照，逐步调整模型。

输出重点是可维护、适合继续动画化的代码，而不是一个只能导入使用的封闭模型资产。适合探索图像到代码驱动 3D 场景的制作流程，重建效果仍取决于参考图、Agent 能力与迭代调整。

常用Prompts与Skills

Wed, 07 Oct 2026 00:00:00 GMT

常用 Prompts#

1. 中文授课稿改写提示词#

1
请把下面的文稿改成“专业教师可以直接朗读的中文授课稿”。
2

3
我的目标不是随意聊天，也不是教材摘要，而是：
4
句子完整、对象明确、上下文连贯、口语自然，同时保持专业准确。
5

6
请按以下要求修改：
7

8
1. 明确主语和讲述对象
9
定义句、提问句、结论句、转折句必须明确在讨论哪个对象。
10
不要让听众猜“谁满足条件”“哪个量在变化”“哪个事件有概率”。
11
不要机械地给每句话添加“我们”；应当使用准确的对象名称作主语。
12
同一句中主语清楚时，可以自然承接，避免重复啰嗦。
13

14
2. 保持专业定义
15
先给出准确的定义，再用完整的口头语言解释。
16
不要用模糊说法、比喻或口号代替定义。
17
保留结论成立的条件，不要为了通俗而扩大结论的适用范围。
18

19
3. 补足上下文衔接
20
引入新概念前，先说明当前有什么问题、为什么需要这个概念。
21
后一句应承接前一句已经出现的对象或问题。
22
不要只靠“接下来、那么、因此”等连接词制造表面的连贯。
23

24
4. 检查必要的前置知识
25
检查是否出现了未经解释的术语、符号、条件或方法。
26
对理解当前内容必需的知识，补上最短的必要解释。
27
不要默认听众能自行补出关键步骤，也不要展开完整理论和全部推导。
28

29
5. 准确区分对象
30
特别检查是否混淆了对象本身、对象的取值、相关集合、
31
条件以及由它们计算出的量。
32
数学稿中尤其要区分函数与函数值、事件与概率、密度与单点概率。
33

34
6. 使用自然的授课语言
35
使用完整、顺口、适合朗读的句子，避免提纲式短语和名词堆叠。
36
不要故意加入网络用语、语气词、夸张表达或不恰当的比喻。
37
不要把每一段都写成设问，也不要反复强调“这很重要”。
38

39
7. 控制内容与篇幅
40
保留原有知识范围和已经确定的教学顺序。
41
删除重复解释、没有教学作用的简单例子和无意义的演算。
42
只补理解所必需的内容，不要借修改之名扩写整门课程。
43
优先用更准确的句子替换旧句，而不是不断追加解释。
44

45
修改后，请再从“听众只听一遍、不回看文字”的角度检查：
46
- 听众能否知道每句话在讲哪个对象？
47
- 代词和省略成分是否有明确指向？
48
- 新概念是否有必要的引入？
49
- 结论是否交代了条件与必要理由？
50
- 是否仍有可以删去的重复内容？
51

52
请输出修改后的完整文稿，再简要列出主要修改。
53
如果发现会影响原意的专业错误，请单独说明。
54
若涉及文件，请另存新版本，不覆盖原稿。
55

56
文稿如下：
57
【粘贴文稿】

展开收起

2. AGENTS.md 配置提示词#

1
你是一个 Coding Agent。请在当前项目中创建或更新根目录的 `AGENTS.md`，为后续 AI 编程任务写入一套清晰、可执行、不过度冗长的规则，让 CodeGraph、Caveman、Ponytail 分工互补。
2

3
本任务不只是写文档：还要检查当前电脑上的全局工具配置、在缺少时完成必要配置、为当前项目初始化所需配置，并实际验证三者能否使用。
4

5
参考：
6
- Ponytail：https://github.com/DietrichGebert/ponytail
7
- Caveman：https://github.com/JuliusBrussee/caveman
8
- CodeGraph MCP 设置示例：https://github.com/shantham/codegraph/blob/main/docs/MCP-SERVER-SETUP.md
9
- Model Context Protocol：https://modelcontextprotocol.io/
10

11
## 执行步骤
12

13
1. 先检查当前项目的 `AGENTS.md`、Git 状态和未提交改动；检查当前 Coding Agent 的全局配置、相关 Skill/插件、MCP 服务和可用命令。不要覆盖已有配置或无关改动，也不要输出密钥、令牌或其他凭据。
14
2. 如果当前电脑缺少所需的全局配置，只为当前使用的 Coding Agent 补齐：
15
   - **CodeGraph**：按官方说明配置全局 MCP 服务。
16
   - **Caveman**：按 Skill/工作流安装和使用；不把 CLI 当作前置条件，不为此安装 CLI 或索取 API Key。
17
   - **Ponytail**：配置其 Skill/插件，使 Full 模式可用。
18
   修改已有全局配置前先备份到项目目录之外，并保留其他设置。若配置依赖用户提供的凭据，停止并说明如何在本机安全配置；不要让用户把密钥发到聊天中。
19
3. 全局工具可用后，初始化当前项目所需的 CodeGraph 索引。全局 MCP 配置与项目索引是两件事，不能互相替代。索引范围限制在源码、测试等代码目录；排除个人数据、凭据、依赖目录、构建产物和其他不相关内容。若无法安全划定索引范围，先询问用户。
20
4. 实际验证三者，而不只检查“已安装”状态：
21
   - **CodeGraph**：在当前项目索引中查询文件或符号，确认结果属于当前项目和预期范围。
22
   - **Caveman**：使用已安装的相关 Skill/工作流，完成一次不修改文件的调查或简报验证；明确区分事实与推断。
23
   - **Ponytail**：以 Full 模式对一个只读的小任务展示最小正确方案，不修改无关文件。
24
   不得把读取配置、找到 Skill 文件或其他项目的索引结果声称为成功调用。若工具无法实际运行，如实记录失败原因。
25
5. 创建或更新项目根目录的 `AGENTS.md`：
26
   - 若文件已存在，保留原有内容，只追加或合并；不得删除、覆盖或擅自重写现有规则。
27
   - 若已有 CodeGraph 规则，保留并复用，避免重复粘贴。
28
   - 只写对后续任务持久有效的协作规则，不把机器路径、密钥、临时日志写进项目文档。
29

30
## `AGENTS.md` 中应写明的协作规则
31

32
- **CodeGraph** 用于代码结构查询：定义、调用链、影响范围和上下文。结构问题优先使用；核实当前会话确实提供 CodeGraph，且索引对应当前项目。
33
- **Caveman** 按 Skill/工作流使用：不明问题先调查，报告简短且证据优先，必要时采用安全重构或外科式修复。不得将 CLI 作为前置条件，也不得声称调用了未加载的 Skill。
34
- **Ponytail** 用于最小正确实现：采用 YAGNI、复用现有代码、优先标准库/平台能力和已有依赖、避免无理由新增依赖或抽象。实现时使用 Full 模式；若 Skill 未加载，可遵循原则但不得声称已调用。
35
- 默认顺序：结构问题先用 CodeGraph；不明问题先调查；实现时用 Ponytail Full；最后按风险做最小必要验证，并遵守项目已有的强制检查。
36
- 正确性、安全、数据安全、用户明确要求和无障碍基础都高于“少写代码”；不得为精简而削弱这些要求。
37
- 最终报告简短说明改动、原因、实际验证结果和剩余风险；未运行的检查不得报告为通过。
38

39
## 验收与回复
40

41
检查 `AGENTS.md` 的 Markdown 标题层级、代码围栏和文件结尾；执行 `git diff --check`。文档改动不运行无关构建测试，但工具配置和项目索引必须按上面的步骤实际验证。
42

43
完成后分别报告：
44
- `AGENTS.md` 的绝对路径，以及是创建还是更新；
45
- 是否发现并保留已有 CodeGraph 规则；
46
- 全局配置中哪些已存在、哪些新配置；
47
- 项目索引的位置、范围和排除项；
48
- CodeGraph、Caveman、Ponytail 各自的实际验证结果；
49
- 未能验证的部分、原因和剩余风险。

展开收起

3. 前端视觉与交互检查提示词#

1
请先全面检查现有前端页面，重点检查以下问题：
2

3
1. 不必要、丑陋或风格不统一的图标。
4
2. 多余且没有实际意义的小字。
5
3. 按钮点击、状态切换时的频闪，以及不自然或多余的动画效果。
6
4. 所有按钮的边框位置、对齐和显示是否正常；结合现有页面风格，判断哪些按钮需要补充或调整边框与阴影，避免统一套用。
7

8
需要替换的图标统一从 Iconify 图标库中挑选，尽量使用同一图标集，保持风格一致：
9
https://icon-sets.iconify.design/
10

11
先把发现的问题、对应页面或组件位置，以及修改建议整理出来给我审核。
12

13
涉及图标替换时，制作一个可在浏览器中查看的图标审核页，展示原图标与候选图标的对比、各自的 Iconify 名称（如适用）、使用位置和替换理由，方便我逐项审核。审核页仅用于预览，不直接替换业务页面中的图标。
14

15
确认后再动手修改，不要直接批量调整。

展开收起

常用 Skills#

GitHub：我的 Skills 仓库

1. requirement-validate：需求理解确认#

GitHub：requirement-validate

这是我常用的需求确认 Skill。在开始实现之前，让 AI 用自己的话完整复述需求，我再审查、修改或补充，反复对齐直到确认无误，避免 AI 理解偏了就直接动手。

它只负责确认需求，不写代码、不设计方案，也不主动提供建议。每轮反馈后都会重新复述完整需求；确认后结束，不自动进入实现阶段。

使用时，附上需求文本，并明确说“先别写代码，先确认一下需求”或“帮我理解需求”。

2. blog-cover-prompt：博客封面提示词#

GitHub：blog-cover-prompt

这是我常用的博客封面提示词 Skill。根据文章的标题、摘要或正文，提取核心对象与关系，生成可以直接用于绘图的提示词，让不同文章的封面保持统一风格，同时体现各自的主题。

封面以深蓝黑背景、电蓝与青色光线、玻璃或全息材质为主。它会给出构图思路、正向提示词和负向约束，默认只写提示词，不直接生成图片，也不修改或发布文章。

使用时，附上文章内容，并说明“为这篇文章写封面提示词，保持博客已有封面风格”。

3. humanizer-zh：去除中文 AI 写作痕迹#

GitHub：humanizer-zh

用于去除中文文本中的 AI 写作痕迹，让表达更自然。写完文章或文案后，可以用它检查和调整生硬、模板化的表达。

使用时，附上需要修改的文本，并说明“去除这段文字中的 AI 写作痕迹，保留原意，让表达更自然”。

4. beautify-github-readme：整理与美化 README#

GitHub：beautify-github-readme

用于整理并美化 GitHub README 的内容层级与视觉呈现，让读者更容易找到项目介绍、使用方式和其他重要信息。

使用时，提供项目仓库或 README 文件，并说明“整理并美化这个 README，保留重要信息，让内容层级和视觉呈现更清晰”。

5. vibe-learn：面向非科班开发者的实践学习#

GitHub：vibe-learn

面向非科班开发者，教授工具使用和向 AI 描述需求的方法。重点是把实际任务说清楚、理解操作步骤，而不是展开底层理论或数学推导。

使用时，说明当前想完成的任务或想学习的工具，并提出“教我怎么使用这个工具，以及怎样向 AI 描述我的需求”。

值得反复观看的文章与视频（持续更新ing）

Wed, 23 Sep 2026 00:00:00 GMT

收集有意思或实用的文章与视频，按主题整理，持续更新。

技术与实践#

【文章】终端里的 ASCII 控制字符 · Julia Evans · 配套速查表
解释终端中常见 Ctrl 组合键与 ASCII 控制字符的关系，并提供速查表，具体行为会因环境和配置而异。
收录：2026-09-23

AI 与工具#

学习与思考#

【视频】从理解差异到经营亲密：一套恋爱关系方法论 — real_屠龙的胭脂井
从理解男女差异、建立吸引与依恋，到判断关系并经营亲密，也呈现了将恋爱策略化、强调掌控与忠诚的一面。
收录：2026-09-23
【视频】数学地图：数学全分支（26重制）
从数、结构、空间与变化出发，梳理纯数学、应用数学与数学基础的主要分支，以及它们与物理、计算机科学、机器学习等领域的联系。适合建立数学全局视野，学习具体知识时回来定位它所在的位置。
收录：2026-10-07

设计与表达#

生活与见闻#

数学与统计学知识卡片(持续更新ing)

Sun, 20 Sep 2026 00:00:00 GMT

这里记录一些值得反复理解、但不一定需要单独写成完整文章的数学与统计学概念。内容会随着学习持续补充。

数学基础与逻辑#

充分条件与必要条件#

一句话抓住本质#

判断充分条件和必要条件时，不要先看语序，只看箭头：

A⇒BA\Rightarrow BA⇒B：AAA 是 BBB 的充分条件，BBB 是 AAA 的必要条件。
A⇔BA\Leftrightarrow BA⇔B：AAA 与 BBB 互为充要条件。

可以把它记成：

充分条件：有它就够了。
必要条件：没有它不行。

充分不必要与必要不充分#

若 AAA 是 BBB 的充分不必要条件，则

A⇒B,B⇏A.A\Rightarrow B,\qquad B\nRightarrow A.A⇒B,B⇏A.

由 A⇒BA\Rightarrow BA⇒B 可知：

AAA 是 BBB 的充分条件；
BBB 是 AAA 的必要条件。

再由 B⇏AB\nRightarrow AB⇏A 可知，BBB 不是 AAA 的充分条件。因此：

若 AAA 是 BBB 的充分不必要条件，那么 BBB 是 AAA 的必要不充分条件。

例如：

AAA：一个整数能被 4 整除；
BBB：这个整数能被 2 整除。

显然 A⇒BA\Rightarrow BA⇒B，但 B⇏AB\nRightarrow AB⇏A。因此，“能被 4 整除”是“能被 2 整除”的充分不必要条件；反过来，“能被 2 整除”是“能被 4 整除”的必要不充分条件。

充要条件中的充分性与必要性#

“PPP 的充要条件是 QQQ”表示

P⇔Q.P\Leftrightarrow Q.P⇔Q.

证明时要完成两个方向：

充分性#

证明

Q⇒P.Q\Rightarrow P.Q⇒P.

这里是在说明：条件 QQQ 足以保证结论 PPP 成立。

必要性#

证明

P⇒Q.P\Rightarrow Q.P⇒Q.

这里是在说明：结论 PPP 若成立，条件 QQQ 就必须成立。

语序到底影响什么#

“PPP 的充要条件是 QQQ”与“QQQ 的充要条件是 PPP”在逻辑上等价，因为

P⇔QP\Leftrightarrow QP⇔Q

与

Q⇔PQ\Leftrightarrow PQ⇔P

表达的是同一个等价关系。

但是，语序会影响证明中哪一个方向被称为充分性，哪一个方向被称为必要性：

要证明的表述	充分性	必要性
PPP 的充要条件是 QQQ	Q⇒PQ\Rightarrow PQ⇒P	P⇒QP\Rightarrow QP⇒Q
QQQ 的充要条件是 PPP	P⇒QP\Rightarrow QP⇒Q	Q⇒PQ\Rightarrow PQ⇒P

所以考试中真正要注意的不是两句话是否等价，而是题目要求你证明哪句话，以及当前证明方向应当叫什么。

快速判断法#

遇到“PPP 的充分条件、必要条件或充要条件是 QQQ”时：

先把 QQQ 看作条件，把 PPP 看作结论。
充分性写成“条件推出结论”：Q⇒PQ\Rightarrow PQ⇒P。
必要性写成“结论推出条件”：P⇒QP\Rightarrow QP⇒Q。

最终只认箭头，不靠语感。

概率与统计#

概率论与统计学#

核心区别#

概率论：已知总体的概率模型，研究该模型可能产生什么样的数据，以及各种结果出现的概率。
统计学：已经观测到来自总体的样本数据，据此反推未知的概率模型、参数或总体特征。

两者的推理方向正好相反：

概率论：从模型到数据；统计学：从数据到模型。

统计学的两类方法#

参数统计#

预先假设总体属于某个确定的分布族，只把其中有限个参数视为未知量，再利用样本估计这些参数。

例：假设总体服从正态分布 N(μ,σ2)N(\mu,\sigma^2)N(μ,σ2)，但参数 μ\muμ 和 σ\sigmaσ 未知，于是利用样本对它们进行估计。这里的分布族已经确定，未知的只是参数。

非参数统计#

不预先把总体限制在某个由有限参数决定的分布族中，而是更多地依靠样本数据估计分布形状或其他总体特征。

例：核密度估计不要求总体必须服从正态分布、泊松分布等特定分布，而是根据样本直接估计概率密度曲线。

需要注意：“非参数”不等于“完全没有假设”。它仍可能依赖平滑性等条件，也需要选择核函数、带宽等方法参数；只是不会预先把总体限定为某个有限参数分布族。

概率论学习指南#

这两个都值得收藏，而且很好搭配：Statlect 更像一本讲解型教材，StatProofBook 更像一本随时查阅的统计证明手册。 前者适合学懂一个主题，后者适合追问“这个结论到底怎么推出来”。

1. Statlect：概率、统计与矩阵代数的在线教材#

网址：https://www.statlect.com/

它是免费的英文教材，内容包括概率论基础、常见概率分布、数理统计、渐近理论、矩阵代数，以及部分机器学习内容。

你可以在里面学：

概率基础：随机变量、期望、方差、条件概率、贝叶斯公式。
统计推断：最大似然估计、置信区间、假设检验、线性回归。
进阶理论：大数定律、中心极限定理、不同类型的随机收敛。
数学工具：矩阵、特征值等统计学常用的线性代数知识。
部分机器学习方法：配有详细注释的 Python 示例。

它的优势是围绕一个主题把定义、解释、公式、推导和例子组织在一起，还有习题和图示，适合相对连续地读。

比如，你在论文里看到“最大似然估计”，可以去读它的最大似然章节，把这个方法的目标、数学表达和相关性质串起来。

不过，它整体仍偏数学，遇到进阶章节需要一定微积分、线性代数和概率基础。可以把它当作大学课程的补充教材，或读论文时补基础的工具。

2. StatProofBook：统计学结论的证明库#

网址：https://statproofbook.github.io/

全名是 The Book of Statistical Proofs。它是一个开放、协作编辑的统计定理与证明档案，包含定义和证明，可以按主题或编号查找，也提供整本 PDF。

它的目录主要围绕：

一般定理，包括概率、期望、方差等。
概率分布及其性质。
统计模型。
模型选择准则。

它的特点是把问题拆得非常细。例如，在“期望”下面，会分别列出线性性、单调性、全期望公式等证明；在概率密度函数下面，会分别列出变量变换、独立随机变量求和等结果。

这很适合你遇到这样的情况：

课本或论文直接写出一个公式，但中间几步省略了，我想知道依据是什么。

这时可以从完整目录找对应命题，沿着定义和证明逐步核对。它尤其适合做理论作业、检查推导，或阅读论文时补上某一步。

局限是，它更侧重证明本身，学习动机、直观解释和应用故事相对少。初学时从头逐条读，容易陷进细节；带着明确问题查，通常更高效。

怎么搭配用？#

假设你正在学正态分布：

先用 Statlect 了解定义、参数、图像及主要性质。
对某个性质有疑问，例如“为什么方差是这个表达式”，去 StatProofBook 找对应证明。
自己把推导写一遍，再用例题或代码验证理解。

如果现在只挑一个开始读，我建议先用 Statlect；把 StatProofBook 放在旁边，作为推导卡住时的参考。 两个网站的符号和参数约定可能不同，交叉查阅时要先核对定义，尤其注意同一个分布里的参数究竟表示方差、标准差、尺度还是率。

用 GitHub Actions 实现 CI/CD 自动部署

Sat, 19 Sep 2026 00:00:00 GMT

用 GitHub Actions 实现 CI/CD 自动部署#

本文记录如何用 GitHub Actions 串起从代码推送到上线的流程：自动验证、构建、上传产物并更新服务，让生产服务器只负责运行，不再承担构建压力。

我为什么开始折腾 CI/CD#

最开始，我的部署方式完全是手动的：本地写完代码，先推送到 GitHub，再通过 SSH 登录服务器，手动 git pull 拉取代码，执行 npm install 安装依赖，再用 npm run build 构建，最后更新线上服务。

但实际操作中，构建经常卡住，连带着 SSH 连接也会中断。我已经确认，原因就是服务器内存不足：服务器内存只有约 1.6 GiB，一边运行线上服务，一边执行构建，内存不够用。因此，需要把构建工作搬离服务器，让它只负责运行服务。

于是，我先想到一个办法：在本地构建好，再用 SCP 把产物上传到服务器，让服务器只负责运行。 这一步解决的是“在哪里构建”的问题，但构建、上传、更新版本这些操作，仍然需要我手动完成。

接着，我想到了以前一直听说、却从来没用过的 GitHub Actions：既然这些步骤每次都差不多，能不能让 GitHub 在收到代码后，自动替我执行？

我想达到的效果是：

1
本地修改代码，push 到 GitHub
2
  ↓
3
GitHub Actions 自动验证和构建
4
  ↓
5
把构建产物上传到服务器
6
  ↓
7
服务器更新版本并检查服务是否正常

所以，我学习 CI/CD 不是为了先记住一套概念，而是为了解决一个具体问题：从“SSH 登录服务器，手动拉代码、装依赖、构建”，变成“我只负责推送代码，流水线负责验证、构建和部署”。

这条思路分成两步就很清楚：先把构建搬离服务器，减轻服务器压力；再把重复的发布步骤交给 GitHub Actions，减少手动操作。

CI/CD 自动部署完整流程

这张图展示从提交代码到上线的完整流程：push 后，GitHub Actions 自动验证、构建并打包，通过 SCP 上传产物，再通过 SSH 执行服务器上的版本切换和重启，最后做健康检查，失败时尝试回滚。核心是把构建交给 Actions，服务器只负责运行产物。

一、我的部署分工#

最终采用的分工是：

1
本地电脑
2
  └─ 写代码，git push
3

4
GitHub Actions runner
5
  ├─ 拉取代码
6
  ├─ 安装依赖
7
  ├─ 运行测试
8
  ├─ 构建 Next.js standalone
9
  └─ 打包部署产物
10

11
生产服务器
12
  ├─ 接收压缩包
13
  ├─ 解压到 releases/<commit-sha>
14
  ├─ 切换 current 软链接
15
  ├─ 重启 systemd 服务
16
  └─ 做健康检查

展开收起

为了尽早发现代码问题、减少手动发布操作，我们把验证和部署组织成 CI/CD 流程：

CI（Continuous Integration，持续集成）：频繁地将代码变更集成到共享主干，并通过自动构建、测试等检查，尽早发现问题。本文中的安装依赖、测试和构建，就是其中的自动验证步骤。
CD（Continuous Deployment，持续部署）：本文采用这一含义，即在 CI 检查通过后，自动将构建产物部署到生产环境并更新服务，不需要人工批准上线。

这个项目推送到 master 后会自动验证、构建并部署，采用的就是持续集成 + 持续部署。GitHub Actions 是执行这套流程的工具，不是 CI/CD 本身。

二、从 push 到上线的主线#

实际流程压缩起来就是这一条：

从代码推送到服务上线的发布主线

这张图按执行位置串起发布主线：本地 push 触发工作流，runner 负责验证、构建和打包，再通过 SCP 上传产物、SSH 执行服务器上的版本更新，健康检查通过后完成发布。

GitHub Actions 工作流、任务与步骤的结构

GitHub Actions 是 GitHub 提供的自动化工具：在 .github/workflows/ 中编写 workflow（工作流），由 on 指定 push 等触发事件。一个 workflow 包含一个或多个 job（任务），每个 job 由 **runner（执行机器）**执行，内部的 **step（步骤）**按顺序运行；step 用 run 执行命令，或用 uses 调用封装好的 action（操作）。不同 job 默认可并行，用 needs 指定先后依赖；runner 不等于生产服务器，远程部署需通过 SSH 等方式连接。

下面用项目中的几个配置项，看看这些概念在 YAML 中怎么写。以下是局部示例，不是完整的部署配置。

第一个例子：什么时候触发 workflow？

1
on:
2
  push:
3
    branches: [master]
4
  workflow_dispatch:

on 指定整个 workflow 的触发条件：push 配合 branches: [master]，表示向 master 推送代码时运行；workflow_dispatch 则允许在 GitHub 页面手动触发。这里决定的是“什么时候开始”，还没有描述具体做什么。

第二个例子：job 在哪里执行，step 做什么？

下面补出必要层级作示意，其他步骤省略：

1
jobs:
2
  build:
3
    runs-on: ubuntu-latest
4
    steps:
5
      - uses: actions/setup-node@v4
6
        with:
7
          node-version: 22
8
          cache: npm

这里的 build 是 job 的标识，runs-on 为它选择 GitHub 提供的 Ubuntu 执行机器；steps 中的这个步骤通过 uses 调用 actions/setup-node，准备 Node.js 环境。with 是传给这个 action 的参数：使用 Node.js 22，并启用 npm 缓存来加快依赖准备，但缓存不能代替后续的 npm ci 安装步骤。注意，@v4 是 action 的版本，22 才是 Node.js 的版本。

Next.js 使用 standalone 输出：

1
output: 'standalone'

standalone 的意义是：生产服务器不需要完整源码和完整 node_modules，主要运行构建后的：

1
.next/standalone/server.js

这正好适合低内存服务器。

三、服务器上怎么切换版本#

服务器不是直接覆盖旧目录，而是保留多个 release：

服务器 release 目录与 current 软链接

图中 incoming/ 暂存上传的包，releases/ 分别保存新旧版本，current 是指向所选版本的软链接，.env 则单独留在服务器。新版本先准备完整，再切换入口并重启服务，避免直接覆盖旧文件，也为失败回滚保留旧版本。

1
~/English_Context/
2
├── incoming/
3
├── releases/
4
│   ├── <sha-1>/
5
│   └── <sha-2>/
6
├── current -> releases/<当前版本>
7
└── .env

每次新版本上传后，先解压到：

1
releases/<commit-sha>/

然后把 current 软链接切过去：

Terminal window

1
ln -sfn "$release" "$next_link"
2
mv -Tf "$next_link" "$current"

这样做的好处是，服务目录要么指向完整旧版本，要么指向完整新版本，不会停在复制了一半的状态。

服务由用户级 systemd 运行：

1
WorkingDirectory=%h/English_Context/current
2
Environment=NODE_ENV=production
3
Environment=PORT=3456
4
Environment=HOSTNAME=0.0.0.0
5
ExecStart=/usr/bin/node server.js
6
Restart=on-failure
7
RestartSec=5

部署脚本切换 current 后，执行：

Terminal window

1
systemctl --user daemon-reload
2
systemctl --user restart english-context.service

最后用 curl 检查本机端口：

Terminal window

1
curl -fsS --max-time 2 "http://127.0.0.1:3456/"

这个检查不代表业务完全正常，但至少能确认 Next.js 服务已经启动，并且 HTTP 能返回成功状态。

四、失败时怎么退回去#

自动部署一定要考虑失败。这里最需要处理的是：文件已经上传了，current 也切到新版本了，但服务启动失败或健康检查失败。

脚本会在切换前记录旧版本：

健康检查失败后的应用版本回滚

沿着上排看：先记录旧版本，再切到新版本并重启，随后检查服务是否正常响应；如果检查失败，就沿虚线进入下排，把 current 切回旧目录并重启。回滚能成立，是因为旧版本仍被完整保留，而不是失败后再重新构建一次。

Terminal window

1
previous="$(readlink -f "$current")"

如果新版本失败，就把 current 切回旧版本，并重启服务：

Terminal window

1
ln -sfn "$previous" "$next_link"
2
mv -Tf "$next_link" "$current"
3
systemctl --user restart "$unit_name"

这只能回滚应用目录，不能回滚所有东西。数据库、用户数据、缓存、Service Worker 都可能有自己的状态。

五、数据库迁移单独处理#

ContextVocab 使用 Prisma 和 PostgreSQL。应用发布和数据库结构变更不是一回事：

应用回滚与数据库迁移的边界

左边的应用版本可以通过 current 切回旧目录，右边的数据库变更却不会随之撤销：例如字段已经被删除，退回旧代码也无法把它恢复。因此，数据库迁移需要单独处理，优先做兼容新旧代码的渐进变更，不能把应用回滚当成数据库回滚。

1
应用代码发布
2
数据库 schema/migration 发布

当前 workflow 不自动执行数据库迁移。原因是：应用 release 可以切回去，但数据库迁移未必可逆。

生产数据库更适合渐进式处理：

1
1. 先添加兼容旧代码的新字段
2
2. 部署兼容新旧结构的代码
3
3. 执行数据回填或索引调整
4
4. 验证生产读写
5
5. 后续版本再删除旧字段

这样新旧代码在过渡期都能工作，出问题时也更容易退回。

六、这套方案的核心#

这篇记录里真正重要的不是 GitHub Actions 的 YAML 细节，而是这条分工：

1
本地负责写代码和推送
2
GitHub Actions 负责验证和构建
3
服务器负责运行产物和切换版本
4
健康检查决定发布是否成功
5
失败时回滚应用 release
6
数据库迁移单独设计

对低内存服务器来说，这比“SSH 上去现场构建”稳定很多。

核类美学：梦核、怪核与池核

Sun, 13 Sep 2026 00:00:00 GMT

怪核-超市黑洞

两侧是再普通不过的商店货架，通道尽头却只剩一片没有细节的黑。¹

怪就怪在这里：货架、地面、灯光都没有问题，唯独本该通向别处的通道失去了下文。梦核、怪核与池核经常这样处理普通场所，留下熟悉的外壳，拿走人物、用途或空间线索。要弄清这种处理为什么有效，得先认识一个反复出现在三者中的概念：阈限空间。

阈限空间#

“阈限”来自拉丁语 limen，意思是门槛或临界。走廊、等候室、停车场都属于这类空间：人们来这里是为了经过，很少把它们当作目的地。²

凌晨的商场、放假后的学校走廊、空停车场，都是常见题材。建筑和设施还在，人和日常活动却消失了。²

阈限空间-昏暗走廊

这条走廊属于什么建筑，又通向哪里，画面都没有交代。柱子、顶灯和转角一再重复，视线找不到可以停下来的终点。

我们平时会靠建筑和物件判断一个地方是做什么的。阈限空间没有抹掉这些提示，只是抽走了本该在这里发生的活动，于是熟悉的地方突然变得不太对劲。

“核类美学”是什么#

中文互联网所说的“核”，来自英文后缀 -core，大致是“围绕某种元素形成的风格”。它本身不等于恐怖，也不一定诡异。梦核偏向梦境感，怪核偏向异常感，池核则围绕水池空间展开。³

判断一幅图更接近哪种风格，可以先问几件事：

它主要在拍什么：梦境、异常信息，还是水池？
这个地方出了什么问题：空无一人、已经废弃、失去用途，还是根本不符合建筑逻辑？
画面又是怎样处理的：柔光和旧画质，故障效果，还是蓝白色的水光？

这些分类并不互斥。一座无人泳池，题材上是池核，空间状态带有阈限感；如果再加上故障和低清效果，画面也会染上怪核的味道。

共性与差异#

无人场所、旧画质和残缺的空间信息，在这些作品里反复出现。不过它们关注的东西不同。阈限空间关心场所为何像是卡在“途中”；梦核借用梦的逻辑和童年意象；怪核让信息彼此冲突；池核最直接，主角通常就是泳池和水域。

梦核#

视觉语法#

按美学 Wiki 的说法，梦核是一种用图像、视频和音乐表现梦境及梦中感受的超现实主义美学。⁴

梦核-雾中泳池

柔和的蓝色、浓雾、对称摆放的盆栽，还有一路向下的瓷砖台阶。楼梯通向哪里？水面从哪儿开始？图里没有答案，也找不到能判断尺度和方向的参照物。⁵

所以它既像池核，也像梦核。水池、瓷砖和蓝色调来自池核，柔焦、无人场景与含混的空间关系又把它推向了梦境。

梦核喜欢挪用学校走廊、游乐场、商场和卧室这类带有童年记忆的地方，再塞进不合常理的生物、物件或空间关系。你认得每样东西，却说不清它们为什么会同时出现在这里。

粗略地说，它常由童年场景、错位的物件或生物，再加一层旧影像质感组成。

胶片光晕、划痕、压缩噪点和冷色荧光灯，会让画面像一段来历不明的旧录像。童年符号让人产生“我好像见过”的感觉，空间错位又马上让这份熟悉感站不住脚。

它常以阈限空间、不切实际的地形或梦幻场所为底，再叠上文字、眼睛、翅膀、奇怪生物、RPG 文本框、电脑弹窗或 CRT 电视机。⁴

这些符号未必对应某个具体的梦。梦核借用的是梦的组织方式：东西可以一起出现，不必遵守现实中的尺度、位置和因果。

与阈限空间的区别#

阈限空间强调过渡场所，以及空间功能与当前状态之间的错位。
梦核强调梦境逻辑、童年意象和超现实重组，不必发生在严格意义上的过渡空间。⁴

简单说，阈限空间主要改变场所的使用状态；梦核动得更多，物件组合、比例乃至因果关系都可能被改写。

《Dreamcore》游戏案例#

《Dreamcore》官网称它是一款以阈限空间为基础的心理恐怖游戏。游戏没有固定方向，也不给出明确目标，玩家只能自行探索。⁶

Playrooms 里有软垫房、塑料城堡和球池通道，看起来像儿童游乐区，却没有孩子、声音和可辨认的用途。Eternal Suburbia 换成了重复的住宅与循环路径，布局不讲道理，方向感也随之失效。⁶

它不太依赖突然惊吓。真正让人紧张的是：场所结构还在，原有用途、人物和行动方向却都没了。

在 YouTube 观看 Liminal Hotel 展示视频

“Liminal Hotel” 的展示视频里，走廊不断循环，楼层也会悄悄转换。固定地标不再可靠，玩家很难确认自己在哪里，更别说出口。

怪核#

怪核也爱用阈限空间、早期互联网画面和超现实拼贴。它最在意的不是“像不像梦”，而是让图像里的信息怎么都拼不成一个完整解释。

美学 Wiki 把它归为超现实主义美学。业余摄影、低质量图像和刻意粗糙的后期很常见，它们会带来混乱、陌生、怀旧甚至恐惧感。⁷

开头商店图的构图#

透视线汇聚：货架边缘、层板和地面边界都朝中央消失点收束。
通道逐渐收窄：两侧高大货架形成隧道式包围，越接近中心，可活动空间看起来越小。
终点被黑暗替代：远处信息没有逐渐缩小，而是直接消失。
明暗反差明显：两侧商品明亮且具体，中央区域则没有细节和尺度。

货架、地面和通道全都指向中央，照理说那里应该给出答案，结果却什么也看不见。正常透视走到终点，突然断了。

怪核不需要真的放进一只怪物。低画质、缺失的背景、割裂的文字和不正常的空间，已经足够让画面失去完整解释。⁷

林中的发光人影#

怪核-林中发光人影

树木、落叶和林间空地都很真实，中央两个人形却被白光抹去了面孔、衣着和身份。熟悉的森林因此失去尺度与解释：他们究竟是被照亮的人，还是只有轮廓的不明物体？

池核#

池核围绕水池、瓷砖和波光展开。有些画面干净、安静，像是可以休息的地方；另一些则空无一人，结构不断重复，建筑关系也根本不可能成立。⁸

蓝色、白色和蓝绿色最常见，整齐的瓷砖、清澈水面与公共泳池设施也几乎成了固定班底。⁸

没有出口的室内泳池#

池核-室内泳池

这里没有怪物，也没有明显的破败痕迹，只有蓝色瓷砖、水面、天窗和一座空泳池。可右侧采光口被墙和水面隔开，远处两个门洞也不知通向哪里。它看起来能用，细想又处处不合理。

Jared Pike 的《Dream Pools》#

Jared Pike-Dream Pool 05

Jared Pike 从 2020 年开始制作《Dream Pools》。他称这个系列是在探索“诡异的怀旧”：无尽的泳池把梦境和清醒状态混在了一起。作品使用 Blender 3D 和 LuxCore 制作。⁹

这些泳池干净明亮，看上去随时可以下水，却没有人、出口和明确尺度。水、瓷砖、光照都足够真实，唯独泳池没有尽头，建筑关系也对不上现实。

《POOLS》游戏案例#

POOLS-官方游戏截图

《POOLS》没有怪物追逐，也没有用户界面、对白、背景音乐或传统故事。玩家面对的只有黑暗区域、狭窄通道，以及一间接一间找不到明确出口的水池。¹⁰

每个房间的声音与回声都不一样，涉水还会拖慢脚步。这里的玩法就是听声、看路，并在相似的建筑里勉强维持方向感。

官网列出的灵感来源包括阈限空间、Backrooms 和 Poolrooms，也明确提到 Jared Pike 对 Poolrooms 概念的影响。¹⁰

Blender 实践：构造一条积水地下通道#

你的浏览器不支持视频播放，可下载观看积水地下通道视频。

为了看看这些视觉特征能否被主动构造，我用 Blender 制作了一条被积水淹没的地下通道，把池核、阈限空间与怪核的元素放进同一个场景。

水面、瓷砖和破碎的灯光倒影构成了池核的题材基础。地下通道原本用于通行，如今却空无一人，积水也让它失去正常用途，因此带有明显的阈限感。通道不断向前延伸，尽头被青绿色薄雾遮住，观者无法判断出口是否存在。这种空间信息的中断，又让画面靠近怪核。

制作时，水波不能太剧烈。这个场景需要近乎停滞的水面，只留下缓慢晃动的反光。冷白灯光负责交代建筑结构，薄雾则抹去远处的信息。场景里没有怪物，那个看似真实却解释不通的地方，本身就让人不安。

完整的场景描述和制作要求见 Blender 积水地下通道场景构建提示词。

三种核类美学如何重叠#

这次实践也说明，只给一幅图贴上“池核”或“怪核”的标签，往往会漏掉它真正起作用的部分。题材、场所状态和画面处理可以分别来自不同风格。

池核 × 怪核#

池核与怪核交叉作品

画面主体是池子和水域，所以首先是池核。这里空无一人，用途不明，带着阈限感；低清画质、黑暗区域和无法确认的背景，又让它靠近怪核。¹¹

更准确地说，池核说的是题材，阈限空间说的是场所状态，怪核说的是画面怎样变得异常。

把风格拆成参数#

Dreamcore Style Transfer 是一个使用 Python Pillow 的开源项目。它把十种核类风格拆成参数配方，再依次调整色彩、曝光、颗粒噪点、柔光 Bloom 和扭曲。¹²

核类美学-风格迁移界面

截图里的原图是一座水池，界面选择了“怪核”预设。处理后，画面多了强对比、故障线和彩色噪点。

但滤镜只能改变图像的质感。梦核常见过曝、褪色和胶片颗粒，怪核偏爱色散与故障，池核则常用水下蓝和青色高光。¹²

如果原图里没有无人空间、异常比例、符号错位或信息断裂，套完滤镜往往只是复古、低清或者偏色。决定风格的，仍是场景本身和元素如何组合。

核类美学为什么吸引人#

这类图像先让人认出场所。建筑、家具和公共设施都很熟悉，大脑很快就会猜出这里“应该”发生什么。接着，画面用无人、黑暗、循环或异常比例打破这个预测，却又故意省略人物、事件和空间边界。我们只好自己补全缺失的信息。

吸引力就来自这段没有完成的判断：眼前的地方明明认识，却始终解释不通。梦核、怪核和池核改动的是场所状态、空间关系或图像信息，滤镜反而只是表面的一层。

附录：Blender 积水地下通道场景构建提示词（点击展开）

场景目标

制作一条被洪水灌满的废弃地铁人行通道。两侧铺墨绿色小方块马赛克瓷砖，左侧露出金属楼梯扶手。天花板排列长条 LED 荧光灯，冷白光向下照射，暗色积水覆盖整条通道。水面缓慢荡漾，把灯光反射切成破碎的亮斑。

通道要像是一直延伸到远处，尽头被青绿色薄雾遮住。画面中没有人，也看不出明确出口，整体氛围死寂而幽闭。

美学拆解

积水、瓷砖和灯光倒影提供池核的题材特征。
失去通行功能的地下通道构成阈限空间。
被雾吞没的尽头切断空间信息，使画面靠近怪核。

材质与建模要求

可以从 Poly Haven 下载所需材质，优先使用 4K 版本。
下载的材质存入“材质（按照自己需求创建）”文件夹，也可以使用现有的材质资产和 HDR 资产。
门、窗和其他建筑开口使用布尔方式制作。
建模前先审核场景，确认空间结构没有明显问题。

灯光与渲染要求

使用 Cycles 渲染，整体效果以写实为目标。
先确定主光方向，再调整水面反射、环境亮度和整体氛围。
外景光照使用环境 HDR。
薄雾中需要出现带有丁达尔效应的体积光。
氛围和参考描述应尽量一致，不能只完成建筑模型而忽略光线与空气感。

工具

成品

观看积水地下通道成品视频

这个场景在美学文章中的分析见本文的 Blender 实践章节。

Footnotes#

图片原链接：Reddit 图片，出处为 r/weirdcore 的 “supermarket weirdcore” 帖子。 ↩
美学 Wiki，〈Liminal Space（阈限空间）〉，访问于 2026-09-06。社区协作资料，用于说明美学分类与常见视觉特征，不等同于同行评审研究。 ↩ ↩²
美学 Wiki，〈核类美学〉，访问于 2026-09-06。该分类页用于说明 -core/“核”的分类含义。 ↩
美学 Wiki，〈梦核（Dreamcore）〉，访问于 2026-09-06。社区协作资料，用于说明梦核的常见定义、传播媒介与视觉元素。 ↩ ↩² ↩³
梦核图片原链接。 ↩
Montraluz LLC，〈Dreamcore Official Website〉，访问于 2026-09-06。用于核对游戏定位、地图设计与探索方式。 ↩ ↩²
美学 Wiki，〈怪核（Weirdcore）〉，访问于 2026-09-06。社区协作资料，用于说明怪核的视觉语言与情绪取向，不作为临床心理学资料。 ↩ ↩²
美学 Wiki，〈池核（Poolcore）〉，访问于 2026-09-06。社区协作资料，用于说明池核的题材、视觉元素与情绪特征。 ↩ ↩²
Jared Pike，〈Dream Pools〉，访问于 2026-09-06。艺术家本人对系列的说明，用于核对创作时间、主题与工具。 ↩
Tensori，〈POOLS〉，访问于 2026-09-06。游戏官网，用于核对交互设计、声音机制、情绪目标与创作灵感。 ↩ ↩²
图片原链接：Backrooms Wiki 图片，作者原帖为 Instagram @onion.wave，出处核对：Backrooms Wiki — Level 188.8。 ↩
George-Ye2012，〈Dreamcore Style Transfer〉，GitHub，访问于 2026-09-06。开源实践项目，用于说明核类风格的参数化处理方法，不是美学分类或心理学研究的权威来源。 ↩ ↩²

AI辅助学习：把多源知识变成一对一课堂

Tue, 25 Aug 2026 00:00:00 GMT

来源：How I Use AI to Learn Things

我们常把学习理解成“找到足够好的资料，然后认真读完”。但真正困难的地方，往往不是资料不够，而是资料与自己的理解状态并不匹配。

一本教材可能从已经掌握的内容开始讲，也可能突然跳到暂时无法理解的概念。老师面对一整个班级时，也很难为每个人实时调整进度。于是，学习者不得不自己承担大量“后勤工作”：寻找资料、判断资料是否可信、安排顺序、确认自己究竟卡在哪里。

AI 的价值，或许不只是更快地回答问题，而是把学习过程重新组织成一场真正的一对一教学。

传统教学的问题：同一条路径无法服务所有人#

常见的教学模式是“多对多”：一个老师用同一套课程，面向多个学习者授课；或者多个资料来源共同影响一个学习者。这样的模式便于规模化，却很难做到精准。

对某个学生来说，课程中可能有一部分内容早已掌握，另一部分内容又超出了当前的理解能力。最有效的教学，不应该反复讲已经会的知识，也不应该强行讲解暂时还无法吸收的内容，而是应该持续工作在学习者的“理解边缘”。

所谓理解边缘，就是学习者已经具备了必要的基础，只差一个恰当的解释、一个例子，或者一个小的推导，就能继续向前理解的地方。

这也是一对一教学的优势：老师可以根据学生的即时反馈调整深度、顺序和表达方式。AI 如果能够准确掌握学习者的状态，就有机会把这种优势扩展到更多场景中。

第一步：Probe，探查我究竟理解了什么#

个性化教学的前提，是系统必须知道学习者当前的理解状态。只说“我想学人工智能”或“我看过这本书”，远远不够。AI 需要建立一张更细致的学习者理解地图。

一种可行的方法是使用分级多选测验。系统先提出比较宽泛的问题，了解学习者对主题的整体把握；然后沿着课程依赖的知识线继续追问，用类似二分搜索的方式逐步逼近理解边缘。

例如，学习者声称自己理解了“梯度下降”，系统不能只停留在术语层面。它还需要确认学习者是否理解函数、导数、斜率、损失函数，以及这些概念之间的依赖关系。

这种探查不是为了考试，而是为了避免教学建立在错误的假设上。只有知道哪些内容已经掌握、哪些内容似懂非懂、哪些内容完全陌生，后续的教学计划才有意义。

第二步：Plan，规划适合当前状态的路径#

完成探查后，AI 才能决定从哪里开始、讲到什么程度，以及哪些内容应该暂时跳过。这个过程可以称为优化教学（Optimized Teaching）。

优化教学的目标不是把所有知识都讲一遍，而是把有限的注意力用在最有价值的地方：减少重复，避开当前无法理解的内容，集中突破学习者刚好能够吸收的部分。

因此，同一个问题不应该只有一份固定答案。同一个概念，也不应该对所有人使用完全相同的解释。对于初学者，AI 需要先补充直觉和例子；对于已经掌握基础的人，则可以直接进入形式化定义、推导和应用。

更重要的是，学习路径应该随着理解变化而变化。学习者一旦掌握了某个前置概念，原本困难的内容可能就变得容易；如果某个基础环节没有真正理解，系统也应该及时回退，而不是机械地继续推进。

第三步：Teach，围绕理解边缘进行教学#

在教学阶段，AI 不只是输出一段解释，而是要不断判断“下一步讲什么最合适”。这要求它把讲解、提问、举例和练习结合起来。

一个好的教学循环可能是：先用简洁的语言解释概念，再让学习者用自己的话复述；接着给出一个略有变化的例子，检查理解能否迁移；最后根据回答决定继续深入、换一种说法，还是回到前置知识。

这个循环的核心不是让学习者获得更多文字，而是让系统获得更多反馈。每一次回答都在帮助 AI 更新对学习者状态的判断。

所以，持续反馈并不是教学结束后的附加测试，而是教学本身的一部分。没有反馈，个性化只是一种表面上的称呼；有了反馈，教学路径才真正具备适应性。

好的学习路径，也需要设计情绪曲线#

学习不只是信息输入和答案判断，也是一段持续变化的情绪体验。刚接触新主题时，好奇心可以帮助学习者投入；遇到暂时无法解决的问题时，适度的挫败感能够提示自己需要补足某个环节；解决问题后的满足感，则会强化继续学习的动力。

因此，AI 教师不应该只追求题目越来越难，也不能让学习者一直停留在舒适区。失败太多会让人沮丧，挑战太少又会让人感到无聊。更合理的路径，是根据学习者的状态调整挑战强度，在“我还不会”和“我能够学会”之间保持张力。

这意味着系统需要关注的不只是答对率，还包括学习者是否连续受挫、是否长时间没有获得进展感，以及是否已经因为任务过于简单而失去兴趣。一次适时的提示、一个更容易进入的例子，或者一道能够快速建立信心的练习，都可能让学习重新启动。

学习不止一种目标#

学习也不是单一的“理解知识”。它至少包含几个相互连接的方面。

发现：意识到一个问题、概念或知识领域的存在，知道自己接下来可以探索什么。
理解：建立心智模型，能够解释概念为什么成立，以及它和其他知识如何连接。
练习：通过重复和反馈形成掌握，提升准确率、熟练度和解决问题的速度。
应用：把知识放进真实情境，在具体任务中形成判断、视角和经验。

这几个方面不能完全互相替代。读懂一个概念，不代表能够快速使用它；做对几道练习，也不代表能够在陌生场景中迁移；知道一个领域存在，更不等于已经形成了可操作的理解。

所以，AI 在规划学习路径时，应该先判断学习者当前缺少的是哪一层能力。如果目标是建立整体认识，就应该安排探索和概念连接；如果目标是提高熟练度，就需要更多有梯度的重复练习；如果目标是解决实际问题，就应该提供案例、项目和开放性任务。

只有把这些目标组合起来，学习才不会停留在“看过”和“答对”的层面，而会逐渐转化为真正能够调用的能力。

测验之外：让反馈变成不同类型的练习#

测验适合用来探查理解状态，但它不应该成为 AI 教师唯一的输出形式。不同的学习目标，需要不同的学习材料和反馈方式。

对于需要记忆的事实、术语和关键定义，可以使用闪卡。闪卡的价值不在于把内容压缩成问答，而在于通过间隔重复，让学习者在即将遗忘时再次主动回忆。

对于需要形成熟练度的技能，可以设计重复练习。题目应该有清晰的梯度，并逐步提高速度要求，让学习者不仅知道怎么做，也能够更加准确、稳定地完成。

对于需要理解和表达的内容，则可以要求学习者解释概念、比较两个观点、指出例子的边界，或者用自己的话重建一段推理。这样的练习比单纯选择正确答案更能暴露心智模型中的缺口。

实际应用还需要另一类任务：案例分析、模拟决策、小型项目，以及带有不完整信息的问题。它们能够检验学习者是否可以把知识迁移到新情境中，并积累课本无法直接提供的经验。

因此，一个完整的 AI 学习系统，应该能够在讲解、闪卡、测验、重复练习、解释任务和真实应用之间切换。它输出的不是一串内容，而是一组围绕学习目标组织起来的活动。

学习中的隐性成本：信任也会消耗认知资源#

学习者通常会把注意力放在知识内容上，却容易忽略另一个重要成本：信任成本。

当我们同时使用多个老师、多个课程和多个资料库时，需要不断判断它们是否可靠、观点是否冲突、术语是否一致、哪种说法更值得采用。这些判断本身会消耗认知资源，并且可能打断对知识的深入理解。

从心理资源优化分配（Optimized Allocation of Mental Resources）的角度看，学习者应该尽量把精力放在材料本身，而不是放在资料管理和来源比较上。

这并不意味着学习者只能接受单一观点。更合理的方式是：由一个值得信任的教学界面，承担资料筛选、观点整合和冲突解释的工作，然后以适合个人理解水平的方式传递给学习者。

一个老师，不等于一个来源#

“只使用一个老师，会不会失去多视角？”这是一个自然的担忧。

但单一的教学界面，并不意味着背后只有一个知识来源。AI 可以先收集教材、论文、课程和其他可靠资料，再比较它们的观点，识别分歧，最后把多种视角组织成一条适合当前学习者的解释路径。

可以把它想象成这样：老师阅读了多个来源，理解它们各自的侧重点，然后面对面地为你讲解。你不需要直接面对一堆互相独立的资料，而是先获得一份经过整理、能够继续追问的知识地图。

当然，这种模式仍然需要工程化的信任机制。AI 应该尽可能说明知识来源，在存在争议时明确指出不确定性，在无法确认时承认不知道，而不是用流畅的表达掩盖错误。

结语：AI 教师的关键是适配，而不是生成#

AI 辅助学习最有价值的地方，不在于它能一次生成多少内容，而在于它能否围绕一个具体的人持续调整教学。

一个可信的 AI 教师系统，至少需要完成三个动作：先探查学习者当前理解到哪里，再规划一条合适的学习路径，最后通过教学、练习和多种反馈不断更新判断。这就是 Probe-Plan-Teach 的基本循环。

在这个循环之外，它还需要设计合适的情绪节奏，兼顾发现、理解、练习和应用，并根据不同目标提供闪卡、重复练习、解释任务和真实案例。AI 可以聚合多种知识来源，但最好通过一个稳定、透明、可追问的界面把这些活动组织起来。

最终，理想的学习体验不是“AI 替我学习”，而是“AI 让我始终在最适合自己的理解边缘学习”。当系统真正理解我已经会什么、还缺什么，以及下一步最值得理解什么时，学习才可能从资料堆积，转变为一场持续推进的对话。

在 Linux 服务器上使用 opencode 的正确方式

Mon, 24 Aug 2026 00:00:00 GMT

我一开始想把本地的工作流搬到服务器上。装好 Linux，SSH 上去，直接在服务器里干活。

我当时想要什么#

我想要的布局很简单：左边敲代码，右边跑 opencode，用 tmux 把两个终端分开。

我还希望 opencode 能尽量自己完成任务，不要每一步都等我确认。为了少确认几次，我做了个 opencodeskip，让它直接调用 opencode --auto。

`tmux` 是真学了，但也真被 `Ctrl+C` 坑了#

为了这套用法，我顺手学了 tmux 最基本的操作。最常用的是：

1
Ctrl+b，然后按 %

这个快捷键能把窗口一分为二，左边放代码，右边跑 opencode。刚开始用时，我觉得这个安排挺合理。

坑也从这里开始。我以前在 Windows 上习惯用 Ctrl+C 复制文字，到了 Linux 里还是会下意识按它。结果文字没复制到，服务先被我中断了。明明只是想拿一段输出，最后还得重新处理进程。

`opencodeskip` 这件事#

我在 Windows 本机上本来就有一个脚本：

Terminal window

1
@echo off
2
opencode --auto %*

所以我在 Linux 上也照着做了一个等价版本：

1
#!/usr/bin/env bash
2
exec opencode --auto "$@"

我把它放到 ~/.local/bin/opencodeskip，加上执行权限，想着以后可以像在本地一样直接调用。它只做一件事：把参数转给 opencode --auto，省掉一些确认。

真正让我崩溃的是服务器太小#

我用的是阿里云送的 2核2G 服务器，内存实在太紧。刚开始我以为跑一个 opencode 应该没问题，实际很快就发现不是这么回事。

只要我开两个 opencode，服务器就开始卡，甚至直接死掉，最后只能重启。

我原本想做的是远程协作，结果变成了远程把服务器折腾死。

退出 opencode 之后，麻烦也没有马上结束：

Ctrl+C 后子进程残留
网络一卡，TUI 直接卡死
服务器资源占用下不来
环境版本冲突
会话丢失

我重新运行 opencode 时，服务器还可能再次卡死。用着用着就得先救火，原本的工作反而没推进多少。

`zshrc` 这次也把我坑得不轻#

我还试着让 opencode 帮我装几个 zsh 插件，想把远程 shell 调整得顺手一点。结果它写配置时，直接覆盖了原来的 ~/.zshrc。不是追加，是整份覆盖！！！

终端样式、别名和原来的配置全没了。

更烦的是，之前弄好的 opencodeskip 也不见了。服务器一出错，修复就变得很麻烦：配置没了，命令没了，插件没了，环境还不稳定。每一项单独看都不算大事，叠在一起就够折腾了。

到这时我才意识到，问题不在于要不要放权给 opencode，而在于这台服务器根本扛不住这种用法。

后来我换了个做法#

我最后还是改成本地运行 opencode，通过 SSH 操作服务器。对这台 2核2G 的机器来说，这样省事得多，也不容易因为进程残留、TUI 卡顿或配置覆盖反复救火。

从 HTML 到 Vite：现代前端开发到底解决了什么问题？

Mon, 17 Aug 2026 00:00:00 GMT

前言#

前端开发并不是一开始就复杂的。

最开始，我们只需要写 HTML、CSS 和 JavaScript，就能做出一个可以运行的网页。

但随着项目变大，文件会越来越多，代码之间的依赖关系会越来越复杂，本地开发、上线构建、浏览器缓存等问题也会陆续出现。

这篇文章就从一个普通网页的组成讲起，一步步说明：为什么现代前端需要模块化，为什么需要构建工具，以及 Vite 到底解决了什么问题。

从最简单的网页开始#

一个普通网页通常由三部分组成：HTML、CSS 和 JavaScript。

HTML 负责页面结构，CSS 负责页面样式，JavaScript 负责交互逻辑。

一个很小的页面，可以把它们都写在同一个 HTML 文件里；但项目稍微变大，这个文件就会越来越难维护。

所以更常见的做法，是把它们拆成不同文件：

1
<link rel="stylesheet" href="style.css" />
2
<script src="main.js"></script>

这样做之后，结构、样式和逻辑被分开了，代码确实更清晰。但新的问题很快出现：当 JavaScript 文件越来越多时，脚本的加载顺序会变得非常重要。

比如 a.js 里定义了一个变量，b.js 里要使用它，那么 a.js 就必须写在 b.js 前面。顺序一旦错了，页面运行时就可能报错：变量不存在、函数未定义。

如果项目里只有两三个脚本，这个问题还可以靠人脑记住。可如果项目里有几十个甚至上百个 JS 文件，手动维护它们的引用顺序就会非常痛苦。

模块化：让文件之间的关系写清楚#

为了解决这个问题，现代前端引入了一个非常重要的基础能力：模块化。

模块化的核心思想是：每个文件只暴露自己想让外部使用的内容，其他文件需要什么，就显式地导入什么。

例如：

utils.js

1
export function add(a, b) {
2
  return a + b
3
}

main.js

1
import { add } from './utils.js'
2

3
console.log(add(1, 2))

这样一来，文件之间的依赖关系就不再依靠 HTML 里的 <script> 顺序来维持，而是直接写在 JavaScript 代码里。

这就是 ES Modules，也就是我们常说的 ESM。export 负责导出，import 负责导入。

模块化带来的第一个变化：不能再直接双击打开 HTML#

使用普通 <script> 标签时，很多简单页面可以直接双击 HTML 文件运行，也就是通过 file:// 协议打开。

但如果你使用了 ESM：

1
<script type="module" src="main.js"></script>

情况就不一样了。

浏览器在加载模块时，会按照更严格的规则处理文件请求。通过 file:// 打开页面时，模块之间的导入很容易因为同源策略或 CORS 限制而加载失败。

所以，使用模块化之后，我们通常不能再依赖“直接双击 HTML 文件”来开发页面，而是需要通过一个本地 HTTP 服务来访问页面。

也就是说，页面应该通过类似这样的地址打开：

1
http://localhost:5173

而不是：

1
file:///C:/project/index.html

项目变大后，还会遇到哪些问题？#

到这里，我们其实已经从“写几个静态文件”进入了“现代前端项目”的世界。

这个阶段通常会遇到三个典型问题。

1. 本地开发需要一个服务器#

浏览器中的原生 ESM 开发通常应通过 HTTP 服务访问。如果每次修改代码后，都要手动上传到服务器再刷新页面，开发效率会非常低。

理想的开发体验应该是：在本地启动一个服务器，修改代码后浏览器自动刷新，甚至只更新变动的部分。

2. 上线时不能让浏览器请求太多零散文件#

开发阶段，我们希望文件拆得清楚，方便维护。

但上线之后，如果页面需要请求大量 CSS 和 JS 文件，首屏加载可能会变慢。虽然现代浏览器和 HTTP/2 已经缓解了这个问题，但生产环境仍然需要压缩、拆分和优化资源。

3. 浏览器缓存可能导致用户拿到旧文件#

浏览器会缓存 JS、CSS、图片等静态资源。这样可以加快第二次访问速度，但也会带来一个问题：代码明明已经更新了，用户浏览器里却还在使用旧文件。

一个常见解决方案是给文件名加上 hash，也叫文件指纹。

例如：

1
main.8d3f4a1c.js
2
style.6a91b2ef.css

只要文件内容发生变化，hash 就会变化，文件名也会变化。浏览器会把它当成一个新文件重新下载。

Vite：现代前端开发的基础工具#

为了解决上面这些问题，我们会引入构建工具。现在非常常用的一个构建工具，就是 Vite。

需要注意的是，Vite 不是 React、Vue 这种 UI 框架。它不负责规定页面怎么写，而是负责开发服务器、模块处理和生产构建。

Vite 主要做两类事情：开发阶段提升效率，生产阶段优化资源。

开发阶段：启动本地服务器#

Vite 会在本地启动一个开发服务器。你可以通过 http://localhost:5173 访问项目，而不是直接双击 HTML 文件。

这样就解决了 ESM 在 file:// 协议下的加载问题。

同时，Vite 还支持热更新，也就是 HMR。修改代码后，浏览器可以快速看到变化，不需要你手动重新部署。

生产阶段：打包、压缩、加文件指纹#

开发时，我们希望代码拆得细，文件职责清楚。

上线时，我们希望资源更适合浏览器加载。Vite 在构建生产版本时，会对代码进行打包、压缩和优化，并为输出文件生成带 hash 的文件名。

最终生成的文件通常会放在 dist 目录中。这个目录里的内容，才是要部署到服务器上的生产版本。

为什么使用 Vite 前要安装 Node.js？#

Vite 本质上是一个运行在 Node.js 环境里的前端工具。

JavaScript 原本主要运行在浏览器里，用来操作页面。但如果我们想在浏览器之外运行 JavaScript，比如执行构建工具、启动开发服务器、安装第三方库，就需要 Node.js。

你可以把 Node.js 理解成“让 JavaScript 在电脑本地运行的环境”。

安装 Node.js 后，可以在终端里检查版本：

Terminal window

1
node -v
2
npm -v

如果能看到版本号，就说明安装成功了。

这里的 npm 是 Node.js 自带的包管理工具。它的作用类似于 Python 里的 pip，用来安装和管理 JavaScript 生态里的第三方库。

如何在项目里安装 Vite？#

进入项目文件夹后，先初始化项目：

Terminal window

1
npm init -y

执行后，项目里会出现一个 package.json 文件。它用来记录项目名称、版本、脚本命令、依赖库等信息。

然后安装 Vite：

Terminal window

1
npm install -D vite

这里的 -D 表示把 Vite 安装为开发依赖，也就是写入 devDependencies。

所谓“开发依赖”，不是说它只能安装在你自己的电脑上，而是说它只在开发和构建阶段需要。

如果选择在服务器上执行 npm run build，服务器在构建阶段也需要安装 Vite，所以这时要安装 devDependencies。默认执行 npm install 会安装它们。

但网站真正运行起来以后，浏览器访问的是 dist 里的静态文件，Nginx 只负责把这些文件返回给浏览器，并不需要继续运行 Vite。

安装完成后，项目里通常会多出两个东西：

1
node_modules/
2
package-lock.json

安装 Vite 后，项目目录里出现 package-lock.json 和 node_modules

node_modules 是第三方库实际存放的位置。Vite 以及 Vite 依赖的其他库，都会安装在这里。

node_modules 中除了 Vite，还会包含它依赖的其他包

package-lock.json 用来锁定依赖版本，保证其他人安装项目依赖时，尽量得到一致的结果。

补充一下，如果是从零创建一个新项目，也可以直接使用 Vite 官方脚手架：

Terminal window

1
npm create vite@latest

它会帮你生成基础项目结构。本文使用 npm init 和 npm install -D vite，是为了更清楚地说明 Vite 是如何作为项目依赖被安装进来的。

Vite 命令从哪里来？#

安装 Vite 后，node_modules/.bin 目录里会出现可执行命令。

在 Windows 下，你可能会看到类似这样的文件：

1
node_modules\.bin\vite.cmd

它就是本地项目里的 Vite 命令。

node_modules/.bin 里的 vite.cmd、vite.ps1 等可执行入口

不过实际开发中，我们通常不会手动去执行这个路径，而是把命令写进 package.json 的 scripts 里。

例如：

1
{
2
  "scripts": {
3
    "dev": "vite",
4
    "build": "vite build",
5
    "preview": "vite preview"
6
  }
7
}

之后就可以这样使用：

Terminal window

1
npm run dev
2
npm run build
3
npm run preview

npm run dev 用来启动本地开发服务器。启动成功后，终端会显示本地访问地址，例如 http://localhost:5173/。

Vite 开发服务器启动成功后，会显示本地访问地址

npm run build 用来生成生产环境文件。

npm run preview 用来在本地启动一个服务器，检查构建后的生产版本是否正常；它不是正式的生产服务器。

补充：构建后的 dist 如何部署到服务器？#

一种常见做法是：服务器拉取源码后，在服务器上安装依赖并执行构建，而不是把 dist 提交到 Git 仓库。

具体来说，Git 仓库里只保存项目源码和配置文件，dist 和 node_modules 都放进 .gitignore。

node_modules 不提交，是因为它体积很大，而且可以根据 package.json 和 package-lock.json 重新安装。

dist 不提交，是因为它是构建产物，可以随时通过源码重新生成。

所以一次典型的服务器部署流程是：

Terminal window

1
git pull
2
npm install
3
npm run build

注意：如果服务器负责执行 npm run build，就不能在构建前只安装 production 依赖。因为 Vite 在 devDependencies 中，构建阶段仍然需要它。

执行完 npm run build 后，服务器上会生成新的 dist 目录。

然后在 Nginx 中把网站根目录指向这个 dist 文件夹，并把入口文件设置为 index.html。

例如：

1
server {
2
  listen 80;
3
  server_name example.com;
4

5
  root /var/www/my-project/dist;
6
  index index.html;
7
}

这样浏览器访问网站时，Nginx 返回的就是 Vite 构建后的生产文件。

如果后续项目使用前端路由，例如 React Router，还需要让 Nginx 在找不到具体文件时回退到 index.html。

总结#

现代前端开发并不是一开始就复杂的。它是项目规模变大后，为了解决实际问题一步步演化出来的。

最开始，我们只需要 HTML、CSS 和 JavaScript。

后来，文件越来越多，手动维护脚本顺序变得困难，于是有了模块化。

模块化让依赖关系更清楚，但也要求我们通过 HTTP 服务来开发页面，于是需要本地开发服务器。

项目上线时，还需要打包、压缩、文件指纹和缓存处理，于是构建工具就变得非常重要。

Vite 解决的正是这些问题：开发时提供快速的本地服务器和热更新，上线前生成优化后的生产资源。

所以，理解 Vite 的关键不是记命令，而是理解它为什么出现：它是在帮我们把“适合开发的代码”，转换成“适合上线的资源”。

学完 Vite 之后，下一步学什么#

学到这里，我们已经解决了一部分“工程化”的问题。

Vite 帮我们解决的是开发和构建：本地服务器、模块化、热更新、打包、压缩、文件指纹。

也就是说，Vite 主要回答的是：

1
项目怎么开发？
2
代码怎么组织成模块？
3
上线前怎么构建成生产资源？

但 Vite 并不会直接解决“页面本身如何组织”的问题。

当页面越来越复杂时，我们会遇到新的麻烦：按钮、表单、列表、弹窗、用户状态、加载状态都混在一起。如果继续手动操作 DOM，代码会很快变得难以维护。

这时就需要 React。

React 是一个用于构建用户界面（UI）的 JavaScript 库，也常被称为前端框架；它的核心思想是用组件来组织页面。

React 关注的是另一个层面：如何把页面拆成组件，如何让数据传入组件，如何让状态变化后页面自动更新。

所以，Vite 和 React 解决的是两个不同问题：

1
Vite：解决项目开发、构建、部署的问题
2
React：解决页面组织、数据驱动、状态更新的问题

也正因为如此，学完 Vite 之后，继续学习 React 是很自然的一步。

这条现代前端学习路线可以继续往下走：

1
HTML/CSS/JS
2
→ Vite
3
→ React（或 Vue、Svelte 等）
4
→ Next.js 等应用框架

FastAPI初识&Python 装饰器学习

Sat, 15 Aug 2026 00:00:00 GMT

从 FastAPI 的 @app.get() 出发，拆开看看 Python 装饰器到底在干什么。

前言#

我一开始是从 FastAPI 的 @app.get() 产生疑问，然后顺着“它到底在修饰谁”“为什么这样写”“装饰器什么时候执行”“带参数装饰器又是什么”这条线，一步一步把 Python 装饰器弄懂。

这篇整理记录的是我的学习过程，先把思路走通，再回头看结论。

1. 最初疑问：FastAPI 路由装饰器#

其中的代码：

1
@app.get("/api/profile")
2
def get_profile():
3
    return profile

疑问点 1：`@app.get()` 和下方 `def` 是不是绑定在一起？#

结论：是的，装饰器只修饰紧随其后的函数。它们在语法上必须连在一起，中间不能插入其他代码。

疑问点 2：谁装饰谁？#

@app.get("/api/profile") 装饰的是函数 get_profile。

疑问点 3：装饰器到底有什么用？#

它的作用是给普通函数打上“角色标记”，告诉框架：

这个函数用来处理 GET /api/profile 的网络请求。

等价的原生写法可以理解为：

1
def get_profile():
2
    return profile
3

4
app.add_api_route(path="/api/profile", endpoint=get_profile, methods=["GET"])

所以装饰器本质上是语法糖：把“路径注册”和“业务函数”写在一起，让代码更紧凑、更易读。

2. 切入基础：自定义装饰器（计时器示例）#

示例代码：

1
import time
2

3
def timer(function):
4
    def wrapper():
5
        time_start = time.time()
6
        function()
7
        time_end = time.time()
8
        cost_time = time_end - time_start
9
        print("花费时间：{}秒".format(cost_time))
10
    return wrapper
11

12
@timer
13
def func1():
14
    print('我是一个函数1')

关键疑问 1：函数内部为什么还能定义函数？#

Python 支持嵌套函数。内层函数可以使用外层函数传进来的变量，这就是闭包的典型表现。

这里可以这样拆：

timer：外层工厂函数
wrapper：包装函数，负责新增逻辑（计时）

关键疑问 2：看不见 `wrapper()` 调用，它是怎么运行的？#

把语法糖展开：

1
@timer
2
def func1():
3
    pass
4

5
# 等价于
6

7
def func1():
8
    pass
9

10
func1 = timer(func1)

执行过程可以分成三步：

代码加载阶段（定义时）：执行 timer(原始 func1)，生成 wrapper 函数对象；
变量覆盖：名字 func1 不再指向原始函数，而是指向 wrapper；
调用阶段：执行 func1()，实际上就是执行 wrapper()。

关键疑问 3：为什么是 `return wrapper`，不能写 `return wrapper()`？#

这两者完全不同：

return wrapper：返回函数对象本身，后续可以随时调用；
return wrapper()：立刻执行函数，返回执行结果（大多是 None）。

错误示范：

1
def deco(func):
2
    def inner():
3
        print("包装启动")
4
        func()
5
    return inner()  # 当场执行 inner，返回 None
6

7
@deco
8
def demo():
9
    print("demo执行")
10

11
demo()  # 报错 TypeError: 'NoneType' object is not callable

3. 随堂测试复盘：易错的时序考点#

考题 1#

1
def deco(func):
2
    def inner():
3
        print("开始")
4
        func()
5
        print("结束")
6
    return inner
7

8
@deco
9
def hello():
10
    print("Hello")
11

12
hello()

输出：

1
开始
2
Hello
3
结束

理解方式：hello = deco(hello)，调用 hello() 时实际执行的是 inner()。

考题 2：时序大坑#

1
def deco(func):
2
    print("进入deco")
3
    def inner():
4
        print("inner运行")
5
        func()
6
    return inner
7

8
@deco
9
def test():
10
    print("执行test本体")
11

12
print("====分割线====")
13
test()

正确输出顺序：

1
进入deco
2
====分割线====
3
inner运行
4
执行test本体

核心知识点：@ 装饰器在函数定义阶段就执行外层代码，不等你调用函数。

4. 知识迁移到 FastAPI#

回到最开始的代码：

1
@app.get("/api/profile")
2
def get_profile():
3
    return profile

它可以展开成：

1
def get_profile():
2
    return profile
3

4
# 1. app.get 先执行，得到一个装饰器
5
decorator = app.get("/api/profile")
6

7
# 2. 使用装饰器包装原始函数
8
get_profile = decorator(get_profile)

带参数的装饰器：#

app.get("路径") 先传入配置；
然后返回一个专属装饰器；
再由这个装饰器去包装业务函数。

执行流程#

项目启动加载代码：只是在注册路由表；
浏览器发起 HTTP 请求访问接口时，FastAPI 自动调用包装后的函数；
框架自动把 return 的字典转成 JSON，并封装成 HTTP 响应。

我最后记住的是，装饰器的核心就是 @deco 等价于 f = deco(f)。它不是在改原函数的代码，而是把原函数交给另一个函数包一层，再把新的函数返回回来。

【Claude_Code_CLI安装】代理配置-本地模型-插件生态

Sat, 23 May 2026 00:00:00 GMT

1 前言#

最近在使用Claude Code (简称 cc )帮助我进行日常学习、项目开发，本文记录下 Claude Code CLI 的安装、DeepSeek 模型配置、llama.cpp 本地模型内网穿透后进行公网连接的操作，最后简单提及下 skill、plugin 等功能的安装，后续也会更新下 cc 的一些进阶操作。

2 安装#

先安装 Git 与 Node.js。

Terminal window

1
# 国内用户（winget 源）
2
winget install Anthropic.ClaudeCode
3

4
# 官方渠道（npm 全局安装）
5
npm install -g @anthropic-ai/claude-code

安装完成后，在终端输入 claude 即可启动。

3 `cc switch` 多模型配置切换#

下载：CC Switch

cc switch 用于在多个模型配置之间快速切换，并对齐模型所需格式。

4 配置 DeepSeek 兼容端点#

Claude Code 默认走 Anthropic 官方 API，但也可以通过自定义端点接入 DeepSeek 等兼容模型，降低成本。

4.1 获取 API Key#

前往 DeepSeek 开放平台申请 API Key，然后在 Claude Code 中配置。

4.2 配置自定义端点#

使用 cc switch 创建一套新配置，填入 DeepSeek 的 API 地址和 Key 即可。

注意：DeepSeek 兼容的是 OpenAI API 格式，Claude Code 内部已做适配，直接使用社区提供的端点地址即可。

点击获取模型列表，再点击一键设置即可记得勾选1M，表示可以使用1百万token上下文，当然前提是你的模型支持(比如deepseek)

5 接入本地模型（llama.cpp）#

llama.cpp 默认提供的是 OpenAI 兼容 API，而 Claude Code 走的是 Anthropic 协议。直接在 settings.json 里填 llama.cpp 的地址是不行的，需要配合 cc switch 的自定义端点功能来桥接。

5.1 内网穿透（ngrok）#

使用 ngrok 进行内网穿透，下载客户端即可使用

如果 llama.cpp 跑在本地，想让外网也能访问（比如在另一台机器上用 Claude Code），可以用 ngrok 做内网穿透，把本地端口暴露到公网：

Terminal window

1
ngrok http 8080

5.2 在 Claude Code 中连接 llama.cpp#

配置步骤如下：

如果 llama.cpp 没有配置 API Key，cc switch 处的 API Key 可以随意填写，不会校验。
输入请求地址后，点击管理与测速，测试是否连通。
点击高级选项展开。
点击获取模型列表（上方弹窗会显示获取到的模型数量）。
在模型下拉列表中选择你的模型。
点击一键设置。
保存配置。

注意：请保持 API 格式与认证字段不变，不要随意修改。

配置完成后，在任意文件夹打开终端输入 claude，测试是否正常启用。

5.3 切换模型#

在 cc switch 界面中，你可以随时在不同配置之间切换——远程大模型干活，本地小模型摸鱼，灵活选择。

5.4 缺点#

存在这样一种情景，我需要同时使用多家大模型，但是ccswitch只能选择启用一个供应商。

而且由于目前deepseek v4仅为文本推理llm，不具备图片理解能力，导致我必须额外配置一个具有视觉的大模型，此时我就必须使用python自己写一个网关脚本，用于对齐agent要求的格式并连接上我视觉模型，当然我们可以将其配置成全局skill，当需要视觉理解时进行调用。

5.5 CC switch实际修改配置#

cc switch实际就是建立网关，将baseurl改成自己的端口，再填写供应商的api调用地址和映射模型进行模型调用

6 Skill、Plugin、Agent 扩展#

Claude Code 的真正威力在于可扩展生态。通过插件市场，你可以安装社区提供的 Skill、Plugin 和 Agent，极大扩展能力边界。

6.1 添加市场#

首先添加 Anthropic 官方市场：

1
/plugin marketplace add anthropics/skills

市场地址：https://github.com/anthropics/skills

6.2 浏览与安装#

添加市场后，输入 /plugin 即可浏览所有可用插件。按需安装，最后执行一次插件重载/reload-plugin即可生效。

安装完成后，右下角状态栏会显示各服务的可用状态。如果某个 MCP 服务启动失败或需要官方验证，也会有相应提示，方便排查。

7 小结#

场景	方案
安装使用	官方地址或`winget`安装
模型接入	DeepSeek + `cc switch`
本地模型	llama.cpp 本地模型 + `cc switch`
扩展能力	Marketplace 安装 Skill / Plugin

折腾一圈下来，Claude Code CLI 就配置好了—— 一套工具，多种后端模型，按需切换。希望这篇笔记能帮你少走弯路。

【Git】项目协作开发教程

Tue, 19 May 2026 00:00:00 GMT

1 前言#

近期，我在 GitHub 平台参与项目协同开发的过程中，系统掌握了规范的 Git 操作流程。从遵循 Conventional Commit 规范撰写提交信息，到将代码提交至 Fork 后的个人仓库，再到通过 Pull Request（PR）向上游原仓库贡献代码，每一个环节都经过实践打磨，逐步形成了标准化的操作习惯。为了梳理所学、方便后续查阅，同时也为有类似协作需求的开发者提供参考，特此整理这份 Git 操作指南，涵盖从基础配置到协作收尾的全流程，力求步骤清晰、重点突出、可直接使用。

2 Git 基础全局配置#

在使用 Git 前，需先配置全局用户名和邮箱，这是提交代码时的身份标识，仅需配置一次。

1
# 配置全局用户名（替换为你的 GitHub 用户名）
2
git config --global user.name "Celyn"
3

4
# 配置全局邮箱（替换为你的 GitHub 绑定邮箱）
5
git config --global user.email "1249140039@qq.com"

2.1 验证配置是否成功#

执行以下命令，查看已配置的用户名和邮箱：

1
# 查看用户名
2
git config user.name
3

4
# 查看邮箱
5
git config user.email

==注意==：请务必确认好本地 Git 用户配置是否生效。

小故事😢：我在实验室电脑执行 git push、提交 PR 时，由于疏忽检查，提交记录带入电脑里留存的其他用户信息，导致 pr 时对方被设为共同作者，并且在我 fork 的仓库中显示上传 commit的用户并不是自己。所以一定要提前核对清楚本地个人账号信息，不然你的辛苦付出最后反倒会为他人做了嫁衣。

注：pr 里面多了个不知名的 xxxu680

2.2 Git 的默认分支：`master` 还是 `main`#

Git 本地执行 git init 时，默认分支原本是 master；GitHub 后来将新建仓库的默认分支改成了 main。因此，GitHub 会提示先统一本地分支名，再推送：

Terminal window

1
# 将当前本地分支强制重命名为 main
2
git branch -M main
3

4
# 首次推送，并关联本地 main 与远程 origin/main
5
git push -u origin main

如果不同 AI 开发工具初始化出的分支名不一致，通常是因为部分环境已配置 git config --global init.defaultBranch main，而部分环境仍使用 Git 原本的 master。

3 Git 代理配置（解决 GitHub 下载慢）#

若访问 GitHub 速度缓慢，可配置 7897 端口代理（本地常用代理端口），提升克隆、拉取代码的效率。

3.1 设置 7897 端口代理#

适用于 http/https 协议下载 GitHub

1
# 配置 HTTP 代理
2
git config --global http.proxy http://127.0.0.1:7897
3

4
# 配置 HTTPS 代理
5
git config --global https.proxy https://127.0.0.1:7897

3.2 验证代理是否生效#

1
# 查看 HTTP 代理
2
git config --global --get http.proxy
3

4
# 查看 HTTPS 代理
5
git config --global --get https.proxy

3.3 取消代理（备用）#

若无需代理，可执行以下命令清除配置：

1
# 取消 HTTP 代理
2
git config --global --unset http.proxy
3

4
# 取消 HTTPS 代理
5
git config --global --unset https.proxy

4 Fork 仓库与本地初始化#

4.1 Fork 上游仓库#

以==我参与开发的项目==为例：在 GitHub 上将目标仓库（如 jihe520/MathModelAgent）Fork 到自己的账号下，生成个人副本（如 HP-Patience/MathModelAgent）。

4.2 本地初始化仓库#

4.2.1 方式 1：下载 ZIP 压缩包后初始化#

下载 Fork 后仓库的 .zip 压缩包，解压到本地目录；
进入目录，执行 git init 初始化 Git 仓库；
执行 git branch -M main，确保本地分支名与远程默认分支一致；
关联自己的远程仓库（origin） 和上游原仓库（upstream）：

Terminal window

1
# 关联自己的 Fork 仓库（origin）
2
git remote add origin https://github.com/HP-Patience/MathModelAgent.git
3

4
# 关联上游原仓库（upstream，用于同步最新代码）
5
git remote add upstream https://github.com/jihe520/MathModelAgent.git

拉取最新代码到本地：

Terminal window

1
git pull origin main

4.2.2 方式 2：直接 Git Clone（推荐）#

git clone 会自动执行 git init + 关联远程仓库 + 下载完整最新代码，无需手动初始化和拉取：

Terminal window

1
# 克隆自己的 Fork 仓库到本地
2
git clone https://github.com/HP-Patience/MathModelAgent.git

5 分支开发与代码提交#

5.1 创建开发分支#

永远不要直接在 main 分支修改代码，需创建独立开发分支：

1
# 创建并切换到 myfeat 分支（分支名可自定义）
2
git checkout -b myfeat

5.2 修改代码与提交#

在 myfeat 分支完成代码修改后，提交变更：

1
# 添加所有修改文件
2
git add .
3

4
# 提交代码（添加清晰的提交信息）
5
git commit -m "feat: 完成XX功能开发"

==注意==：请使用 conventional commit 进行提交内容说明

6 同步上游更新与推送代码#

6.1 场景 1：上游仓库无新提交#

若原仓库（upstream）未更新代码，直接将本地分支推送到自己的远程仓库：

1
# 将 myfeat 分支推送到自己的 GitHub 仓库
2
git push origin myfeat

6.2 场景 2：上游仓库有新提交#

若原仓库已更新，需先同步上游代码，再推送，避免冲突：

切换回 main 分支，拉取上游最新代码：

1
git checkout main
2
git pull upstream main

切换回开发分支，将上游代码合并到当前分支：

1
git checkout myfeat
2
git rebase main

若出现 rebase 冲突，手动修改冲突文件后，继续 rebase；
无冲突或冲突解决后，强制推送到自己的远程仓库（必须加 -f）：

1
git push -f origin myfeat

6.3 提交 PR 到上游仓库#

进入自己的 GitHub 仓库（HP-Patience/MathModelAgent）；
点击 Compare & pull request，选择目标分支；
填写 PR 说明，提交后等待原仓库作者审核即可。

7 PR 被合并后：同步代码 + 清理分支#

当你的 PR 被上游仓库合并完成后，执行以下命令同步代码并清理无用分支：

1
# 1. 切换到本地 main 分支
2
git checkout main
3

4
# 2. 拉取上游最新代码（包含你刚合并的功能）
5
git pull upstream main
6

7
# 3. 删除本地已完成的开发分支（强制删除）
8
git branch -D myfeat
9

10
# 4.（可选）同步到你自己的远程 main 分支
11
git push origin main

7.1 常见问题提示#

代理报错 URL拼写可能存在错误：检查代理地址是否为 127.0.0.1:7897，确认本地代理服务已启动；
Rebase 冲突：打开冲突文件，删除冲突标记（<<<<<<</=======/>>>>>>>），保留正确代码后重新执行；
推送失败：确认分支权限，非 main 分支无需强制推送，更新上游后务必加 -f 强制推送。
删除分支报错：使用大写 -D 强制删除已合并完成的开发分支。

8 总结#

本文介绍了从配置 → 克隆 → 开发 → 提交 → 同步 → 提PR → 清理的完整闭环 Git 协作流程，所有命令都是团队开源协作最标准的用法，可以直接使用。

【n8n】基于WSL2-Docker完整部署教程

Tue, 12 May 2026 00:00:00 GMT

1 引言：为什么使用 n8n#

n8n 是一款开源免费低代码自动化工作流工具，支持可视化拖拽、对接海量第三方服务（数据库、企业微信、飞书、网盘、接口等），可自建部署、数据私有不托管，搭配 WSL2 + Docker 一键部署，轻量化不占用 Windows 主环境，方便日常自动化流程搭建、定时任务、数据同步等场景。

2 WSL 下载配置#

2.1 WSL 内核更新#

在 CMD/PowerShell 里输入：

Terminal window

1
wsl --update

等待自动下载安装 WSL2 内核，跑完就好了。

2.2 手动安装 Ubuntu22.04（清华镜像离线导入）#

使用清华镜像源进行下载，点击该链接后：如果你电脑是 Windows 64 位，下滑找到jammy-server-cloudimg-amd64-root.tar.xz下载即可

下载好后操作把文件放到：F:\wsl\，没有文件夹自行创建即可
接着打开 CMD 或者 PowerShell创建文件夹，输入：

Terminal window

1
mkdir F:\wsl\Ubuntu2204

接着导入安装，运行：

Terminal window

1
wsl --import Ubuntu-22.04 F:\wsl\Ubuntu2204 F:\wsl\jammy-server-cloudimg-amd64-root.tar.xz --version 2

等着跑完就行，几分钟搞定，直接装在 F 盘。

2.3 常见报错处理：#

2.3.1 开启系统必要功能（管理员 PowerShell 逐条执行）#

Terminal window

1
dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart
2
dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart
3
dism.exe /online /enable-feature /featurename:Hyper-V-Online /all /norestart

2.3.2 图形化检查 Windows 功能#

按下 Win + R 输入 optionalfeatures.exe 回车
查看是否勾选下面 3 个，若无则打勾：

✅ Windows 子系统用于 Linux
✅ 虚拟机平台
✅ Hyper-V（能看到就勾）

确定后重启电脑。

2.3.3 开启 CPU 虚拟化#

重启开机马上按 Del / F2 / F1 进 BIOS：

Intel 找：Intel VT-x 设为 Enabled
AMD 找：AMD-V / SVM Mode 设为 Enabled

保存退出重启。

2.3.4 重新执行导入命令#

Terminal window

1
wsl --import Ubuntu-22.04 F:\wsl\Ubuntu2204 F:\wsl\jammy-server-cloudimg-amd64-root.tar.xz --version 2

3 Docker下载与配置#

3.1 Docker Desktop下载#

Docker Desktop下载链接

3.2 Docker Resources#

3.2.1 Advanced 设置#

修改 Disk image location，把 Docker 存储路径迁移到非 C 盘。

3.3 WSL integration 配置#

开启对应 Ubuntu-22.04 的 WSL 集成，让 Docker 与 WSL 互通

3.4 Docker Engine 镜像加速配置#

粘贴以下完整配置，配置国内镜像源加速拉取：

1
{
2
  "builder": {
3
    "gc": {
4
      "defaultKeepStorage": "20GB",
5
      "enabled": true
6
    }
7
  },
8
  "experimental": false,
9
  "features": {
10
    "buildkit": true
11
  },
12
  "registry-mirrors": [
13
    "https://docker.1ms.run",
14
    "https://docker.xuanyuan.me",
15
    "https://registry-1.docker.io"
16
  ]
17
}

展开收起

配置后重启 Docker 生效。

4 n8n 部署与使用#

4.1 Docker 部署启动 n8n#

在bash中输入docker命令：

创建持久化数据卷

Terminal window

1
docker volume create n8n_data

启动 n8n 容器（时区设为上海、端口映射、数据持久化）

1
docker run -d ` --name n8n ` -p 5678:5678 ` -e GENERIC_TIMEZONE="Asia/Shanghai" ` -e TZ="Asia/Shanghai" ` -v n8n_data:/home/node/.n8n ` n8nio/n8n

访问地址

浏览器打开：http://localhost<5678>/

同时在docker desktop中的Containers中出现该容器

4.2 n8n 的webui界面操作#

5 参考文档：#

神经网络优化核心：鞍点而非局部极小值

Sun, 10 May 2026 00:00:00 GMT

1 前言#

当模型在训练集上损失居高不下，且增加模型复杂度后损失未降反升时，问题通常不在于模型 bias，而在于优化过程本身——梯度下降易在高维损失景观中被困于鞍点，本文结合 Hessian 矩阵与实验证据，梳理相关核心结论。

2 梯度下降收敛停滞的关键原因#

梯度下降过程中，当梯度∇L (θ)=0 时，损失函数值不再变化，优化陷入停滞。造成这一现象的原因并非仅为局部最小值点，还可能是鞍点，两者核心区别如下：

局部最小值点（local minimum point）：梯度为 0，且任意方向移动损失均增大，优化达到局部最优；
鞍点（saddle point）：梯度为 0，存在一对正交方向，沿其中一个方向移动损失增大，沿另一个方向移动损失减小，并非最优解，却会导致梯度下降停滞。

综上，局部最小值点与鞍点的梯度均为 0，这两类梯度为 0 的点统称为驻点。

那么当我们遇到梯度为 0 的驻点时，如何判断其是局部最小值点还是导致优化停滞的鞍点呢？此时需要引入 Hessian 矩阵进行判别：

3 Hessian 矩阵与二次型#

要判断一个临界点到底是什么，我们需要用到二阶泰勒展开，在临界点 θ′\theta'θ′ 附近近似损失函数：

L(θ)≈L(θ′)+12(θ−θ′)TH(θ−θ′)L(\theta) \approx L(\theta') + \frac{1}{2} (\theta - \theta')^T H (\theta - \theta')L(θ)≈L(θ′)+21(θ−θ′)TH(θ−θ′)

这里的 HHH 就是Hessian 矩阵，是由损失函数 L (θ) 各参数的二阶偏导数构成的对称方阵，用于刻画损失函数曲率，辅助判断驻点类型。

我们设 v=θ−θ′v = \theta - \theta'v=θ−θ′（移动方向），那么损失的变化就完全由二次项决定：

ΔL≈12vTHv\Delta L \approx \frac{1}{2} v^T H vΔL≈21vTHv

而根据特征向量的定义，对于 Hessian 的特征向量 uuu 和对应的特征值 λ\lambdaλ，我们有：

uTHu=λ∥u∥2u^T H u = \lambda \|u\|^2uTHu=λ∥u∥2

因为 ∥u∥2>0\|u\|^2 > 0∥u∥2>0，所以 uTHuu^T H uuTHu 的符号完全由特征值 λ\lambdaλ 决定：

λ>0\lambda > 0λ>0：沿 uuu 方向走，损失会变大（上坡）。
λ<0\lambda < 0λ<0：沿 uuu 方向走，损失会变小（下坡）。

这就是为什么我们可以用 Hessian 的特征值来判断临界点的类型。

4 收敛点的真实本质#

我们可以做一个简单的实验：重复训练同一个网络很多次，每次训练到收敛，然后计算每个临界点 Hessian 矩阵的正特征值比例（我们称之为 Minimum Ratio），并记录对应的训练损失。

我们能从实验结果中清晰地看到一个强规律：

左侧点群（Minimum Ratio 很低）：损失都很高（0.08-0.09），这些是典型的低维鞍点，有大量负特征值，模型困在这里根本没学好。
右侧点群（Minimum Ratio 很高）：损失都很低，这些点看起来像“局部极小值”，但它们的 Minimum Ratio 远小于 1，说明 Hessian 矩阵里仍然存在少量负特征值，本质上还是鞍点。

图中的文字 never reach a real "local minima" 直接点破了真相： 我们几乎永远无法到达数学上严格定义的局部极小值，只能停在这些高维鞍点上。

5 总结#

高维空间中，鞍点数量远多于局部极小值，是模型收敛的主要位置，且鞍点可进一步优化，并非优化终点；
驻点类型可通过 Hessian 矩阵特征值判断：所有特征值>0 为局部最小值点，正负特征值共存为鞍点；
可沿 Hessian 负特征值对应的特征向量方向，逃离劣质鞍点，继续降低损失；
优化的关键并非追求严格局部极小值，而是收敛到负特征值少、正特征值占比偏高的平缓优质临界点，这类点损失更低、泛化性能更好。

【IP地址防护】-预防WebRTC泄露

Sat, 02 May 2026 00:00:00 GMT

什么是 WebRTC 泄露（WebRTC Leak），如何预防#

WebRTC（Web Real-Time Communication）是浏览器提供的实时音视频与点对点数据通道技术。WebRTC 泄露 指的是在使用浏览器或某些应用时，WebRTC 的连接流程（ICE 候选交换）意外暴露了本地或真实公网 IP 地址，导致即便你在用 VPN/代理，目标网站或第三方仍可能看到你的真实 IP 地址或局域网地址，从而破坏隐私与匿名性。

WebRTC 泄露简要原理

建立 P2P 连接时，浏览器会通过 STUN/TURN server 获取 ICE candidates（候选连接地址），这些候选包括：
- host（本机局域网 IP）
- srflx（通过 STUN 获得的公网映射 IP）
- relay（通过 TURN 中继的地址）
如果浏览器本地或网页脚本暴露/发送了 host 或 srflx 类型的候选，第三方就可能获知本机真实 IP（包括局域网 IP 与公网真实 IP）。
VPN/代理通常只影响浏览器的普通 HTTP(S) 流量，但 WebRTC 的 STUN 请求可能绕过这些路径，从而暴露真实地址。

chrome需要安装扩展来避免WebRTC 泄露，推荐一个开源扩展 chrome扩展地址

使用 IPPure 检查 WebRTC 泄露情况#

安装前：#

IPPure链接地址

安装后：#

Reference：#

WebRTC解释

【cv-AI攻防】-Task1：赛题方案解读

Sat, 12 Oct 2024 00:00:00 GMT

步骤一：构建YOLO数据集#

由于比赛原始数据集较大，我们采样部分数据构建训练集和验证集：

1
if os.path.exists('yolo_seg_dataset'):
2
    shutil.rmtree('yolo_seg_dataset')
3

4
os.makedirs('yolo_seg_dataset/train')
5
os.makedirs('yolo_seg_dataset/valid')
6

7
def normalize_polygon(polygon, img_width, img_height):
8
    return [(x / img_width, y / img_height) for x, y in polygon]
9

10
# 采样训练集
11
for row in training_anno.iloc[:10000].iterrows():
12
    shutil.copy(row[1].Path, 'yolo_seg_dataset/train')
13

14
    img = cv2.imread(row[1].Path)
15
    img_height, img_width = img.shape[:2]
16
    txt_filename = os.path.join('yolo_seg_dataset/train/' + row[1].Path.split('/')[-1][:-4] + '.txt')
17
    with open(txt_filename, 'w') as up:
18
        for polygon in row[1].Polygons:
19
            normalized_polygon = normalize_polygon(polygon, img_width, img_height)
20
            normalized_coords = ' '.join([f'{coord[0]:.3f} {coord[1]:.3f}' for coord in normalized_polygon])
21
            up.write(f'0 {normalized_coords}\n')
22

23
 # 采用验证集
24
 for row in training_anno.iloc[10000:10150].iterrows():
25
    shutil.copy(row[1].Path, 'yolo_seg_dataset/valid')
26

27
    img = cv2.imread(row[1].Path)
28
    img_height, img_width = img.shape[:2]
29
    txt_filename = os.path.join('yolo_seg_dataset/valid/' + row[1].Path.split('/')[-1][:-4] + '.txt')
30
    with open(txt_filename, 'w') as up:
31
        for polygon in row[1].Polygons:
32
            normalized_polygon = normalize_polygon(polygon, img_width, img_height)
33
            normalized_coords = ' '.join([f'{coord[0]:.3f} {coord[1]:.3f}' for coord in normalized_polygon])
34
            up.write(f'0 {normalized_coords}\n')

展开收起

逐行代码分析#

好的，我们逐行分析这段代码，它的主要功能是将训练集和验证集的数据从原始数据集中复制到新的目录中，并将多边形的坐标标准化为相对坐标。

代码逐行分析#

1
if os.path.exists('yolo_seg_dataset'):
2
    shutil.rmtree('yolo_seg_dataset')

功能: 检查yolo_seg_dataset目录是否存在。如果存在，则使用shutil.rmtree删除该目录及其内容。shutil常用于文件与目录的处理。
目的: 确保每次运行代码时，数据集是干净的，没有旧的数据。

1
os.makedirs('yolo_seg_dataset/train')
2
os.makedirs('yolo_seg_dataset/valid')

功能: 创建两个新的子目录train和valid，用于存放训练集和验证集数据。
目的: 为之后的文件复制和标签文件创建所需的目录结构。

1
def normalize_polygon(polygon, img_width, img_height):
2
    return [(x / img_width, y / img_height) for x, y in polygon]

功能: 定义一个函数normalize_polygon，它接受一个多边形的坐标（列表形式），以及图像的宽度和高度。该函数返回归一化后的坐标，归一化的方式是将每个坐标除以图像的宽度和高度。
目的: ==将坐标转换为相对坐标，使其在不同尺寸的图像中具有一致性==。

1
# 采样训练集
2
for row in training_anno.iloc[:10000].iterrows():

功能: 遍历training_anno数据框的前10000行。iterrows()方法用于逐行迭代数据框，并返回行的索引和行的内容。
目的: 处理训练集中的前10000条数据。

1
    shutil.copy(row[1].Path, 'yolo_seg_dataset/train')

功能: 将当前行的图像文件从原始路径复制到yolo_seg_dataset/train目录。
目的: 将图像文件放入训练集目录中。

1
    img = cv2.imread(row[1].Path)
2
    img_height, img_width = img.shape[:2]

功能: 使用OpenCV读取图像文件，并获取其高度和宽度。
目的: 获取图像的尺寸，以便后续进行坐标归一化。

1
    txt_filename = os.path.join('yolo_seg_dataset/train/' + row[1].Path.split('/')[-1][:-4] + '.txt')

功能: 生成对应的文本文件名，该文件名是基于图像文件名生成的（去掉扩展名并添加.txt）。
目的: 为每个图像文件创建一个对应的标签文件。

1
    with open(txt_filename, 'w') as up:

功能: 打开或创建文本文件进行写入，使用with语句可以确保文件在写入完成后正确关闭。
目的: 准备写入归一化后的坐标数据。

1
        for polygon in row[1].Polygons:
2
            normalized_polygon = normalize_polygon(polygon, img_width, img_height)

功能: 遍历当前行的所有多边形坐标，调用normalize_polygon函数进行归一化。
目的: 将多边形的坐标转化为相对坐标。

1
            normalized_coords = ' '.join([f'{coord[0]:.3f} {coord[1]:.3f}' for coord in normalized_polygon])

功能: 这是一个列表推导式，用于遍历normalized_polygon中的每个坐标coord。每个coord都是一个包含两个元素的元组（(x, y)），表示一个点的坐标。
格式化:
- coord[0]:.3f：将coord中的第一个元素（x坐标）==格式化为小数点后三位的浮点数==。
- coord[1]:.3f：将第二个元素（y坐标）格式化为小数点后三位的浮点数。
结果: 列表推导式生成一个字符串列表，其中每个字符串都包含格式化后的坐标，例如：["0.123 0.456", "0.789 0.012"]。

1
            up.write(f'0 {normalized_coords}\n')

内容:
- '0 '：这是一个常量字符串，通常用于表示==类别标签==。在YOLO格式中，0可能表示某个特定的类别（例如，一个物体的类别，具体取决于数据集的类别定义）。
- up是一个文件对象，通过with open(...) as up:创建的。调用write方法将构建的字符串写入到文件中。
功能: 将归一化后的坐标写入文本文件。
目的: 保存标签信息，以便YOLO模型使用。

验证集处理#

接下来的代码与训练集处理相似，只是处理的是验证集数据。它从training_anno的第10000到第10150行进行迭代，重复上述步骤，复制图像到yolo_seg_dataset/valid目录，并创建相应的标签文件。

1
# 采用验证集
2
for row in training_anno.iloc[10000:10150].iterrows():
3
    shutil.copy(row[1].Path, 'yolo_seg_dataset/valid')
4

5
    img = cv2.imread(row[1].Path)
6
    img_height, img_width = img.shape[:2]
7
    txt_filename = os.path.join('yolo_seg_dataset/valid/' + row[1].Path.split('/')[-1][:-4] + '.txt')
8
    with open(txt_filename, 'w') as up:
9
        for polygon in row[1].Polygons:
10
            normalized_polygon = normalize_polygon(polygon, img_width, img_height)
11
            normalized_coords = ' '.join([f'{coord[0]:.3f} {coord[1]:.3f}' for coord in normalized_polygon])
12
            up.write(f'0 {normalized_coords}\n')

总结#

这段代码的主要目的是将多边形标注数据从原始数据集中提取出来，规范化并保存到新的训练集和验证集目录中，以供YOLO模型使用。通过归一化坐标，模型可以更好地适应不同尺寸的输入图像。

步骤二：写入YOLO配置文件#

1
with open('yolo_seg_dataset/data.yaml', 'w') as up:
2
    data_root = os.path.abspath('yolo_seg_dataset/')
3
    up.write(f'''
4
path: {data_root}
5
train: train
6
val: valid
7

8
names:
9
    0: alter
10
''')

逐行代码分析#

这一段代码的目的是创建一个名为 data.yaml 的配置文件，通常用于YOLO等深度学习模型的数据配置。我们来逐步分析这段代码的结构和含义。

代码解析#

1
with open('yolo_seg_dataset/data.yaml', 'w') as up:

功能: 使用 with open(...) as ...: 语句打开（或创建）一个名为 data.yaml 的文件，并以写入模式（'w'）打开。up 是一个文件对象，用于后续的写入操作。
上下文管理: 使用 with 语句可以确保文件在操作完成后自动关闭，避免文件未关闭导致的资源泄漏。

2. ==获取数据根路径==#

1
data_root = os.path.abspath('yolo_seg_dataset/')

功能: os.path.abspath(...) 返回给定路径的==绝对路径==。在这里，它将 'yolo_seg_dataset/' 转换为绝对路径并存储在 data_root 变量中。
示例: 如果当前工作目录是 /home/user/projects，那么 data_root 的值将是 /home/user/projects/yolo_seg_dataset。

3. 写入内容到文件#

1
up.write(f'''
2
path: {data_root}
3
train: train
4
val: valid
5

6
names:
7
    0: alter
8
''')

功能: 使用 write(...) 方法将格式化的字符串写入到 data.yaml 文件中。字符串的内容使用了多行字符串的语法（即用三个单引号包裹的字符串）。
内容解释:
- path: {data_root}: 写入数据集根路径的==绝对路径==。
- train: train: 指定训练数据的子目录名（==相对路径==）。
- val: valid: 指定验证数据的子目录名（==相对路径==）。
- names:: 这是一个字典，用于==映射类别ID到类别名称==。在这里，0 映射到类别名称 alter。

完整内容示例#

假设 data_root 的绝对路径为 /home/user/projects/yolo_seg_dataset，最终写入 data.yaml 文件的内容将类似于：

1
path: /home/user/projects/yolo_seg_dataset
2
train: train
3
val: valid
4

5
names:
6
    0: alter

总结#

这段代码生成了一个用于YOLO数据集配置的 data.yaml 文件，包含了数据集的根路径、训练和验证集的目录，以及类别的映射信息。该配置文件通常用于训练模型，帮助模型了解数据集的结构和类别定义。

步骤三：训练YOLO分割模型#

1
from ultralytics import YOLO
2

3
model = YOLO("./yolov8n-seg.pt")
4
results = model.train(data="./yolo_seg_dataset/data.yaml", epochs=10, imgsz=640)

逐行代码分析#

以下是对代码的逐行分析：

1
from ultralytics import YOLO

这行代码导入了 ultralytics 库中的 YOLO 类。
ultralytics 是一个用于目标检测的库，提供了易于使用的接口来训练和推理 YOLO 模型，尤其是 YOLOv8 模型。
YOLO 类是用于创建并管理 YOLO 模型的类，包括加载预训练模型、训练模型和进行推理。

1
model = YOLO("./yolov8n-seg.pt")

这行代码使用 YOLO 类创建了一个 model 实例。
YOLO("./yolov8n-seg.pt") 加载一个预训练的 YOLOv8 模型，该模型文件是 yolov8n-seg.pt。这是 YOLOv8 模型的小型版本（n 代表 nano纳米），同时具有分割功能（-seg 代表分割任务）。
通过这种加载方式，可以直接基于预训练模型进行进一步训练或推理。

1
results = model.train(data="./yolo_seg_dataset/data.yaml", epochs=10, imgsz=640)

model.train() 是 YOLO 模型的训练方法。
data="./yolo_seg_dataset/data.yaml" 指定了用于训练的数据集配置文件。data.yaml 文件通常包含训练集、验证集的路径，以及类别名称等信息。
epochs=10 指定模型要进行 10 个==训练周期==（epochs）。每个周期意味着模型将遍历完整的训练数据集一次。
imgsz=640 设置了输入图像的尺寸为 640 像素。YOLO 模型会将训练数据的图像调整到 640x640 的尺寸进行训练。

训练完成后，results 会包含训练过程中的结果和性能指标（如损失值、准确度等），这些结果可以用于评估模型的训练效果。

总结#

这段代码从 ultralytics 库中导入 YOLO 模型，加载了一个 YOLOv8 分割模型，并基于指定的数据集文件进行 10 个周期的训练，使用了 640x640 的图像输入尺寸。

步骤四：预测测试集#

1
from ultralytics import YOLO
2
import glob
3
from tqdm import tqdm
4

5
model = YOLO("./runs/segment/train6/weights/best.pt")
6
test_imgs = glob.glob('./test_set_A_rename/*/*')

1
Polygon = []
2
for path in tqdm(test_imgs[:]):
3
    results = model(path, verbose=False)
4
    result = results[0]
5
    if result.masks is None:
6
        Polygon.append([])
7
    else:
8
        Polygon.append([mask.astype(int).tolist() for mask in result.masks.xy])
9

10
import pandas as pd
11
submit = pd.DataFrame({
12
    'Path': [x.split('/')[-1] for x in test_imgs[:]],
13
    'Polygon': Polygon
14
})
15
submit.to_csv('track2_submit.csv', index=None)

展开收起

逐行分析代码#

这段代码使用预训练的YOLO模型来处理图像集，并将结果保存到CSV文件中。下面是逐行的分析：

1
from ultralytics import YOLO
2
import glob
3
from tqdm import tqdm

from ultralytics import YOLO: 从 ultralytics 库中导入 YOLO 类，这个类用于加载并使用预训练的 YOLO 模型进行推理和处理图像。
import glob: glob 模块用于文件操作，它可以根据特定的模式匹配文件路径。
from tqdm import tqdm: tqdm 模块用于显示进度条，常用于长时间运行的循环或任务中，帮助可视化处理进度。

1
model = YOLO("./runs/segment/train6/weights/best.pt")

这行代码加载了一个训练好的YOLO模型，权重文件位于 ./runs/segment/train6/weights/best.pt。这个模型是预训练的权重，专门用于图像分割任务。

1
test_imgs = glob.glob('./test_set_A_rename/*/*')

使用 glob.glob() 函数获取所有位于 ./test_set_A_rename/ 路径下的图像文件。
'*/*' 匹配所有子目录中的文件路径，因此它会抓取该目录下所有的图像路径，并存储在 test_imgs 列表中。

1
Polygon = []
2
for path in tqdm(test_imgs[:]):
3
    results = model(path, verbose=False)
4
    result = results[0]

Polygon = []: 初始化一个空列表 Polygon，用于存储每张图片的分割结果。
for path in tqdm(test_imgs[:]):: 通过 tqdm 包裹循环，遍历 test_imgs 中的每个图像路径，并显示进度条。
results = model(path, verbose=False): 调用模型对当前图片（path）进行推理，得到分割结果。verbose=False 表示不打印详细信息。
result = results[0]: YOLO 返回的结果可能包含多张图片（批处理），这里仅取第一个结果（当前处理的图片）。

1
if result.masks is None:
2
    Polygon.append([])
3
else:
4
    Polygon.append([mask.astype(int).tolist() for mask in result.masks.xy])

if result.masks is None:: 检查结果是否包含分割的掩码（masks）。如果没有分割掩码（即 result.masks 为 None），则向 Polygon 列表中添加一个空列表。
Polygon.append([mask.astype(int).tolist() for mask in result.masks.xy]): 如果存在分割掩码，将掩码的边界坐标（result.masks.xy）转换为整数并存储为 Python 列表的形式，然后将其添加到 Polygon 列表中。

==掩码（Mask）==在计算机视觉中是一个非常重要的概念，它通常用于表示图像中的特定区域。掩码的作用是突出或分离出图像中的某些部分（例如物体、背景等），便于后续的处理。掩码通常是一个与原始图像尺寸相同的二值化矩阵，每个像素点要么是 1（代表属于目标区域），要么是 0（代表不属于目标区域）。

在你的代码中，掩码（mask）与图像分割任务相关。模型返回的 mask 描述的是在图像中哪一部分属于分割出的对象。这些掩码可以是二值化的矩阵，也可以是其对应的轮廓坐标（多边形）。

1
import pandas as pd
2
submit = pd.DataFrame({
3
    'Path': [x.split('/')[-1] for x in test_imgs[:]],
4
    'Polygon': Polygon
5
})
6
submit.to_csv('track2_submit.csv', index=None)

import pandas as pd: 导入 pandas 库，用于处理数据并生成 CSV 文件。
submit = pd.DataFrame({...}): 创建一个 pandas 数据框 submit，包含两列：
- 'Path': 存储每张图像的文件名（通过 x.split('/')[-1] 从路径中提取文件名）。
- 'Polygon': 存储每张图像的分割结果（存储在 Polygon 列表中）。
submit.to_csv('track2_submit.csv', index=None): 将 submit 数据框保存为一个名为 track2_submit.csv 的 CSV 文件，index=None 表示不保存行索引。

总结#

这段代码使用YOLO模型处理一批图像，提取图像中的分割掩码边界（多边形），并将这些结果存储到一个CSV文件中。
tqdm 用来展示处理进度，pandas 则用来生成最终的提交文件（track2_submit.csv）。

使用 InternLM 构建个人 AI 助手：Prompt、RAG、Agent 与 XTuner 微调

Tue, 03 Sep 2024 00:00:00 GMT

这篇文章把四次相对独立的实践整理成一条完整路线：先用结构化 Prompt 约束模型，再用 RAG 补充外部知识，随后通过 Agent 连接工具，最后用微调固化稳定的行为与风格。

这四种技术并不是互相替代的关系。它们分别解决“如何表达任务”“如何获得知识”“如何执行动作”和“如何形成长期能力”四类问题。

能力路线#

层次	技术	主要解决的问题	适合优先使用的场景
任务表达	LangGPT / Prompt	输出不稳定、格式不统一、推理步骤不清晰	需求可以通过文字明确描述
外部知识	RAG / LlamaIndex	模型不知道私有资料或最新内容	文档问答、知识库检索
工具执行	Lagent	模型只能回答，不能搜索、计算或调用服务	需要调用工具完成多步任务
行为固化	XTuner	仅靠提示词难以长期保持风格或能力	有高质量训练数据且需求稳定

实际开发时，通常应该按表格从上到下逐层增加复杂度，而不是一开始就进行微调。

LangGPT：先让模型准确理解任务#

结构化提示词是成本最低、反馈最快的一层。下面保留当时针对浮点数比较问题的实践记录，并包含模型服务和 tmux 的基础操作。

前言#

在日常使用大模型时，我发现它经常在数字比对这类基础问题上出错，并且输出结果很不严谨。为了解决这个问题，我尝试使用Prompt Engineering，并在网上找到了一个开源的「结构化提示词框架」— LangGPT，以下是我的使用过程记录。

实现步骤#

step0：前期准备

创建虚拟环境->激活虚拟环境->安装必要包文件
创建项目路径->进入项目
安装必要软件，如tmux

step1：模型部署模型下载->部署模型为OpenAI server->图形化界面调用

step3：langgpt结构化提示词编写偷懒大法：GPTS有LangGPT提示词专家，用大模型生成即可

tmux使用#

tmux可以在终端中创建终端，将进程维持在后台。

所以当我们下载模型，使用tmux在后台下载时，即便我们断开ssh连接，下载也不会中断。

step1：部署模型为OpenAI server

tmux常见命令#

1.创建窗口命令：

PS：t表示target(目标)，用于指定会话、窗口或面板的名称

Terminal window

1
tmux new -t <session_name>

PS：创建完成后，运行下面的命令进入新的命令窗口(首次创建自动进入，之后需要连接)：其中a 是 attach 的简写

Terminal window

1
tmux a -t <session_name>

2.查看当前 tmux 会话：

Terminal window

1
tmux ls

3.连接到特定的 tmux 会话：

Terminal window

1
tmux attach -t <session_name>

将 <session_name> 替换为你要连接的会话的实际名称或编号。

4.杀死整个 tmux 会话：

Terminal window

1
tmux kill-session -t <session_name>

5.退出tmux:

Ctrl+B进入tmux的控制模式，然后按d退出窗口连接

模型部署#

进入命令窗口后，需要在新窗口中再次激活环境，命令参考0.1节。然后，使用LMDeploy进行部署，参考如下命令：

使用LMDeploy进行部署，参考如下命令：

Terminal window

1
CUDA_VISIBLE_DEVICES=0 lmdeploy serve api_server /share/new_models/Shanghai_AI_Laboratory/internlm2-chat-1_8b --server-port 23333 --api-keys internlm2

部署成功后，可以利用如下脚本调用部署的InternLM2-chat-1_8b模型并测试是否部署成功。

1
from openai import OpenAI
2

3
client = OpenAI(
4
    api_key = "internlm2",
5
    base_url = "http://0.0.0.0:23333/v1"
6
)
7

8
response = client.chat.completions.create(
9
    model=client.models.list().data[0].id,
10
    messages=[
11
        {"role": "system", "content": "请介绍一下你自己"}
12
    ]
13
)
14

15
print(response.choices[0].message.content)

展开收起

服务启动完成后，可以按Ctrl+B进入tmux的控制模式，然后按D退出窗口连接，更多操作参考。

作业：#

基础任务 (完成此任务即完成闯关)：

背景问题：近期相关研究发现，LLM在对比浮点数字时表现不佳，经验证，internlm2-chat-1.8b (internlm2-chat-7b)也存在这一问题，例如认为13.8<13.11。
任务要求：利用LangGPT优化提示词，使LLM输出正确结果。完成一次并提交截图即可

使用GPTS中LangGPT提示词专家，配合我们的需求生成LangGPT结构化提示词

生成结果如下：

1
# Role: 数学助手
2

3
## Profile
4
- author: LangGPT
5
- version: 1.0
6
- language: 中文
7
- description: 一个能够进行基本数学加减法运算，并能够比较两个数字大小的助手。
8

9
## Skills
10
1. 能够进行基本的数学加法和减法运算。
11
2. 能够比较两个数字的大小，并给出相应的判断。
12
3. 能够理解用户输入的简单数学表达式或问题描述。
13

14
## Rules
15
1. 用户输入可以是任意两个数字或一个包含加法、减法的表达式。
16
2. 当输入两个数字时，助手应比较它们的大小，并返回结果。
17
3. 当输入一个加法或减法表达式时，助手应计算出结果并返回。
18
4. 如果用户输入有误或不符合数学表达式规则，助手应给出提示并要求重新输入。
19

20
## Workflows
21
1. 接收用户输入的数字或数学表达式。
22
2. 判断输入的类型（两个数字或数学表达式）。
23
3. 如果是两个数字，执行大小比较，并返回结果。
24
4. 如果是数学表达式，进行加法或减法计算，返回结果。
25
5. 如果输入不符合预期格式，返回错误提示，要求用户重新输入。
26

27
## Init
28
1. 向用户介绍助手的功能和使用方法。
29
2. 提示用户可以输入两个数字进行比较，或输入一个加法、减法表达式进行计算。

展开收起

加入系统提示词前： PS：估计InternLM2-chat-1_8b版本太久远了，所以回答不出来🤔

加入系统提示词后： PS：效果明显变好了😋

Reference：#

1.LangGPT社区：LangGPT结构化提示词 - 飞书云文档 2.浦语开源文档书生浦语-浦语提示词工程实践 3.文档：系统论述文章：构建高性能 Prompt 之路——结构化 Prompt

RAG：给助手接入自己的知识库#

当问题来自私有文档或模型训练后的新知识时，仅修改 Prompt 不够。RAG 会先检索相关资料，再把检索结果交给模型生成答案。

一、前置知识#

给模型注入新知识的方式：
- 内部方式：更新模型的权重，但训练代价较大。
- 外部方式：给模型注入额外的上下文或外部信息，不改变其权重。
RAG 工作原理：
- 将问题编码成向量，在向量数据库中找到最相关的文档块（top-k chunks）。
- 将知识源分割成小块，编码成向量并存储在向量数据库中。
- 将检索到的文档块与原始问题一起作为提示输入到 LLM 中，生成最终的回答。
RAG 效果比对：
- 由于 xtuner 是较新的框架，InternLM2-Chat-1.8B 训练数据库中未收录相关信息，使用 RAG 前问答均未给出准确答案，使用后能获得想要的答案。

二、环境、模型准备#

（一）配置基础环境#

在 Intern Studio 服务器上部署 LlamaIndex：
- 打开 Intern Studio 界面，点击 创建开发机 配置开发机系统。
- 填写 开发机名称 后，点击 选择镜像 使用 Cuda11.7-conda 镜像，在资源配置中选择 30% A100 * 1 的选项，立即创建开发机器。
- 进入开发机后，创建新的 conda 环境，命名为 llamaindex，运行以下命令：
Terminal window
```
1
conda create -n llamaindex python=3.10
2
conda env list
3
conda activate llamaindex
4
conda install pytorch**2.0.1 torchvision**0.15.2 torchaudio==2.0.2 pytorch-cuda=11.7 -c pytorch -c nvidia
5
pip install einops**0.7.0 protobuf**5.26.1
```
- 环境激活后，命令行左边会显示当前环境名称。

（二）安装 LlamaIndex#

安装 LlamaIndex 和相关的包：

Terminal window

1
conda activate llamaindex
2
pip install llama-index**0.10.38 llama-index-llms-huggingface**0.2.0 "transformers[torch]**4.41.1" "huggingface_hub[inference]**0.23.1" huggingface_hub**0.23.1 sentence-transformers**2.7.0 sentencepiece==0.2.0

（三）下载 Sentence Transformer 词嵌入模型#

新建一个 python 文件，贴入以下代码：

1
import os
2

3
# 设置环境变量
4
os.environ['HF_ENDPOINT'] = 'https://hf-mirror.com'
5

6
# 下载模型
7
os.system('huggingface-cli download --resume-download sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2 --local-dir /root/model/sentence-transformer')

在 /root/llamaindex_demo 目录下执行该脚本自动开始下载。

（四）下载 NLTK 相关资源#

使用以下命令下载 nltk 资源并解压到服务器上：

Terminal window

1
cd /root
2
git clone https://gitee.com/yzy0612/nltk_data.git --branch gh-pages
3
cd nltk_data
4
mv packages/* ./
5
cd tokenizers
6
unzip punkt.zip
7
cd ../taggers
8
unzip averaged_perceptron_tagger.zip

三、LlamaIndex HuggingFaceLLM#

运行以下指令，把 InternLM2 1.8B 软连接出来：

Terminal window

1
cd ~/model
2
ln -s /root/share/new_models/Shanghai_AI_Laboratory/internlm2-chat-1_8b/ ./

新建一个 python 文件，贴入以下代码：

1
from llama_index.llms.huggingface import HuggingFaceLLM
2
from llama_index.core.llms import ChatMessage
3

4
llm = HuggingFaceLLM(
5
    model_name="/root/model/internlm2-chat-1_8b",
6
    tokenizer_name="/root/model/internlm2-chat-1_8b",
7
    model_kwargs={"trust_remote_code": True},
8
    tokenizer_kwargs={"trust_remote_code": True}
9
)
10

11
rsp = llm.chat(messages=[ChatMessage(content="xtuner 是什么？")])
12
print(rsp)

运行以下命令：

Terminal window

1
conda activate llamaindex
2
cd ~/llamaindex_demo/
3
python llamaindex_internlm.py

结果回答效果并不好，不是想要的 xtuner。

四、LlamaIndex RAG#

安装 LlamaIndex 词嵌入向量依赖：

Terminal window

1
conda activate llamaindex
2
pip install llama-index-embeddings-huggingface**0.2.0 llama-index-embeddings-instructor**0.1.3

获取知识库：

Terminal window

1
cd ~/llamaindex_demo
2
mkdir data
3
cd data
4
git clone https://github.com/InternLM/xtuner.git
5
mv xtuner/README_zh-CN.md ./

新建一个 python 文件，贴入以下代码：

1
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
2
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
3
from llama_index.llms.huggingface import HuggingFaceLLM
4

5
# 初始化一个 HuggingFaceEmbedding 对象，用于将文本转换为向量表示
6
embed_model = HuggingFaceEmbedding(
7
    model_name="/root/model/sentence-transformer"
8
)
9
Settings.embed_model = embed_model
10

11
llm = HuggingFaceLLM(
12
    model_name="/root/model/internlm2-chat-1_8b",
13
    tokenizer_name="/root/model/internlm2-chat-1_8b",
14
    model_kwargs={"trust_remote_code": True},
15
    tokenizer_kwargs={"trust_remote_code": True}
16
)
17
Settings.llm = llm
18

19
# 从指定目录读取所有文档，并加载数据到内存中
20
documents = SimpleDirectoryReader("/root/llamaindex_demo/data").load_data()
21
index = VectorStoreIndex.from_documents(documents)
22
query_engine = index.as_query_engine()
23
response = query_engine.query("xtuner 是什么?")
24

25
print(response)

展开收起

运行以下命令：

Terminal window

1
conda activate llamaindex
2
cd ~/llamaindex_demo/
3
python llamaindex_RAG.py

结果借助 RAG 技术后，能获得想要的答案。

五、LlamaIndex Web#

安装依赖：
Terminal window
```
1
pip install streamlit==1.36.0
```

新建一个 python 文件，贴入以下代码：

1
import streamlit as st
2
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
3
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
4
from llama_index.llms.huggingface import HuggingFaceLLM
5

6
st.set_page_config(page_title="llama_index_demo", page_icon="🦜🔗")
7
st.title("llama_index_demo")
8

9
# 初始化模型
10
@st.cache_resource
11
def init_models():
12
    embed_model = HuggingFaceEmbedding(
13
        model_name="/root/model/sentence-transformer"
14
    )
15
    Settings.embed_model = embed_model
16

17
    llm = HuggingFaceLLM(
18
        model_name="/root/model/internlm2-chat-1_8b",
19
        tokenizer_name="/root/model/internlm2-chat-1_8b",
20
        model_kwargs={"trust_remote_code": True},
21
        tokenizer_kwargs={"trust_remote_code": True}
22
    )
23
    Settings.llm = llm
24

25
    documents = SimpleDirectoryReader("/root/llamaindex_demo/data").load_data()
26
    index = VectorStoreIndex.from_documents(documents)
27
    query_engine = index.as_query_engine()
28

29
    return query_engine
30

31
# 检查是否需要初始化模型
32
if 'query_engine' not in st.session_state:
33
    st.session_state['query_engine'] = init_models()
34

35
def greet2(question):
36
    response = st.session_state['query_engine'].query(question)
37
    return response
38

39

40
# Store LLM generated responses
41
if "messages" not in st.session_state.keys():
42
    st.session_state.messages = [{"role": "assistant", "content": "你好，我是你的助手，有什么我可以帮助你的吗？"}]
43

44
# Display or clear chat messages
45
for message in st.session_state.messages:
46
    with st.chat_message(message["role"]):
47
        st.write(message["content"])
48

49
def clear_chat_history():
50
    st.session_state.messages = [{"role": "assistant", "content": "你好，我是你的助手，有什么我可以帮助你的吗？"}]
51

52
st.sidebar.button('Clear Chat History', on_click=clear_chat_history)
53

54
# Function for generating LLaMA2 response
55

56

57
def generate_llama_response(question):
58
    response = greet2(question)
59
    return response
60

61
# User-provided prompt
62
if prompt := st.chat_input("What's on your mind?"):
63
    st.chat_message("user").write(prompt)
64
    with st.chat_message("assistant"):
65
        message_placeholder = st.empty()
66
        response = generate_llama_response(prompt)
67
        message_placeholder.write(response)
68
    st.session_state.messages.append({"role": "assistant", "content": response})

展开收起

启动 Streamlit 服务：

Terminal window

1
cd ~/llamaindex_demo/
2
streamlit run llamaindex_streamlit.py

打开浏览器，访问 https://localhost:XXX。

六、总结#

本文介绍如何结合 LlamaIndex 和 InternLM2 部署 RAG，为大模型注入最新知识库，效果显著。

七、作业#

RAG前

RAG后

使用Streamlit部署webui（使用RAG）

Lagent：让助手能够调用工具#

RAG 解决“知道什么”，Agent 更关注“能够做什么”。这一部分记录 Lagent WebUI、模型服务、依赖问题和自定义工具的接入过程。

启动webui服务#

使用lmdeploy启动一个api_server

Terminal window

1
conda activate agent_camp3
2
lmdeploy serve api_server /share/new_models/Shanghai_AI_Laboratory/internlm2_5-7b-chat --model-name internlm2_5-7b-chat

另开一个终端，使用stremlit启动agent_web应用

Terminal window

1
cd /root/agent_camp3/lagent
2
conda activate agent_camp3
3
streamlit run examples/internlm2_agent_web_demo.py

本地powershell建立ssh连接，进行端口映射

Q&A#

遇到的问题：#

1
ModuleNotFoundError: No module named 'griffe.enumerations

解决方法：#

1
Due to griffe's recent 1.x release, the `griffe.enumerations` module has been removed, resulting in a break change, which can be resolved by
2
`pip install griffe==0.48`.

修改模型名称以及模型IP地址#

启动streamlit的web应用如下：

修改红框内的内容

终端的反馈：

PS<很是可惜>，没有找到我想要的内容[1706.03762] Attention Is All You Need (arxiv.org)

自定义工具#

进入lagent_web_demo的py文件中

添加&修改代码：

1
from lagent.actions import ActionExecutor, ArxivSearch, IPythonInterpreter
2
+ from lagent.actions.magicmaker import MagicMaker
3
from lagent.agents.internlm2_agent import INTERPRETER_CN, META_CN, PLUGIN_CN, Internlm2Agent, Internlm2Protocol
4

5
...
6
        action_list = [
7
            ArxivSearch(),
8
+             MagicMaker(),
9
        ]

重新启动agent_web服务

使用MagicMaker工具绘画

Prompt：帮我画一个微笑的女孩，穿着校服在学校的走廊上，阳光照耀在她身上

可以看到对于用户输入的提示词，有自动进行填充完善

XTuner：把稳定需求固化到模型中#

微调适合处理长期、重复且有训练样本支持的能力或风格。它不应替代知识库和工具系统；知识经常变化时优先使用 RAG，需要执行动作时仍要使用 Agent。原始记录主要保存了任务要求与结果截图，因此这里不补写未经验证的训练参数。

任务内容#

完成任务截图#

四种方案如何组合#

一个实用的个人助手可以采用这样的工作流：用户输入先经过结构化 Prompt 整理；系统判断是否需要检索本地知识库；如果任务要求搜索、绘图或运行代码，再交给 Agent 调用工具；模型本身则通过少量高质量微调数据保持稳定的人设和表达习惯。

实践建议#

先用 Prompt 做最小可行版本，确认任务边界。
知识变化频繁时使用 RAG，不要反复微调事实数据。
工具权限应尽量最小化，并为调用结果增加校验。
只有当需求稳定、样本可靠、收益明确时再进行微调。
用固定测试集分别验证准确率、引用质量、工具成功率和风格一致性。

从 Prompt 到 RAG、Agent、微调，本质上是在逐步扩展助手的可控性、知识范围、行动能力和个性化程度。

从认识 InternLM 到 8G 显存部署：Demo、LMDeploy 与 OpenCompass 评测

Thu, 08 Aug 2024 00:00:00 GMT

这篇文章把“认识模型、运行模型、评估模型”三段学习记录合并在一起。目标不是只把 Demo 跑起来，而是形成一条从生态理解到低显存部署，再到能力验证的完整路径。

阅读路线#

先了解 InternLM 的模型、数据、训练、部署和评测工具链。
在 8G 显存环境中运行文本与多模态 Demo。
使用 LMDeploy 提供更适合实际调用的推理服务。
使用 OpenCompass 对模型能力进行可重复的评测。

部署成功只说明环境和推理链路能够工作，并不代表模型适合目标任务。最终仍需要结合显存占用、响应速度、输出质量和评测结果进行选择。

InternLM 全链路开源体系#

先从全局理解书生·浦语生态。模型只是其中一环，数据处理、训练、微调、部署、智能体和评测共同组成完整工具链。

博客：书生·浦语大模型全链路开源开放体系及其最新发展#

在现代人工智能技术的迅猛发展浪潮中，书生·浦语大模型全链路开源开放体系以其独特的优势和卓越的性能，在各个领域中不断取得突破性进展。本文将详细介绍该体系的发展历程、最新版本的特征、基于规则、模型和反馈的数据生成方法，以及mind search项目、开源数据提取工具和预训练框架、EXTINA的评测和部署、知识管理工具等各个方面的应用与优化策略。

书生·浦语大模型全链路开源开放体系的历程及最新版本的特征#

书生·浦语大模型开源开放体系在多个方面表现出色，包括数据收集整理、模型训练、微调、评测和搜索引擎AI应用的部署等方面。最新版本书生·浦语大模型2.5在推理能力和短期记忆等方面有质的飞跃，并开放了label LLM项目，方便标注数据。此外，视频还介绍了模型的性能天梯和应用前景。

书生浦语大模型开源开放体系
InputLM2.5性能飞跃
迭代发展过程中的数据驱动模型性能

基于规则、模型和反馈的数据生成方法，以及如何使用开源项目进行标注和推理#

反映模型的数据生成方法在模型优化和训练过程中至关重要，以下是一些关键方法的介绍：

基于模型的反馈数据生成方法：包括相似度对齐和基于反馈的强化训练。
大海捞针实验：介绍模型的推理能力和大海捞针实验，模型在处理稀长背景知识的表现。
问题匹配分块：介绍问题匹配分块的方法，可以用于语言模型的索引和问题理解。

mind search项目#

mind search项目展示了其在语言模型、预训练模型、微调框架、部署工具等方面的强大功能和应用潜力。

Mindsearch项目和书生普与开源模型谱系
部署工具和评测工具
应用方面的工具和框架

开源数据提取工具Minor U和预训练框架XTNER#

Minor U和XTNER提供了无缝衔接和数据格式兼容性的功能，极大地加速了模型的训练和优化过程。

智能体框架和开源工具无缝衔接
微调框架和数据格式兼容性
使用XTNER进行微调的方法和流程

EXTINA的评测和部署#

EXTINA通过微调和Open Compass评测模型，以及lm deploy的推理性能对比，构建了智能体框架建设方案。

使用EXTINA微调和Open Compass评测模型
lm deploy模型部署框架和智能体框架
基于AI的搜索引擎和知识插件

知识管理工具笞香豆的企业级应用#

知识管理工具笞香豆通过可视化、强生和知识图谱生成，支持搜索和思考过程的展示，推动了开源生态系统的完善和实践营的创新发展。

思维可视化：通过搜索和思考1900年和1924年的相关信息，展示了模拟人脑思维逻辑的可视化过程。
支持检索增强生成和知识图谱：理解群体行为。
赋能创新：通过开源生态实践营，持续以高质量的开源赋能创新。

在人工智能的快速发展中，书生·浦语大模型全链路开源开放体系无疑是一颗璀璨的明珠。它不仅在技术上不断推陈出新，在应用上也不断拓展，为各行各业带来了无限的可能。期待未来它能为更多领域提供支持，推动社会的智能化发展。

8G 显存环境下的模型部署#

在资源有限的环境中，模型规模、精度、量化方式和推理框架必须一起考虑。下面保留 CLI、Streamlit Web Demo、XComposer 和 InternVL2 的实际部署记录。

环境配置#

1
# 创建环境
2
conda create -n demo python=3.10 -y
3
# 激活环境
4
conda activate demo
5
# 安装 torch
6
conda install pytorch**2.1.2 torchvision**0.16.2 torchaudio==2.1.2 pytorch-cuda=12.1 -c pytorch -c nvidia -y
7
# 安装其他依赖
8
pip install transformers==4.38
9
pip install sentencepiece==0.1.99
10
pip install einops==0.8.0
11
pip install protobuf==5.27.2
12
pip install accelerate==0.33.0
13
pip install streamlit==1.37.0

InternLM2-Chat-1.8B 模型部署#

一、用Cli Demo 部署#

1.创建demo文件夹，用于存放代码。并创建 cli_demo.py文件

1
mkdir -p /root/demo
2
touch /root/demo/cli_demo.py

其中cli_demo.py 的代码为：

1
import torch
2
from transformers import AutoTokenizer, AutoModelForCausalLM
3

4

5
model_name_or_path = "/root/share/new_models/Shanghai_AI_Laboratory/internlm2-chat-1_8b"
6

7
tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, trust_remote_code=True, device_map='cuda:0')
8
model = AutoModelForCausalLM.from_pretrained(model_name_or_path, trust_remote_code=True, torch_dtype=torch.bfloat16, device_map='cuda:0')
9
model = model.eval()
10

11
system_prompt = """You are an AI assistant whose name is InternLM (书生·浦语).
12
- InternLM (书生·浦语) is a conversational language model that is developed by Shanghai AI Laboratory (上海人工智能实验室). It is designed to be helpful, honest, and harmless.
13
- InternLM (书生·浦语) can understand and communicate fluently in the language chosen by the user such as English and 中文.
14
"""
15

16
messages = [(system_prompt, '')]
17

18
print("===========**Welcome to InternLM chatbot, type 'exit' to exit.**===========")
19

20
while True:
21
    input_text = input("\nUser  >>> ")
22
    input_text = input_text.replace(' ', '')
23
    if input_text == "exit":
24
        break
25

26
    length = 0
27
    for response, _ in model.stream_chat(tokenizer, input_text, messages):
28
        if response is not None:
29
            print(response[length:], flush=True, end="")
30
            length = len(response)

展开收起

2.在终端执行python /root/demo/cli_demo.py命令启动Demo

3.使用 Cli Demo 完成 InternLM2-Chat-1.8B 模型的部署，并生成 300 字小故事

二、用Streamlit Web Demo 部署#

1.clone InternLM 的github仓库到本地：

Terminal window

1
cd /root/demo
2
git clone https://github.com/InternLM/Tutorial.git

2.启动Streamlit 服务：

Terminal window

1
cd /root/demo
2
streamlit run /root/demo/Tutorial/tools/streamlit_demo.py --server.address 127.0.0.1 --server.port 6006

3.在本地的 PowerShell 中输入以下命令，将端口映射到本地：

Terminal window

1
ssh -CNg -L 6006:127.0.0.1:6006 root@ssh.intern-ai.org.cn -p 你的 ssh 端口号

4.完成端口映射后，通过浏览器访问 http://localhost:6006 来启动我们的 Demo。

LMDeploy 部署#

一、InternLM-XComposer2-VL-1.8B 模型#

模型介绍：#

InternLM-XComposer2 是一款基于 InternLM2 的视觉语言大模型，其擅长自由形式的文本图像合成和理解。其主要特点包括：

自由形式的交错文本图像合成：InternLM-XComposer2 可以根据大纲、详细文本要求和参考图像等不同输入，生成连贯且上下文相关，具有交错图像和文本的文章，从而实现高度可定制的内容创建。
准确的视觉语言问题解决：InternLM-XComposer2 基于自由形式的指令准确地处理多样化和具有挑战性的视觉语言问答任务，在识别，感知，详细标签，视觉推理等方面表现出色。

部署步骤：#

1.激活环境并安装 LMDeploy 以及其他依赖。

Terminal window

1
conda activate demo
2
pip install lmdeploy[all]==0.5.1
3
pip install timm==1.0.7

2.使用 LMDeploy 启动一个与 InternLM-XComposer2-VL-1.8B 模型交互的 Gradio 服务。

Terminal window

1
lmdeploy serve gradio /share/new_models/Shanghai_AI_Laboratory/internlm-xcomposer2-vl-1_8b --cache-max-entry-count 0.1

3.若已关闭端口映射，重新输入以下代码即可:

1
ssh -CNg -L 6006:127.0.0.1:6006 root@ssh.intern-ai.org.cn -p 36558

通过浏览器访问 http://localhost:6006 来启动InternLM-XComposer2-VL-1.8B模型

输入图片并询问图片里有什么：

输出：

二、InternVL2-2B 模型#

模型介绍:#

InternVL2 是上海人工智能实验室推出的新一代视觉-语言多模态大模型，是首个综合性能媲美国际闭源商业模型的开源多模态大模型。InternVL2 系列从千亿大模型到端侧小模型全覆盖，通专融合，支持多种模态。

部署步骤：#

1.通过下面的命令来启动 InternVL2-2B 模型的 Gradio 服务:

Terminal window

1
conda activate demo
2
lmdeploy serve gradio /share/new_models/OpenGVLab/InternVL2-2B --cache-max-entry-count 0.1

2.若已关闭端口映射，重新输入以下代码即可:

1
ssh -CNg -L 6006:127.0.0.1:6006 root@ssh.intern-ai.org.cn -p 36558

通过浏览器访问 http://localhost:6006 来启动InternVL2-2B模型

输入图片并询问详细描述图片内容：

输出：

使用 OpenCompass 进行模型评测#

模型能够启动后，还需要回答“它在目标任务上表现如何”。OpenCompass 提供统一的数据集、配置和指标，使不同模型与不同设置之间的比较更加规范。

参考文档#

Tutorial/docs/L1/OpenCompass at camp3 · InternLM/Tutorial (github.com)

任务内容#

任务复现过程#

列出所有跟 InternLM 及 C-Eval 相关的配置：

Terminal window

1
python tools/list_configs.py internlm ceval

评测结束

从 Demo 到可用服务#

完成本地 Demo 后，可以继续沿以下方向完善：

记录模型加载后的实际显存占用和首字延迟。
固定模型版本、依赖版本和推理参数，保证结果可复现。
使用 LMDeploy API Server 将界面与模型服务解耦。
为目标业务建立小型自定义测试集，不只依赖通用榜单。
同时观察准确率、稳定性、速度和资源消耗。

总结#

InternLM 的价值不仅在模型本身，也在于它提供了从数据、训练到部署和评测的完整开源链路。8G 显存实践验证了轻量模型的可运行性，而 OpenCompass 则补上了“运行之后如何判断是否好用”的关键环节。

经典监督学习模型：线性模型、决策树与支持向量机

Thu, 16 May 2024 00:00:00 GMT

线性模型、决策树和支持向量机是经典监督学习中三条非常不同的建模路线。它们分别通过线性组合、递归划分和最大间隔来刻画输入与输出之间的关系。

把三章放在一起学习，更容易看清模型结构、优化目标、非线性能力和泛化方式之间的差异。

统一比较框架#

模型	基本表示	非线性来源	主要优点	常见限制
线性模型	特征的加权组合	特征变换或广义线性连接函数	简洁、可解释、训练高效	原始特征空间中表达能力有限
决策树	一系列属性划分规则	递归分区天然形成非线性边界	规则直观、能处理混合特征	容易过拟合，对数据扰动敏感
支持向量机	最大间隔超平面	核函数映射到高维空间	小样本、高维任务中表现稳定	大规模训练成本高，参数和核选择重要

三种模型都可以完成监督学习任务，但它们引入先验偏好的方式不同，因此适用的数据结构也不同。

线性模型：从回归到分类#

线性模型用特征的加权组合表达预测函数，是理解最小二乘、对数几率回归和许多复杂模型的基础。

所需数学知识#

求偏导
矩阵求导
求逆矩阵

名词解释#

1.序关系

1
有序：属性之间可进行相对比较（如大、中、小）
2
无序：属性之间不可进行相对比较（如南瓜、西瓜、冬瓜）

2.符号arg与s.t.

1
arg：即argument（参数），用于表示求出指定函数时的**参数取值**
2
  例如：
3
  arg min 就是使后面这个式子达到最小值时的 变量的取值
4
  arg max 就是使后面这个式子达到最大值时的 变量的取值
5

6
s.t.：即subject to，意思是受限于...，后面紧跟约束条件

3.闭式解

1
也叫做 解析解，
2
闭式解就是一些严格的公式,给出任意的自变量就可以求出其因变量,也就是问题的解
3
南瓜书中说闭式解是指可以通过具体的表达式解出待解参数

模型介绍#

表示形式#

对于拥有 ddd 个属性的样本，特征向量可写为：

x=(x1,x2,…,xd)T\boldsymbol{x} =(x_1,x_2,\ldots,x_d)^{\mathrm T}x=(x1,x2,…,xd)T

其中 xix_ixi 表示第 iii 个属性的属性值。各属性的线性组合作为预测函数：

f(x)=w1x1+w2x2+⋯+wdxd+bf(\boldsymbol{x}) =w_1x_1+w_2x_2+\cdots+w_dx_d+bf(x)=w1x1+w2x2+⋯+wdxd+b

向量形式为：

f(x)=wTx+bf(\boldsymbol{x}) =\boldsymbol{w}^{\mathrm T}\boldsymbol{x}+bf(x)=wTx+b

其中 w\boldsymbol ww 和 x\boldsymbol xx 均为列向量，w\boldsymbol ww 中的元素表示不同属性的权重故线性模型具有很强的可解释性

模型优点#

简单（模型表示、数学公式简单）
基本（通过引入层级结构或高维映射可以得到许多非线性模型）
可理解性好（通过权重可以看出对属性的偏好）

属性数值化#

总结：离散属性的处理：若有“序”(order)，则连续化；否则，转化为 𝑘维向量

对于线性模型的求解，我们首先需要明确参数的输入和求解两个部分

我们知道模型的输入为各个示例 xix_ixi，其中的xix_ixi由d个属性组成，而我们用d个属性值表示一个具体的示例xix_ixi作为输入

这时我们会发现我们需要注意属性值的数据类型 于是这里我们把属性分为两类

连续属性
离散属性
- 有序的离散属性
- 无序的离散属性

对于有序的属性，我们用相对值表示属性值，如大、中、小分别用1，0.5，0来表示

对于无序的属性，我们用0/1表示属性值，我们记改属性有m种属性值，则一个属性值需要m维列向量进行表示。

比如属性“瓜的类别”有西瓜、南瓜、冬瓜三种取值，可分别进行独热编码：

x1=(1,0,0)T,x2=(0,1,0)T,x3=(0,0,1)T\begin{aligned} \boldsymbol{x}_1&=(1,0,0)^{\mathrm T},\\ \boldsymbol{x}_2&=(0,1,0)^{\mathrm T},\\ \boldsymbol{x}_3&=(0,0,1)^{\mathrm T} \end{aligned}x1x2x3=(1,0,0)T,=(0,1,0)T,=(0,0,1)T

x1\boldsymbol x_1x1、x2\boldsymbol x_2x2、x3\boldsymbol x_3x3 分别表示西瓜、南瓜、冬瓜。

对于回归，二分类，多分类任务，我们给出不同的线性模型

1.png

回归任务#

最小二乘法#

在第二章中我们知道，均方误差是回归任务常见的性能度量。
最小二乘把残差向量的平方欧氏范数作为优化目标，因而具有清晰的几何意义。

定义：通过最小化预测值与真实标记之间的平方残差来求解模型。普通最小二乘最小化的是纵向残差平方和，并不是样本点到直线的垂直欧氏距离。

数学知识：涉及求偏导数

1. 一元线性回归#

1. 假设方程#

f(xi)=wxi+bf(x_i)=w x_i+bf(xi)=wxi+b

希望预测值 f(xi)f(x_i)f(xi) 尽可能接近真实标记 yiy_iyi。

2. 最小化平方误差#

定义平方误差和：

E(w,b)=∑i=1m(yi−wxi−b)2E(w,b)=\sum_{i=1}^{m}\left(y_i-wx_i-b\right)^2E(w,b)=i=1∑m(yi−wxi−b)2

于是最小二乘估计为：

(w∗,b∗)=arg min⁡w,bE(w,b)\left(w^*,b^*\right) =\operatorname*{arg\,min}_{w,b}E(w,b)(w∗,b∗)=w,bargminE(w,b)

若把目标函数写成均方误差 E(w,b)/mE(w,b)/mE(w,b)/m，只会多出常数因子 1/m1/m1/m，不会改变最优解。

3. 对 www 与 bbb 求偏导#

∂E∂w=−2∑i=1mxi(yi−wxi−b),∂E∂b=−2∑i=1m(yi−wxi−b).\begin{aligned} \frac{\partial E}{\partial w} &=-2\sum_{i=1}^{m}x_i\left(y_i-wx_i-b\right),\\ \frac{\partial E}{\partial b} &=-2\sum_{i=1}^{m}\left(y_i-wx_i-b\right). \end{aligned}∂w∂E∂b∂E=−2i=1∑mxi(yi−wxi−b),=−2i=1∑m(yi−wxi−b).

E(w,b)E(w,b)E(w,b) 是关于 www 和 bbb 的凸二次函数，因此令梯度为零即可得到全局最优解；若所有 xix_ixi 都相同，则斜率不能被唯一确定。

4. 求得闭式解#

当 ∑i=1m(xi−xˉ)2>0\sum_{i=1}^{m}(x_i-\bar{x})^2>0∑i=1m(xi−xˉ)2>0 时：

w∗=∑i=1m(xi−xˉ)(yi−yˉ)∑i=1m(xi−xˉ)2w^* =\frac{\sum_{i=1}^{m}(x_i-\bar{x})(y_i-\bar{y})} {\sum_{i=1}^{m}(x_i-\bar{x})^2}w∗=∑i=1m(xi−xˉ)2∑i=1m(xi−xˉ)(yi−yˉ)b∗=yˉ−w∗xˉb^*=\bar{y}-w^*\bar{x}b∗=yˉ−w∗xˉ

其中 xˉ=1m∑i=1mxi\bar{x}=\frac{1}{m}\sum_{i=1}^{m}x_ixˉ=m1∑i=1mxi，yˉ=1m∑i=1myi\bar{y}=\frac{1}{m}\sum_{i=1}^{m}y_iyˉ=m1∑i=1myi。

2. 多元线性回归#

额外数学知识：矩阵求导与矩阵求逆。

基于本人数学系所教授的高等代数中无此内容，故认为需要额外补充学习。

详见《机器学习》附录 P400 的 A.2 导数。

1. 假设方程#

f(xi)=wTxi+bf(\boldsymbol{x}_i)=\boldsymbol{w}^{\mathrm T}\boldsymbol{x}_i+bf(xi)=wTxi+b

同样希望预测值 f(xi)f(\boldsymbol{x}_i)f(xi) 尽可能接近真实标记 yiy_iyi。

2. 构造增广向量与设计矩阵#

定义增广参数和增广样本：

w^=(wb),x^i=(xi1)\hat{\boldsymbol w} =\begin{pmatrix}\boldsymbol w\\b\end{pmatrix}, \qquad \hat{\boldsymbol x}_i =\begin{pmatrix}\boldsymbol x_i\\1\end{pmatrix}w^=(wb),x^i=(xi1)

将所有样本按行排列，得到设计矩阵：

X=(x1T1x2T1⋮⋮xmT1)∈Rm×(d+1)\mathbf X =\begin{pmatrix} \boldsymbol{x}_1^{\mathrm T} & 1\\ \boldsymbol{x}_2^{\mathrm T} & 1\\ \vdots & \vdots\\ \boldsymbol{x}_m^{\mathrm T} & 1 \end{pmatrix} \in\mathbb R^{m\times(d+1)}X=x1Tx2T⋮xmT11⋮1∈Rm×(d+1)

标记向量写作 y=(y1,y2,…,ym)T\boldsymbol y=(y_1,y_2,\ldots,y_m)^{\mathrm T}y=(y1,y2,…,ym)T，平方误差和为：

E(w^)=∥Xw^−y∥22E(\hat{\boldsymbol w}) =\left\|\mathbf X\hat{\boldsymbol w}-\boldsymbol y\right\|_2^2E(w^)=∥Xw^−y∥22

2.png

[图片源于周志华老师]

3. 求解参数向量#

对目标函数求梯度：

∇w^E=2XT(Xw^−y)\nabla_{\hat{\boldsymbol w}}E =2\mathbf X^{\mathrm T} \left(\mathbf X\hat{\boldsymbol w}-\boldsymbol y\right)∇w^E=2XT(Xw^−y)

若 X\mathbf XX 满列秩，则 XTX\mathbf X^{\mathrm T}\mathbf XXTX 正定且可逆。令梯度为零，得到唯一闭式解：

w^∗=(XTX)−1XTy\hat{\boldsymbol w}^{*} =\left(\mathbf X^{\mathrm T}\mathbf X\right)^{-1} \mathbf X^{\mathrm T}\boldsymbol yw^∗=(XTX)−1XTy

若 XTX\mathbf X^{\mathrm T}\mathbf XXTX 不可逆，最小二乘解可能不唯一，此时可用 Moore–Penrose 伪逆得到一个最小范数解：

w^∗=X+y\hat{\boldsymbol w}^{*}=\mathbf X^{+}\boldsymbol yw^∗=X+y

也可以加入正则化项表达归纳偏好，详见 6.4 节和 11.4 节。

常见正则化方法包括岭回归（Ridge Regression）、Lasso 和弹性网（Elastic Net）。

4. 得到预测模型#

对于增广输入 x^i\hat{\boldsymbol x}_ix^i，预测值为：

y^i=x^iTw^∗\hat y_i =\hat{\boldsymbol x}_i^{\mathrm T}\hat{\boldsymbol w}^{*}y^i=x^iTw^∗

PS：把最小二乘目标写成二次型并使用矩阵求导很有意思，详细推导可参考《南瓜书》P35–P36。

3.广义线性模型(GLM)#

通过联系函数，让输出的条件均值与线性预测子建立关系。

对数线性模型#

当输出变量为正，且条件均值随输入呈指数尺度变化时，可以使用对数联系函数建模。

个人理解：

其实就是我们在原样本中，通过数值或者散点图，观察到输出标记在指数尺度上变化，故很难直接用一条直线拟合输出标记，因为标记值本身为非线性增长。

而对在指数尺度上变化的输出标记取对数后，就可以将输出标记映射到线性尺度上变化，故易于用直线拟合

将输出的条件均值记为 μ(x)=E[Y∣x]\mu(\boldsymbol x)=\mathbb E[Y\mid\boldsymbol x]μ(x)=E[Y∣x]。对数线性模型使用对数联系函数：

ln⁡μ(x)=wTx+b\ln \mu(\boldsymbol{x}) =\boldsymbol{w}^{\mathrm T}\boldsymbol{x}+blnμ(x)=wTx+b

因此原始尺度上的预测为：

μ(x)=exp⁡ ⁣(wTx+b)\mu(\boldsymbol{x}) =\exp\!\left(\boldsymbol{w}^{\mathrm T}\boldsymbol{x}+b\right)μ(x)=exp(wTx+b)

这里的对数函数把输出均值与线性预测子联系起来。偏置 bbb 也位于指数内部。
但实质上已是在求取输入空间到输出空间的非线性函数映射

广义线性模型通过选择联系函数和响应变量分布来扩展线性模型。联系函数并不是为了把每个观测值强行“变成线性”，而是规定条件均值 μ(x)\mu(\boldsymbol x)μ(x) 与线性预测子之间的关系。

实际建模时，应根据响应变量的取值范围、分布假设和任务目标选择合适的联系函数，再通过极大似然等方法估计模型参数。

而由此我们引出了广义线性模型（Generalized Linear Model）的定义：

g ⁣(μ(x))=wTx+b,μ(x)=E[Y∣x]\begin{aligned} g\!\left(\mu(\boldsymbol{x})\right) &=\boldsymbol{w}^{\mathrm T}\boldsymbol{x}+b,\\ \mu(\boldsymbol{x}) &=\mathbb E[Y\mid\boldsymbol{x}] \end{aligned}g(μ(x))μ(x)=wTx+b,=E[Y∣x]

其中 g(⋅)g(\cdot)g(⋅) 称为联系函数（link function），它把输出分布的条件均值与线性预测子联系起来。

广义线性模型的参数估计常通过加权最小二乘法或极大似然法进行

对数线性模型是广义线性模型在 g(μ)=ln⁡μg(\mu)=\ln\mug(μ)=lnμ 时的一个特例。显然，一元线性回归也是如此

分类任务#

引导#

在先前的文章：西瓜书-第3章-线性模型 (Part 1) 中我们介绍了 一元线性回归、多元线性回归、广义线性回归（对数线性回归）的模型, 用于解决回归类问题

那么对于分类问题，我们又该使用哪种模型呢？我们知道分类问题可以分成二分类与多分类问题

此处我们先介绍二分类问题所使用的模型

我们可以沿用广义线性模型的思想，用联系函数把类别概率与线性预测子联系起来。模型先输出连续的概率，再根据阈值或决策规则得到离散类别。

对数几率回归#

这里我们先给出“单位阶跃函数“(unit-step function)

此函数能够将输出范围在R上的标记转换为离散值

若预测值大于零就判为正例，小于零则判为反例，预测值为临界值零则可任意判别

在这里插入图片描述

我们可以看出这个函数的效果是很不错的但是因为其函数性质很差，不连续也不可微，不符合联系函数的定义

所以我们引入 Sigmoid 函数。令

z=wTx+bz=\boldsymbol{w}^{\mathrm T}\boldsymbol{x}+bz=wTx+b

则样本属于正类的条件概率为：

p(y=1∣x)=σ(z)=11+e−zp(y=1\mid\boldsymbol{x}) =\sigma(z) =\frac{1}{1+e^{-z}}p(y=1∣x)=σ(z)=1+e−z1

它对应的对数几率为：

ln⁡p(y=1∣x)1−p(y=1∣x)=wTx+b\ln\frac{p(y=1\mid\boldsymbol{x})} {1-p(y=1\mid\boldsymbol{x})} =\boldsymbol{w}^{\mathrm T}\boldsymbol{x}+bln1−p(y=1∣x)p(y=1∣x)=wTx+b

在这里插入图片描述

若把 p(y=1∣x)p(y=1\mid\boldsymbol x)p(y=1∣x) 视为样本属于正类的概率，则 1−p(y=1∣x)1-p(y=1\mid\boldsymbol x)1−p(y=1∣x) 是属于负类的概率。二者之比称为几率（odds），几率的对数称为对数几率（log odds）。

最小二乘是一种损失准则，并不是只适用于凸函数的优化算法。在线性回归中，它恰好形成凸二次目标并可在满秩条件下得到闭式解。

对数几率回归通常使用极大似然估计，其负对数似然是凸函数，可通过梯度下降、牛顿法等数值方法求解。

决策树：用属性划分构造规则#

决策树通过递归选择属性划分数据。信息增益、增益率和基尼指数决定如何分裂，剪枝则用于控制过拟合。

递归终止条件#

决策树使用递归实现，而递归终止条件有以下三种：

当前结点所有样本属于同类，无需划分
当前属性集为空，无法划分，选取此节点中数量更多的标记作为类别标记
当前样本集为空，不能划分，依据父节点中数量更多的标记作为类别标记

名词概念#

1.纯度：同类聚集程度高、不同类越分散，则纯度越高 2.信息熵：纯度的量化指标，来源于信息论 3.剪枝：防止决策树过拟合，减去部分划分属性。分为预剪枝和后剪枝

信息熵#

信息熵计算公式：

Ent⁡(D)=−∑k=1∣Y∣pklog⁡2pk\operatorname{Ent}(D) =-\sum_{k=1}^{|\mathcal Y|}p_k\log_2p_kEnt(D)=−k=1∑∣Y∣pklog2pk

信息熵用于衡量信息的不确定性或信息的混乱程度，我们可以将其用于量化纯度 信息熵越大，数据分布越均匀、随机、杂乱无章，明显这不是我们想要的。我们想要的是相同类靠近，不同类远离的效果，即需要越小的信息熵

pkp_kpk表示选到k类别的概率，而 −log⁡2pk-\log _ { 2 } p _ { k }−log2pk则表示信息量

1
我们可以理解对于某一事件，其发生的概率越小，那么其信息量越大；发生的概率越大，那么其信息量越小。所有对两者求期望即得到信息熵。

注意：∣Y∣|\mathcal Y|∣Y∣ 表示类别集合中的类别数量，例如二分类任务中 ∣Y∣=2|\mathcal Y|=2∣Y∣=2。

划分选择#

决策树中最重要的部分，用于选择最佳划分属性

1.信息增益(Information Gain)#

计算某属性的信息增益，用根节点的信息熵-属性各个属性值的信息熵的加权平均值 信息增益越大，意味着使用属性a进行划分获得的纯度提升越大

Gain⁡(D,a)=Ent⁡(D)−∑v=1V∣Dv∣∣D∣Ent⁡(Dv)\begin{aligned} \operatorname{Gain}(D,a) ={}&\operatorname{Ent}(D)\\ &-\sum_{v=1}^{V} \frac{|D^v|}{|D|} \operatorname{Ent}(D^v) \end{aligned}Gain(D,a)=Ent(D)−v=1∑V∣D∣∣Dv∣Ent(Dv)

2.增益率(Gain Ratio)#

由于信息增益对于取值数目较多的属性有所偏好，所以引进增益率进行选择最优划分属性，比如著名的C4.5决策树算法

属性的取值越分散，固有值 IV⁡(a)\operatorname{IV}(a)IV(a) 通常越大。增益率用信息增益除以固有值，从而抑制信息增益对多取值属性的偏好：

GainRatio⁡(D,a)=Gain⁡(D,a)IV⁡(a)\operatorname{GainRatio}(D,a) =\frac{\operatorname{Gain}(D,a)} {\operatorname{IV}(a)}GainRatio(D,a)=IV(a)Gain(D,a)IV⁡(a)=−∑v=1V∣Dv∣∣D∣log⁡2∣Dv∣∣D∣\operatorname{IV}(a) =-\sum_{v=1}^{V} \frac{|D^v|}{|D|} \log_2\frac{|D^v|}{|D|}IV(a)=−v=1∑V∣D∣∣Dv∣log2∣D∣∣Dv∣

不过，增益率可能偏好固有值很小的属性。C4.5 通常先保留信息增益高于平均水平的候选属性，再从中选择增益率最大的属性。

思考🤔：#

增益率可以减少信息增益对于属性值较多的属性有所偏好的问题，但是同样的，增益率对于属性值较少的属性有所偏好 所以实际处理时，对于不同的属性的划分选择可以采取不同的方法，但是在同一层属性划分选择时只能使用同一种方法。

3.基尼指数(Gini Index)#

含义：反映从数据集中随机抽取两个样本，其类别标记不一致的概率

CART 分类树常用基尼指数选择划分；CART 回归树通常使用平方误差等回归损失，而不是下面的分类基尼公式。

基尼指数越小，则数据集纯度越高。

Gini⁡(D)=1−∑k=1∣Y∣pk2\operatorname{Gini}(D) =1-\sum_{k=1}^{|\mathcal Y|}p_k^2Gini(D)=1−k=1∑∣Y∣pk2GiniIndex⁡(D,a)=∑v=1V∣Dv∣∣D∣Gini⁡(Dv)\operatorname{GiniIndex}(D,a) =\sum_{v=1}^{V} \frac{|D^v|}{|D|} \operatorname{Gini}(D^v)GiniIndex(D,a)=v=1∑V∣D∣∣Dv∣Gini(Dv)

剪枝(Pruning)#

为了防止决策树模型过拟合而采取的手段分为预剪枝与后剪枝两种方法

PS：需要先选定评估方法和性能度量（第二章知识内容）下列假设使用留出法，以精度为性能度量

预剪枝(Prepruning)#

运用贪心思想，可能有弊端

在建立决策树的过程中进行剪枝，使用验证数据比较当前精度与增加划分属性后的精度， 判断是否需要增加划分属性

后剪枝 (Postpruning)#

在决策树建立完成后进行剪枝，使用验证数据比较当前精度与把该结点变成叶节点后的精度， 判断是否需要剪去不要的树枝 优点：欠拟合风险小，泛化性能较好

支持向量机：最大间隔与核方法#

支持向量机从几何间隔出发，通过对偶问题与核函数处理高维非线性任务，并可扩展到支持向量回归。

章节介绍#

统计学领域名声赫赫的SVM与核方法是时至今日仍在高频使用的经典算法。

笔记介绍#

对本章各节知识点进行汇总，主要分为引入原因，原理思想，和一些思考，对于数学推导内容介绍较少，有需要的可以先阅读西瓜书，再参考南瓜书的数学推导。

数学知识#

大部分都是规划类、最优化的问题，最好先进行相关知识的学习。

这里推荐一本书：最优化：建模、算法与理论 (刘浩洋户将李勇锋文再文)

SVM-支持向量机#

引入原因：#

在线性可分的条件下，我们在训练集做分类任务时，最基本的想法就是在样本空间中找到一个超平面进行划分, 但是对于分类任务，我们可以画出很多个超平面，这时候就需要引入损失函数，对超平面进行选择，而使得两个异类支持向量的距离最大化，就是我们所说的支持向量机的基本型。

数学公式及其原理：#

仍用线性模型表示分类超平面：

wTx+b=0\boldsymbol{w}^{\mathrm T}\boldsymbol{x}+b=0wTx+b=0

点 x\boldsymbol xx 到该超平面的几何距离为：

r(x)=∣wTx+b∣∥w∥2r(\boldsymbol{x}) =\frac{|\boldsymbol{w}^{\mathrm T}\boldsymbol{x}+b|} {\|\boldsymbol{w}\|_2}r(x)=∥w∥2∣wTx+b∣

令类别标记 yi∈{−1,+1}y_i\in\{-1,+1\}yi∈{−1,+1}，并采用规范化约束

yi(wTxi+b)≥1,i=1,…,my_i(\boldsymbol{w}^{\mathrm T}\boldsymbol{x}_i+b)\geq 1, \qquad i=1,\ldots,myi(wTxi+b)≥1,i=1,…,m

两条间隔边界 wTx+b=±1\boldsymbol w^{\mathrm T}\boldsymbol x+b=\pm1wTx+b=±1 之间的距离为：

γ=2∥w∥2\gamma=\frac{2}{\|\boldsymbol{w}\|_2}γ=∥w∥22

最大化间隔等价于最小化 ∥w∥22\|\boldsymbol w\|_2^2∥w∥22，因此硬间隔 SVM 的基本形式为：

min⁡w,b12∥w∥22s.t.yi(wTxi+b)≥1,i=1,…,m\begin{aligned} \min_{\boldsymbol w,b}\quad &\frac{1}{2}\|\boldsymbol w\|_2^2 \\ \text{s.t.}\quad &y_i(\boldsymbol w^{\mathrm T}\boldsymbol x_i+b)\geq1, \quad i=1,\ldots,m \end{aligned}w,bmins.t.21∥w∥22yi(wTxi+b)≥1,i=1,…,m

求解方法：#

涉及到二次规划问题，使用拉格朗日乘子法解决问题，我们会得到基本型的“对偶问题”

具体方法不做详解，此处仅做大概阐述：

为每条不等式约束引入拉格朗日乘子 αi≥0\alpha_i\geq0αi≥0。
令拉格朗日函数对 w\boldsymbol ww 和 bbb 的偏导为零，消去原始变量。
得到关于 α\boldsymbol\alphaα 的对偶二次规划问题，同时保留 αi≥0\alpha_i\geq0αi≥0 与 ∑iαiyi=0\sum_i\alpha_i y_i=0∑iαiyi=0 等约束。
可使用二次规划算法或 SMO 求解 α\boldsymbol\alphaα，再恢复 w\boldsymbol ww 与 bbb。因此对偶问题并不是普通的无约束优化。

核函数#

引入原因：#

由于前面的讨论都是基于训练集是线性可分的假设 对于原始空间中线性不可分的数据，可以通过核函数隐式计算高维特征空间中的内积，从而学习非线性决策边界。映射后也不保证数据一定完全线性可分，因此仍可能需要软间隔。

升维思想：#

通过特征映射把数据表示到新的空间，并使用核函数直接计算映射后样本的内积；这样可以得到原始空间中的非线性决策边界。

常用核函数：#

下面给出常用核函数：

软间隔和正则化：#

引入原因：#

前面的硬间隔模型假设训练样本线性可分。实际数据可能包含噪声、类别重叠和异常点，即使使用核函数，也不应要求所有样本都被绝对正确地分开，否则模型可能过拟合。

所以我们引入了软间隔（soft margin），即允许部分样本违反间隔约束或被错误分类。而相应的，先前我们让所有样本正确分类就叫做硬间隔。

正则化思想：#

其实软间隔也就是一种正则化，通过对不希望的到的结果进行惩罚，使得优化过程趋向于希望目标。

支持向量回归#

引入原因：#

我们一开始引入SVM就是为了解决分类问题，而对于回归问题是否也能通过SVM解决呢？🤔

为了解决回归问题，我们引入了支持向量回归，简称SVR(Support Vector Regression)

方法思想：#

在损失函数方面，与传统的回归模型用预测和标记的差别计算损失不同，

SVR 使用 ϵ\epsilonϵ-不敏感损失：当预测误差满足 ∣f(xi)−yi∣≤ϵ|f(\boldsymbol x_i)-y_i|\leq\epsilon∣f(xi)−yi∣≤ϵ 时不产生损失。几何上，这对应预测函数上下各宽 ϵ\epsilonϵ、总宽 2ϵ2\epsilon2ϵ 的容忍带。

如何选择模型#

特征数量适中、强调可解释性或需要快速建立基线时，优先考虑线性模型。
数据中存在清晰的条件规则、特征尺度差异较大或需要直观解释时，可以尝试决策树及其集成方法。
样本量不大但特征维度较高、类别间隔较明显时，支持向量机通常值得尝试。

无论选择哪一种模型，都应回到第二章的评估方法：使用独立验证过程、合适的性能度量和一致的实验设置进行比较。

三类模型的共同点#

它们都在特定假设空间中寻找经验风险较小、同时具有一定泛化能力的函数。线性模型依赖参数约束，决策树依赖划分与剪枝，支持向量机依赖最大间隔与正则化。差异最终都可以理解为不同的归纳偏好。

总结#

线性模型提供简洁基线，决策树提供可读规则，支持向量机提供最大间隔与核技巧。理解三者的表示方式和约束方法，比单独记忆公式更有助于解决实际问题。

机器学习基础：基本概念、评估方法与性能度量

Wed, 15 May 2024 00:00:00 GMT

机器学习不仅是选择一个算法并运行训练。真正完整的实验需要先明确任务、数据和假设，再决定如何划分数据、使用什么指标，以及怎样比较模型。

这篇笔记把《机器学习》第一章和第二章连在一起：第一章回答“机器学习在做什么”，第二章回答“怎样判断它做得好不好”。

学习路线#

理解样本、特征、标记、假设空间等基本概念。
认识独立同分布、未知分布和归纳偏好等基本假设。
区分监督学习、无监督学习等任务类型。
使用留出法、交叉验证法或自助法组织实验。
根据任务选择准确率、查准率、查全率、F1、ROC 或 AUC。
避免用测试集调参，并在比较结论中考虑统计波动。

机器学习的基本概念与假设#

这一部分建立后续章节需要的共同语言，并说明学习算法为什么必须带有归纳偏好。

本书的使用：#

第1章-绪论

计算学习理论#

概率近似正确（Probably Approximately Correct，PAC）描述的是一种学习保证：训练样本由未知分布随机抽取时，学习算法以至少 1−δ1-\delta1−δ 的概率得到泛化误差足够小的模型。

一种常见的不可知 PAC 表述是：

Pr⁡S∼Dm[RD(hS)≤inf⁡h∈HRD(h)+ϵ]≥1−δ\Pr_{S\sim\mathcal{D}^{m}} \left[ R_{\mathcal{D}}(h_S) \leq \inf_{h\in\mathcal{H}}R_{\mathcal{D}}(h)+\epsilon \right] \geq 1-\deltaS∼DmPr[RD(hS)≤h∈HinfRD(h)+ϵ]≥1−δ

其中，SSS 是从分布 D\mathcal DD 独立抽取的训练集，hSh_ShS 是算法根据 SSS 学到的模型，RD(h)R_{\mathcal D}(h)RD(h) 是模型在真实分布上的风险。

ϵ\epsilonϵ 表示允许的误差裕量，δ\deltaδ 表示学习保证失败的概率。公式中的概率来自训练集的随机抽取，而不是“取得某个模型”的概率。

PAC 讨论的是样本复杂度和泛化保证，不能由 ϵ=0\epsilon=0ϵ=0、δ=0\delta=0δ=0 推导出 P 与 NP 的关系。通常只要求二者为足够小的正数。

术语名词#

1.示例 = 特征向量，样本

名词解释:即对某个事件或者对象的全局描述
构成元素:多组(特征:特征值)
样本要根据上下文来判断含义

2.特征 = 属性

名词解释：即对某个事件或对象的一个具体特征的描述

3.样本空间 = 属性空间 = 输入空间

名词解释：即特征张成的空间，空间中每个点对应一个特征向量即样本

4.数据集、训练集、验证集与测试集

训练集用于拟合模型参数。
验证集用于选择模型和超参数。
测试集只用于最终评估，不能参与调参。

一个包含 mmm 个样本的数据集可表示为：

D={x1,x2,…,xm}D=\left\{\boldsymbol{x}_1,\boldsymbol{x}_2,\ldots,\boldsymbol{x}_m\right\}D={x1,x2,…,xm}

若每个样本包含 ddd 个特征，则 xi∈Rd\boldsymbol x_i\in\mathbb R^dxi∈Rd。实际划分比例应根据样本量与任务决定，并不存在固定的“二八分”规则。

5.样例，标记，标记空间

样例=样本+标记

标记：即想预测的结果的实际信息，比如想预测瓜的好坏，实际样本中的信息为”好瓜”/“坏瓜”，

一般表示为：

(xi,yi)(\boldsymbol{x}_i,y_i)(xi,yi)

标记空间 or 输出空间：所有标记的集合

6.假设空间，版本空间

1
假设：学得模型关于数据的潜在规律
2

3
真实or真相：潜在规律本身
4

5

6
假设空间：所有假设构成的集合
7

8
版本空间：与训练集一致的假设构成的集合，由一个或多个假设空间的子集构成

…

基本假设#

我们知道训练出的模型是为了对未知数据进行结果预测

但是为什么模型可以对未知数据进行预测呢？

这里我们引出了机器学习的基本假设。

1.未知分布D#

通常假设样本空间中全体样本服从一个未知“分布” D
此处的“分布”指的是概率论中的概率分布

我们假设数据（包括源数据集和未知数据）背后满足某种规律，

即数据的采样来自一个未知的、潜在的分布D

2.独立同分布（i.i.d）#

我们获得的每个样本都是独立地从这个分布上采样获得的，即“独立同分布”（简称i.i.d）

或者说所有样本都是独立同分布的

一般而言，训练样本越多，我们得到的关于D的信息也越多

3.一些思考#

在现实生活中，大多数样本之间不是独立同分布的，而是相互影响的。

比如说：在淘宝上买衣服的人和买裤子的人，它们之间可能来自不同的分布，可能买衣服的人推荐买裤子的人来淘宝购物。

所以现在在机器学习的前沿领域，

如何突破独立同分布的限制 是一个重大课题

归纳偏好#

归纳偏好对应了学习算法本身所做出的关于“什么样的模型更好”的假设

对假设空间筛选后所得到的版本空间中可能有多个假设这些假设都能够匹配训练集中的训练样本

而如何对版本空间中的假设进行选择呢？🤔

这里引入一个原则or方法论：

奥卡姆剃刀：

若非必要勿增实体
选取多个假设中最简单的。

但是其实感觉没啥用，因为”简单“的定义难以量化。

一个“随机乱猜”的算法有可能优于精心选择的算法

“没有免费的午餐”（NFL）定理：

1
任意算法的“训练集外误差”相等，即不同算法的误差期望相同，无绝对意义上的更优算法。

所以 不能摆脱具体问题 谈论算法的优劣

实际上：还是看测试集再模型上的效果，以及结合特定领域的需求对模型进行选择

机器学习分类#

1.监督学习-有导师学习#

样本有标记

1.1 分类问题-预测 离散值

二分类-正类/负类(反类)

一般取值0/1，文本可通过特征工程转换为数值型变量

一般假设正类和负类是可交换的
多分类 涉及多类别的预测输出

可以转换成二分类问题

1.2 回归问题-预测 连续值

1
预测结果 ∈ R

2.非监督学习-无导师学习#

样本无标记

2.1 聚类算法

离散型变量的分类、分组别
连续型变量的统计个数，进行密度估计

了解数据内在规律

2.2 降维算法

如PCA主成分分析等

…

机器学习的发展#

符号主义：源于数学逻辑，产生明确的概念表示

符号主义认为人工智能源于数理逻辑后来又发展了启发式算法>专家系统>知识工程理论与技术

主要方向：决策树和基于逻辑的学习
```
1
  决策树->模拟人类对概念的判定树形过程
2

3
  基于逻辑的学习-->典型代表：归纳逻辑程序设计(ILP)
```
连接主义：基于神经网络

算法复杂度高，假设空间大，且参数设置缺乏理论指导

经典代表：BP反向传播算法
统计学习：支持向量机(SVM)，核方法

与连接主义关系密切
深度学习：早期连接主义的衍生，基于神经网络，现阶段很流行

模型评估、性能度量与比较#

有了学习任务和假设之后，需要设计可靠的实验。数据划分方式与评价指标会直接影响最终结论。

术语名词#

1.泛化误差与经验误差

泛化误差：在“未来”样本上的误差
经验误差：在训练集上的误差，亦称“训练误差”

训练集样本数越接近数据集数量，经验误差就越小。但是经验误差越小，模型效果就越好吗？

请注意，我们是为了得到泛化能力强的模型，而经验误差≠泛化误差

经验误差很小，会使模型学习到训练样本中的许多无用特征，导致泛化能力变弱 我们称其为过拟合(overfitting)

而与之相对的概念，我们称为欠拟合(underfitting)，其表示的就是模型没有很好的学习到训练样本上的特征，从而也导致泛化能力变弱

2.过拟合与欠拟合

过拟合：模型在训练数据上表现得过于复杂，以至于在未见过的数据上表现不佳。欠拟合：模型在训练数据上表现得过于简单，无法捕捉到数据的内在结构和模式。

出现原因： 1.出现欠拟合的情况，一般是由于样本特征少，模型复杂度低等

2.出现过拟合的情况，一般是由于样本数量少、噪声多，模型复杂度过高等

经验误差就是训练程度的体现，经验误差越小则训练程度越强所以现在，我们可以得出训练程度不能过大也不能过小的结论

那我们能找到一个最佳方案得出最佳的训练程度吗🤔

答案是--------------->不能🙅

原因是：对于千禧年七大数学问题之——“P=NP”问题，只要我们相信”P≠NP”，就无法找出最优解

但是我们依然有相应的解决方法，用于欠拟合与过拟合的问题此处的解决方法我们留待以后解决…

好了，回归本章主题—模型评估与选择

对于模型的选择，我们有三个关键问题：

如何获得测试集？------>评估方法
如何评价性能优劣？------>性能度量
如何判断模型实质差别------>比较检验

1.评估方法#

因为我们无法得知未来数据的输出标记故而需要得到测试集用来评估模型

而测试集有多种划分方法，这里我们给出以下三种

1.1 留出法(hold-out)：#

将数据集直接划分为训练集和测试集

留出法：对数据集的划分方法会影响模型结果；训练集和测试集的数据分布必须保持一致；测试集过大会使模型拟合效果变差，太小会使得测试估计偏小；有一些数据可能从未被训练过

总结：

保证数据分布一致性（比如分层取样）
多次重复划分 (例如: 100次随机划分)
测试集不能太大或太小（例如：1/5~1/3，其实二八分偏多）
可能遗漏数据（随机划分没取到该数据进行训练）

1.2 交叉验证法#

对于 留出法出现可能遗漏数据（随机划分没取到该数据进行训练）的问题

我们引入新的划分方法 k-折交叉验证法可以有效解决该问题

以该图为例：

首先将数据集D随机划分为10个子集，进行十次操作，每一次取其中1个子集为测试集，其余为训练集（实际也可以选取多个子集为测试集）将结果做平均处理

而对于再划分子集的阶段，将测试集中只留有一个数据的方法叫做留一法 留一法每次只留一个样本用于验证，因此单次训练集与原始数据集非常接近。它的数据利用率高，但需要训练 mmm 次，计算成本较高；不同训练集高度重叠，评估结果也可能具有较高方差。

优缺点：

在 kkk 折交叉验证中，每个样本会恰好作为一次验证样本，并在其余 k−1k-1k−1 折中参与训练。较大的 kkk 能提高训练数据利用率，但会显著增加计算成本。

划分时仍要遵守数据的独立结构。例如，同一用户、同一时间序列或同一实体的相关样本不应随意分到训练折和验证折，否则可能产生数据泄漏。

1.3 自助法#

“自助法”(bootstrapping) 基于放回取样 亦称“可重复采样”

从含有 mmm 个样本的原始数据集中进行 mmm 次有放回抽样，可以得到一个大小仍为 mmm 的训练集，但其中会包含重复样本。

某个原始样本在一次抽样中未被选中的概率为 1−1/m1-1/m1−1/m，在 mmm 次抽样后仍未被选中的概率为：

lim⁡m→∞(1−1m)m=1e≈0.368\lim_{m\to\infty} \left(1-\frac{1}{m}\right)^m =\frac{1}{e} \approx 0.368m→∞lim(1−m1)m=e1≈0.368

因此，约有 36.8%36.8\%36.8% 的原始样本不会进入本次自助训练集，可作为包外样本（out-of-bag samples）进行评估；进入训练集的不同原始样本约占 63.2%63.2\%63.2%。

优缺点：

优点：自助法在数据集较小、难以有效划分训练/测试集时很有用，自助法能从初始数据集中产生多个不同的训练集,这对集成学习等方法有很大的好处。

缺点：自助法产生的数据集改变了初始数据集的分布，这会引入估计偏差。但是通过增加数据划分的次数，就可以缓解该影响。

1.4 调参与验证集#

在模型评估与选择的过程中，我们既要选择学习算法，还要对算法的参数进行设定

训练过程中的参数分为两种：

算法参数：亦称“超参数”，由人工设定
模型参数：由训练集训练而成

1.5 重新训练#

模型选择和调参完成后，可以合并训练集与验证集重新训练最终模型，再使用此前从未参与训练和调参的测试集进行一次独立评估。

测试集不是用来选择算法或参数的。如果把测试集也用于重新训练，就不能再用同一测试集报告无偏的泛化性能。部署前确实可以使用全部已有数据训练，但之后应准备新的独立数据进行评估。

2.性能度量#

2.1 错误率和精度#

错误率定义：

E(f;D)=1m∑i=1mI ⁣(f(xi)≠yi)E(f;D) = \frac{1}{m} \sum_{i=1}^{m} \mathbb{I}\!\left(f(\boldsymbol{x}_i)\neq y_i\right)E(f;D)=m1i=1∑mI(f(xi)=yi)

精度定义：

acc⁡(f;D)=1m∑i=1mI ⁣(f(xi)=yi)=1−E(f;D)\begin{aligned} \operatorname{acc}(f;D) &= \frac{1}{m} \sum_{i=1}^{m} \mathbb{I}\!\left(f(\boldsymbol{x}_i)=y_i\right) \\ &=1-E(f;D) \end{aligned}acc(f;D)=m1i=1∑mI(f(xi)=yi)=1−E(f;D)

然而对于不同的任务需求，仅仅用错误率和精度是不够的，故引出查准率、查全率、F1的概念

2.2 查准率、查全率、F1#

二分类任务：#

1
现有一瓜田含10000个瓜，其中有100个好瓜，利用学习器挑瓜

查准率或精确率（precision）：挑出的瓜中好瓜所占的比例。
查全率或召回率（recall）：所有好瓜中被成功挑出的比例。
F1-score：查准率与查全率的调和平均。

注意，precision 不是 accuracy。accuracy 表示全部样本中预测正确的比例。

在选瓜任务中我们的目标是：

在挑出来的瓜中尽可能都是好瓜
瓜田中的好瓜尽可能多地被挑出来很直观的可以感受到查全率越大(如挑出越多的瓜，好瓜被挑出的比例也就越大），查准率就会越低

混淆矩阵：

其中查准率P和查全率R的定义为：

P=TPTP+FPP=\frac{TP}{TP+FP}P=TP+FPTPR=TPTP+FNR=\frac{TP}{TP+FN}R=TP+FNTP

F1即综合考虑两者效果:

F1=2PRP+RF_1 = \frac{2PR}{P+R}F1=P+R2PR

等价地：

1F1=12(1P+1R)\frac{1}{F_1} = \frac{1}{2} \left(\frac{1}{P}+\frac{1}{R}\right)F11=21(P1+R1)

多分类任务：#

2.3 ROC与AUC#

3.比较检验#

从任务到结论的基本流程#

一个较规范的机器学习实验可以按以下顺序进行：

定义输入、输出和业务目标。
明确数据来源及其分布假设。
划分训练集、验证集和测试集。
只使用验证集选择模型与超参数。
根据错误代价选择合适的性能指标。
最后一次使用测试集报告泛化性能。
比较多个模型时说明随机种子、方差和统计检验方法。

总结#

第一章提供机器学习的概念框架，第二章提供验证结论的实验框架。只有把“学习什么”和“如何评价”连接起来，模型结果才具有可解释性和可复现性。

定义类和方法

Tue, 14 May 2024 00:00:00 GMT

对象是实例化的类，所以对象也叫做实例。

一个实例(对象)由属性 (变量or数据)和方法 (行为)构成

所以属性和方法叫做对象的成员

对象的属性叫做成员变量or实例变量(这俩也有点区别)

对象的方法叫做成员方法

在面向对象编程中，成员变量和实例变量通常指的是相同的概念，但它们的使用和含义略有不同，具体取决于上下文：

成员变量：
- 成员变量是类的一部分，它们定义了类的状态或属性。
- 每个成员变量都是类的蓝图，用于创建对象时存储数据。
- 成员变量可以是静态的或非静态的（实例变量）。
实例变量（非静态变量）：
- 实例变量是成员变量的一种，它们属于类的特定实例（对象）。
- 每个实例变量的副本都存储在创建的对象中，这意味着每个对象都有自己的实例变量副本。
- 实例变量的值对于每个对象都是独立的，一个对象的实例变量改变不会影响另一个对象的相应变量。
静态变量（类变量）：
- 静态变量也是成员变量的一种，但它们不属于任何特定的实例。
- 静态变量只有单一的副本，所有类的实例共享这个副本。
- 静态变量通常用于存储类级别的数据，如配置信息或计数器。

以下是一些关键点的对比：

作用域：实例变量属于对象，每个对象都有其独立的副本；静态变量属于类，所有实例共享同一个副本。
生命周期：实例变量随对象的创建而存在，随对象的销毁而消失；静态变量随类的加载而存在，随程序结束或类被卸载而消失。
访问：实例变量可以通过对象的引用访问；静态变量可以通过类名直接访问，也可以通过对象引用访问。

下面是一个简单的Java类示例，展示了实例变量和静态变量的使用：

1
public class Car {
2
    // 实例变量，每个Car对象都有自己的颜色和速度
3
    String color;
4
    int speed;
5

6
    // 静态变量，所有Car对象共享同一个制造数量
7
    static int manufacturingCount = 0;
8

9
    public Car(String color) {
10
        this.color = color;
11
        // 每创建一个Car对象，制造数量增加
12
        manufacturingCount++;
13
    }
14

15
    public void drive() {
16
        // 实例方法，影响特定对象的速度
17
        speed += 10;
18
    }
19

20
    public static int getManufacturingCount() {
21
        // 静态方法，返回所有Car对象共享的制造数量
22
        return manufacturingCount;
23
    }
24
}

展开收起

在这个例子中，color 和 speed 是实例变量，因为它们属于每个 Car 对象。而 manufacturingCount 是一个静态变量，因为它属于 Car 类本身，并且所有 Car 实例共享这个变量。drive 方法是一个实例方法，因为它操作特定 Car 对象的速度。getManufacturingCount 是一个静态方法，因为它返回的是类级别的信息。

在Java中，类（Class）是用来创建对象的模板或蓝图。类本身不直接持有数据，但类定义中可以包含成员变量（也称为字段或属性），这些成员变量是用来存储数据的。当你根据类创建一个对象（实例）时，每个对象都会有自己的成员变量副本，这些副本中存储的就是数据。

例如，假设有一个名为 Person 的类：

1
public class Person {
2
    String name;
3
    int age;
4

5
    public Person(String name, int age) {
6
        this.name = name;
7
        this.age = age;
8
    }
9

10
    // 其他方法...
11
}

在这个 Person 类中，name 和 age 就是成员变量，它们可以在类的实例中存储数据。当你创建 Person 类的对象时：

1
Person person1 = new Person("Alice", 30);
2
Person person2 = new Person("Bob", 25);

person1 和 person2 都是 Person 类的实例，它们各自拥有自己的 name 和 age 数据。person1 的 name 是 “Alice”，age 是 30；而 person2 的 name 是 “Bob”，age 是 25。

类本身只是一个定义，它不包含数据，但是它定义了如何创建可以包含数据的对象。

在面向对象编程（OOP）中，成员是类的一部分，它代表了类的特性（属性）或行为（方法）。成员是构成类的基本元素，它们定义了类的功能和数据结构。以下是成员的两种主要类型：

成员变量（属性）：
- 成员变量是类的一部分，用于存储数据。它们是类的属性，通常用于描述对象的状态。
- 成员变量可以是私有的（private），这意味着它们只能被类内部的方法访问，或者可以是公有的（public），这意味着它们可以被任何其他类访问。
- 成员变量可以有默认的访问修饰符（没有显式指定），这通常是包级私有的（即同一个包内的其他类可以访问）。
成员方法（行为）：
- 成员方法是类的一部分，定义了对象的行为。它们是类的操作，用于描述对象可以执行的动作。
- 成员方法可以有不同的访问修饰符，如public、private或protected，这决定了它们可以被谁调用。
- 方法还可以是静态的（static），这意味着它们属于类而不是类的实例，并且可以在不创建类实例的情况下被调用。

除了成员变量和成员方法，类的成员还可以包括：

构造方法：特殊的方法，用于创建类的对象。它们的名字必须与类名相同，并且没有返回类型。
静态初始化块：用于初始化静态变量的代码块，它在类加载时执行一次。
实例初始化块：用于初始化非静态变量的代码块，它在每次创建类的新实例时执行。
内部类：定义在另一个类内部的类，它可以访问外部类的成员，包括私有成员。

成员变量和方法的可见性和行为可以通过使用不同的访问修饰符和非访问修饰符来控制。例如：

1
public class ExampleClass {
2
    // 成员变量
3
    private int privateVar;
4
    protected int protectedVar;
5
    int packageVar; // 默认访问修饰符，也称为包级私有
6
    public int publicVar;
7

8
    // 构造方法
9
    public ExampleClass() {
10
        // 构造逻辑
11
    }
12

13
    // 成员方法
14
    public void publicMethod() {
15
        // 方法逻辑
16
    }
17

18
    private void privateMethod() {
19
        // 私有方法逻辑
20
    }
21

22
    // 静态方法
23
    public static void staticMethod() {
24
        // 静态方法逻辑
25
    }
26

27
    // 实例初始化块
28
    {
29
        // 实例初始化逻辑
30
    }
31

32
    // 静态初始化块
33
    static {
34
        // 静态初始化逻辑
35
    }
36
}

展开收起

在这个例子中，ExampleClass 包含了不同类型的成员，包括私有和公有的成员变量，一个构造方法，公有和私有的成员方法，以及静态方法。静态初始化块和实例初始化块分别用于初始化静态成员和非静态成员。

在Java语言中，this 是一个特殊的关键字，它指向当前对象的引用。每个对象都有一个隐式的 this 引用，指向它自己。以下是 this 关键字的一些常见用法：

区分成员变量和局部变量：当局部变量名与成员变量名相同时，可以使用 this 关键字来区分它们。

1
public class MyClass {
2
    private int number;
3
    public MyClass(int number) {
4
        this.number = number; // 使用 this 来引用成员变量
5
    }
6
}

在构造函数中调用另一个构造函数：可以使用 this() 来调用同一个类中的另一个构造函数。

1
public class MyClass {
2
    private int number;
3
    public MyClass() {
4
        this(0); // 默认构造函数调用带参数的构造函数
5
    }
6
    public MyClass(int number) {
7
        this.number = number;
8
    }
9
}

在方法中返回当前对象的引用：有时，方法需要返回调用该方法的对象的引用，这时可以使用 this。

1
public class MyClass {
2
    public MyClass getNext() {
3
        // 一些逻辑...
4
        return this; // 返回当前对象的引用
5
    }
6
}

在参数中传递当前对象：当需要将当前对象作为参数传递给另一个方法时，可以使用 this。

1
public class MyClass {
2
    public void doSomething(MyClass other) {
3
        other.copy(this); // 将当前对象作为参数传递
4
    }
5
    public void copy(MyClass other) {
6
        // 复制逻辑...
7
    }
8
}

在匿名类和内部类中引用外部类的实例：在匿名类或内部类中，可以使用 this 关键字来引用外部类的实例。

1
public class OuterClass {
2
    public void doSomething() {
3
        new Thread(new Runnable() {
4
            public void run() {
5
                OuterClass.this.doWork(); // 调用外部类的 doWork 方法
6
            }
7
        }).start();
8
    }
9
    public void doWork() {
10
        // 工作逻辑...
11
    }
12
}

在重载方法中使用：当类中有多个同名方法但参数列表不同时，可以使用 this 调用其他重载的方法。

1
public class MyClass {
2
    public void print(int number) {
3
        System.out.println("Number: " + number);
4
    }
5
    public void print(String text) {
6
        System.out.println("Text: " + text);
7
    }
8
    public void printAll(int number, String text) {
9
        this.print(number); // 调用第一个 print 方法
10
        this.print(text); // 调用第二个 print 方法
11
    }
12
}

this 关键字是Java中一个非常有用的工具，它允许程序员在各种情况下引用当前对象。

Hexo搭建实遇问题

Mon, 13 May 2024 00:00:00 GMT

1.spawn_failed问题#

原因分析：#

其实出现这个问题，很大可能是因为https和http的proxy的对应的分别是https和http开proxy server，

而https的proxy server可能无法正常工作。

解决办法：#

修改_config.yml文件的deploy部分，将https 修改为http url 或者设置为git url, 配置为https oauth2 加token

设置为git url(推荐) 亲测有效

1
    deploy:
2
        type: git
3
        repo: git@github.com:your_github_id/your_github_id.github.io.git
4
        branch: gh-pages

2.头像无法显示问题#

原因分析：#

不明原因，猜测是路径问题

解决方法1：#

将想要显示的头像图片存入本地文件夹
在根目录下进入git bash使用hexo g和hexo d上传代码到github仓库
在github仓库找到该图片，鼠标右键复制图片链接
修改主题配置文件，如我修改的为config.butterfly.yml文件

1
#Avatar (頭像)
2
avatar:
3
  img: 输入你复制的图片链接
4
  # effect为true 则鼠标放于图片上，会使图片一直旋转
5
  effect: false

解决方法2：#

更改默认头像路径

默认路径："C:\Users\陈荣伟\Desktop\Blog\Hexo-blog\blog\themes\butterfly\source\img\friend_404.gif"

把需要的头像名称改为friend_404.gif，把friend_404.gif 重命名成别的即可

_config.butterfly.yml内的配置文件

1
# Replace Broken Images (替换无法显示的图片)
2
error_img:
3
  flink: /img/friend_404.gif
4
  post_page: /img/404.jpg

3.本地预览正常，但部署到GitHub 网站背景图片不加载#

解决方法：#

分清背景图片是放在本地还是别处？
记得用图片的网络链接，确保图片地址没有错误。
然后清除浏览器缓存再试试

hexo clean命令#

1
hexo clean

清除缓存文件 db.json 和已生成的静态文件 public。

网站显示异常时可以执行这条命令试试。

接着依次运行代码：

1
hexo g

1
hexo d

终极方法#

删除.deploy_git和public文件

4.插入图片的显示问题#

参考文章：

在hexo博客中插入图片的方法_hexo插入图片-CSDN博客

插入图片的方法在完成了博客搭建、发布文章后，如果我们想在文章中插入图片，该怎么做呢？

如果图片保存在本地

方法一：全局资源文件夹#

即，将所有文章的资源统一用一个全局资源文件夹管理。

此方法的优点是比较简便，并且当多篇文章需要引用同一资源时，也比较方便。

缺点是当文章很多时，各个文章的图片都在同一文件夹，不便管理。

具体方法：在hexo文件夹下的source目录下，新建一个文件夹叫images(名字随意)，将要插入的图片放在该文件夹中。 md文档内，使用的格式，圆括号内的链接地址写(/images/name.jpeg)。这里的 / 指的是根目录，对于hexo，资源文件的根目录就是source(可以在config文件里修改资源的根目录)

例如，在md文档中写：![图片](/images/20.jpeg "甘雨") 同时将“20.jpeg”这个图片文件放在hexo文件夹/source/images下，则图片可以上传到博客。

方法二：文章资源文件夹#

即，对于每篇文章，使用一个文件夹管理资源。

此方法的优点是，当文章很多时，便于结构化管理。

缺点是，比方法一麻烦一点。

具体方法：

2.1 修改hexo文件夹中的_config.yml文件，如下：

1
post_asset_folder: true
2
marked:
3
  prependRoot: true
4
  postAsset: true

2.2 在终端cd到hexo文件夹，hexo new 文章名 命令创建一篇新文章，此时会在hexo文件夹的source目录下，自动创建一个文件夹和文章名.md文件。

注：如果文章名中有空格，务必将整个文章名用双引号引起来。如果文章名中没有空格，可以加双引号，也可以不加。

例如，执行hexo new “如何发布文章到hexo博客上”，如下：

会在source/_post文件夹下生成一个”如何发布文章到hexo博客上.md”文件。如下：

可以看到，同时还生成了一个同名的资源文件夹。

2.3 我们可以将所有与该文章有关的资源（包括图片）放在这个关联文件夹中 2.4 通过相对路径来引用图片资源。

例如，将“1.jpeg”这个图片资源放在该文件夹中，并在.md文件中像这样引用图片：，这个方法在资源较多时方便管理。

另附Typora编辑器中不显示图片的解决方案：安装下面的插件，可以使Typora等Markdown编辑器预览以及Hexo发布预览时，均能正常显示图片。 npm install hexo-asset-img --save 这样，如果你使用Typora编辑markdown文档，在typora内也可以显示图片了。

5.4000端口占用问题#

查看端口:#

1
netstat -ano

1
    每一列分别对应：协议、本地地址、外部地址、状态、PID
2

3
  参数详解：
4
    -a            显示所有连接和侦听端口。
5
    -n            以数字形式显示地址和端口号。
6
    -o            显示拥有的与每个连接关联的进程 ID。

注：其余参数可使用help命令查看：

netstat -help

查询出的端口数量很多，我们可使用findstr命令进行过滤：

1
netstat -ano | findstr "被占用的端口"

释放被占用的端口：#

过滤出需要释放的端口后，在cmd窗口输入task kill命令 可释放被占用的端口：

1
taskkill -f -t /pid "占用端口的程序的pid"

6.网页渲染Latex问题#

修改主题配置文件_config.butterfly.yml：

1
mathjax:
2
  enable: true
3
  # true 表示每一頁都加載mathjax.js
4
  # false 需要時加載，須在使用的Markdown Front-matter 加上 mathjax: true
5
  per_page: false

以下操作在你 hexo 博客的目录下 (不是 Butterfly 的目录):

安装插件

1
npm uninstall hexo-renderer-marked --save
2
npm install hexo-renderer-kramed --save

配置 hexo 根目录的配置文件_config.yml

1
kramed:
2
  gfm: true
3
  pedantic: false
4
  sanitize: false
5
  tables: true
6
  breaks: true
7
  smartLists: true
8
  smartypants: true

7.引入CSS文件#

打开config.butterfly.yml文件

CTRL+F 搜索下面的代码，增加<link>标签即可

1
inject:
2
  head:
3
    # - <link rel="stylesheet" href="/xxx.css">
4
    - <link rel="stylesheet" href="/css/categories_dark_fit.css">
5
    - <link rel="stylesheet" href="/css/butterfly_article_double_row.css">
6
  bottom:
7
    # - <script src="xxxx"></script>