Chang Luo

智能的本质是对抗不确定

Thu, 29 Jan 2026 00:00:00 +0000

2019 年春，在晨光熹微的餐厅里，我独自坐在角落，思考智能如何产生。餐厅的名字已经忘了，只记得离开时，老板送我一根棒棒糖。糖很甜，我舔着糖回家。此后多年，这个问题一直萦绕在我心间，却没有答案。时间来到 2026 年，当我再度思考这个问题，发现如今对智能的理解不是太少，而是太多。

一千个人对智能有一千五百种理解。

Ilya 说，智能的本质是压缩。

这是一种相当工程的理解。想象你学了很多驳杂无用的知识。某天偶得机缘，将它们融会贯通。原本分散在大脑中的知识骤然凝聚、浓缩。此刻，它们占据比往常更少的存储空间，却拥有更快的推理速度。这就是压缩。

融会贯通的关键，在于找到引发知识凝聚的「内在关联」。在深度学习中，找这种内在关联有一种方法，叫作「注意力机制」。其虽名为注意力，却和注意力关系不大，本质上是一种搜索。通过反复迭代 Q, K, V 三矩阵，逐渐精炼出更好的 Q（问题），更好的 KV（答案的键值），从而实现对文本信息的高维抽取。

Ilya 的理解已经足够触及本质，但我更想给出我的版本。如果 Ilya 是工程视角，回答的是如何训练出智能；那我就是演化视角，试图分析智能将往何处去。

智能的本质是泛化，而泛化的本质是对抗不确定。

这句话是未经允许擅自出现在我脑海中的。它是一个典型的三段论：因为智能的本质是泛化，而泛化的本质是对抗不确定，所以智能的本质是对抗不确定。

虽然这句话属于浴中奇思，但推究下来居然挺有道理。早期智能只能完成图像识别、命名实体识别、文本摘要这种零散琐碎的任务。随着模型的演化，泛化能力逐渐增强，最终在语言这种泛化能力极强的模态中，诞生了大语言模型这个庞然大物。

业界目前有种认知，就是大语言模型有缺陷，是因为缺少对物理世界的感知，所以大模型的下一站应该是「世界模型」。我认同这种观点，因为这是沿着泛化能力逐渐增强的路子往下走的。人类正是因为拥有无比强大的泛化能力，才能在自然界中生存下来。模型如果要超越人类，即 AGI，必然要在泛化性上超越人。所以在泛化性上做横向拓展，应该是确定的下一步。

至于泛化的本质是对抗不确定，这个更好理解了。一个常见的用于解释泛化性的例子是：一个苹果被咬了一口，如果模型的泛化性好，依然可以被识别为苹果。泛化本身做的就是对抗不确定的事情，这个描述倒是浅白到无需解释。

在树莓派上搭建家用 Agent 服务

Sun, 18 Jan 2026 00:00:00 +0000

使用树莓派搭建 dive-into-langgraph/app 服务，在家庭局域网内部使用。

一键部署脚本：agent-server

一、制作 TF 卡

Note: 你可以参考我的这篇博客《树莓派 5 装机指南》，它写得更详细一些。但部分信息已经过时，请注意甄别。

1）下载

你需要下载两样东西：

Raspberry Pi Imager：将镜像写入 TF 卡的工具
Ubuntu 24.04.3 LTS：树莓派的 Ubuntu 镜像

Ubuntu 镜像有两种版本：桌面版、服务器版，我们下载服务器版。下载的时候可以检查一下，安装包的文件名应该是这个 ubuntu-24.04.3-preinstalled-server-arm64+raspi.img.xz

2）将镜像写入 TF 卡

根据 Raspberry Pi Imager 的指引，完成镜像烧录的过程就好了。并没有什么难的。唯一需要注意的是，由于我们已经下载了 Ubuntu 镜像，所以这里要选「使用自定义镜像」。

二、首次启动 Ubuntu

烧录完成后，按以下步骤操作：

先断电，然后将 TF 卡插入板子
连接外接显示屏、键盘、网线
最后插入电源

一般来讲，插电即可点亮。这时回车一下，即可输入账号密码，初始账密是：


账号	ubuntu
密码	ubuntu

输完账密，它会接着让你设置新密码。这里流程设计得有点人机，需要注意看提示，不然容易卡关。温馨提示：你输入 ubuntu 的次数比你想象中更多。

三、环境配置

1）更新软件包

# 更新软件源的索引列表
sudo apt update

# 根据更新后的索引，升级所有可更新的软件包
sudo apt upgrade -y

2）安装 pipx 和 uv

先安装 pipx，再用它安装 uv：

RAG：大模型时代的搜索基座

Sat, 27 Dec 2025 00:00:00 +0000

没有一条帆船能吹动自己行驶，它需要外面的风。 – 因可觅《量子离歌》

大模型的训练数据有截止日期，在此之后的事它不知道；大模型的参数量有限，无法容纳所有专业知识。也就是说，大模型在实时性和专业性上都有所欠缺。

如何让大模型变得实时且专业呢？最省力的方法是“打小抄”。知识库 就像大模型的“小抄”。在回答问题之前，先瞅一眼小抄，看有没有与问题相关的内容。如果有，就从知识库中取回这段内容，结合大模型的推理能力，生成最终答案。

这里「打小抄」的动作，就是 RAG（Retrieval-Augmented Generation, 检索增强生成）。

Note: 使用知识库可以让大模型的回答有据可依、减少幻觉，代价是需要承担知识库的构建成本。尤其当知识库的规模较大时，有必要想想是否值得支付对价。毕竟，通过扩大知识库的方式提升 Agent 性能，多少有点「用有限对抗无限，用确定对抗不确定」的意思。虽然我们总是在提起 RAG 时提到知识库，但 RAG 是一种检索技术，它可以检索任何内容。比起检索需要手动构建的知识库，用来检索联网内容、历史对话也是可以的，而且性价比很高。你的下一个检索对象，又何必是知识库。

一、提示词模板

RAG 做的事情并不复杂，就是从知识库中召回与用户问题有关的内容，作为上下文注入到 提示词模板 (Prompt Template) 中。

下面是一个提示词模板：

{context}

---

基于上面给出的上下文，回答问题。

问题：{question}

回答：

使用该模板时，将召回文本填入 {context}，将用户问题填入 {question}。然后把填好的提示词模板交给大模型推理。

RAG 主要做了两件事：一是从知识库中召回与用户问题有关的文本，二是使用提示词模板拼接召回文本与用户问题。拼接很容易做到，难度主要集中在召回上。在下一小节中，我将介绍如何召回与用户问题有关的文本。

二、向量检索

完成「召回与用户问题有关的」这件事，需要用到检索器。实现检索器的方式有很多，比如基于关键词检索的 BM25 算法，但本节主要介绍基于 Embedding 的检索方法：向量检索。

1）从文本向量化说起

Embedding 是一种将文本转为向量的技术。它的输入是一段文本，输出是一个定长的向量。

"好喜欢你" --> [0.190012, 0.123555, .... ]

将文本转为向量的目的，是把语义相近的词分配到同一片向量空间。所以，一对近义词转成向量后，它们的向量之间的距离通常比其他词更近。比如，足球和篮球在向量空间中的距离更近一些，而足球和篮筐之间的距离更远。Embedding 的本质是压缩。从编码角度讲，自然语言存在冗余信息。Embedding 相当于对自然语言进行重编码，用最少的 token 表达最多的语义。

Embedding 在多语言场景下也有优势。经过充分训练的 Embedding 模型，会将多语言内容在语义层面上对齐。也就是说，一个向量可以在多语言环境中保持同一语义。这种特性让大模型得以兼容并包。即使加入多语言材料，也不会因为字面上的词不同，而产生“理解”上的混乱。

2）向量检索的原理

由于 Embedding 模型具有将相似语义的词训练成距离相近的向量的特性，我们可以把「用户问题」与「知识库内容」都转成 Embedding 向量。然后计算向量之间的距离。向量之间的距离越小，则语料之间的相似度越高。借助这个原理，最后返回知识库中与问题向量距离最小的 Top-K 份语料即可。

《LangGraph 1.0 完全指南》发布

Sun, 23 Nov 2025 00:00:00 +0000

经过三个星期的努力，《LangGraph 1.0 完全指南》终于面世啦！

10 月中旬，LangGraph 1.0 发布。开发团队承诺这是一个稳定版本，未来不会大改。因此，现在正是学习它的好时候。

LangGraph 是由 LangChain 团队开发的开源智能体框架。使用时它俩是紧密耦合的：LangChain 提供底层功能，LangGraph 负责状态管理。因此，两个库的文档都需要学习，这无疑加重了使用者的负担。为了让大家快速入门，我将两个库的主要功能提取出来，分成 13 个章节进行介绍。

这是一个开源电子书项目，使用 GitHub Action 自动构建，欢迎 Pull Request。如果你觉得本教程对你有帮助，也欢迎 Star 本教程仓库 luochang212/dive-into-langgraph。

一、在线资源

可以通过以下链接，访问本项目的仓库和在线文档：

资源	链接
GitHub 仓库	luochang212/dive-into-langgraph
电子书	《LangGraph 1.0 完全指南》

二、章节介绍

本教程的内容速览：

序号	章节	主要内容
1	快速入门	创建你的第一个 ReAct Agent
2	状态图	使用 StateGraph 创建工作流
3	中间件	使用自定义中间件实现四个功能：预算控制、消息截断、敏感词过滤、PII 检测
4	人机交互	使用内置的 HITL 中间件实现人机交互
5	记忆	创建短期记忆、长期记忆
6	上下文工程	使用 State、Store、Runtime 管理上下文
7	MCP Server	创建 MCP Server 并接入 LangGraph
8	监督者模式	两种方法实现监督者模式：tool-calling、langgraph-supervisor
9	并行	如何实现并发：节点并发、`@task` 装饰器、Map-reduce、Sub-graphs
10	RAG	三种方式实现 RAG：向量检索、关键词检索、混合检索
11	网络搜索	实现联网搜索：DashScope、Tavily 和 DDGS
12	Deep Agents	简单介绍 Deep Agents
13	调试页面	介绍 langgraph-cli 提供的调试页面

三、拓展阅读

以下是推荐阅读的文档和教程：

使用 Docker Compose 部署大数据集群：Spark + Hadoop + Hive + JupyterLab

Sat, 15 Nov 2025 00:00:00 +0000

麻雀虽小，五脏俱全。

GitHub 项目地址：bigdata-env

引子

我有两台树莓派。

凭借超高颜值，安安静静地摆在那里，就是超绝桌搭。担心没有实用性？有的兄弟，包有的。装上 JupyterLab，它是数据科学工作站；装上 Kali Linux，它是黑客界的瑞士军刀；装上 llama.cpp，它是你的私有 LLM 推理服务器。

你可能不屑一顾，这些事一台树莓派也能搞定，何必弄两台呢？看来只有做一些两台机器才能办到的事，才算物尽其用。因此，我计划部署一个大数据集群。部署大数据集群是个技术活，不要期待一开始就在硬件上部署。可以先在 Docker Compose 上跑通，再尝试硬件部署。

Note: 如果对装机过程感兴趣，可以参考我的博客《树莓派 5 装机指南》

一、集群功能

「大数据集群」是个宽泛的词儿。

装了 Spark 的，可以是大数据集群；装了 Spark + Hadoop 的，也可以是大数据集群。那么到底要装到什么程度呢？这取决于我们的需求。作为常年耕作在数据一线的工程师，我认为基础需求包括：

必须能分布式计算
必须能分布式存储
必须可以建分区表
必须能使用分布式机器学习库 pyspark.ml
必须有调度工具（当然 crontab 也算）
必须有 JupyterLab

我的目标是搭建一个满足这些需求的集群。当然，我们没有必要从零开始搭建，因为前人已经有很优秀的工作。只需要基于前人的工作做一些拓展，就能实现我们想要的功能。s1mplecc 大佬的《使用 Docker 快速部署 Spark + Hadoop 大数据集群》就是一个很棒的基础工作。

大佬已经实现了 Spark + Hadoop 集群，我只需要新增以下内容：

沿用一主（Master）二从（Worker）的配置
启用 Worker 节点的 DataNode 以支持数据同步
安装 Hive 环境
安装并初始化 miniconda3
安装与 Spark 版本配适的 Python 和 PySpark
安装 JupyterLab

主要增加了 Hive、JupyterLab 和 miniconda3。Hive 让我们更轻松地管理分区表；JupyterLab 提供了用于调试开发的浏览器界面；miniconda3 用作 Python 包管理。

阿里发布新版 Quick BI，聊聊 ChatBI 的底层架构、交互设计和云计算生态

Sat, 06 Sep 2025 00:00:00 +0000

8月28日，阿里云发布了数据分析工具 Quick BI 的全新版本。它是大模型应用在 BI 行业的最新实践。Quick BI 在云计算基础设施之上，搭建了一个 ChatBI 应用。阿里为这个应用起了一个拟人化的名字：智能小Q。智能小Q允许用户以对话的形式探索数据。无需写 SQL，只需与小Q对话，即可获得想要的统计信息。

智能小Q其实是一个多智能体系统（multi-agent system），包含多个 Agent：

报告 Agent
问数 Agent
搭建 Agent
解读 Agent

这些 Agent 均由领域大模型驱动。

Note: 领域大模型经过 SFT、RL 微调，可将业务知识迁移泛化到同类任务中，从而在特定领域获得更优表现。此外，领域大模型的参数量小、推理速度快，也是优势之一。

一、智能小Q能做什么？

下面介绍智能小Q的两种模式：问数和解读。

1）问数界面

当用户提问：“店日均杯量是多少？”小Q可以找到数据并可视化，这就是“问数”。

2）解读界面

解读界面允许用户筛选面板中的数据，并基于筛选后的数据向小Q提问。

将「筛选后的数据」作为上下文向小Q提问有什么优势？

一方面，直接引用数据源意味着大模型无需去猜你想分析哪张表，节省了宝贵的 token；另一方面，直接引用提问涉及的数据范围，有助于大模型关注到真正有用的线索，避免大模型因为找不到重点，变得泛泛而谈。

在与智能体的对话中，明确引用所指对象是好文明！

二、拆解 Quick BI 技术路径

Quick BI 的底层架构是 Agent + 数据库。只要有这两个核心模块，你也能做出简易的 ChatBI，这一点在我的开源项目 luochang212/clickhouse-chatbi 中亦有记载。其中，Agent 对 Quick BI 的实现尤为关键。

先来盘一盘 Agent 框架有哪些能力？

能力	技术	代表	偏向
路由	Router	ChatGPT	模型
检索	RAG	LlamaIndex	工程
状态	Session	Google ADK	工程
记忆	Memory	Letta	工程
交互	ReActChat	Qwen Agent	模型
工具	MCP	Claude	工程
规划	Supervisor	LangGraph	工程
安全	Guardrails	OpenAI Agents	工程

* 上面的「代表」不是 SOTA 的意思，只是我第一个想到的例子

耶是 ClickHouse！我们有救了！！

Sat, 26 Jul 2025 00:00:00 +0000

本来我懒得装，但是 MySQL 太慢了，遭不住，咱还是把 ClickHouse 装起来吧。

GitHub 项目地址：chat-to-clickhouse

在《Agent 实战：智能路由、任务拆解和链路工程》一文中，我实现了一个简单的 ChatBI，它能查询 MySQL 数据库。对于小批量数据量，MySQL 尚可应付，但是当数据量来到千万量级时，一次 MySQL 查询将消耗数秒甚至数十秒，这么长的等待时间是用户难以忍受的。而且 Agent 还有一个技术问题，它的 NL2SQL 尚未做到 one-shot，也就是说，在拿到最终结果前，它也许需要多次试错，这将进一步拉长查询时间。

如何无痛解决查询效率低下的问题呢？很简单，只需要换数据库就可以做到。这便引入今天的主角：ClickHouse。

一、分析利器

ClickHouse 是 Yandex 旗下的一款开源的列式存储数据库，专为 联机分析处理 (OLAP) 场景设计。在做数据分析时，它比传统数据库快几倍到几十倍。分析场景的核心需求是「聚合计算」，即 GROUP BY 子句下的 SUM, AVG, COUNT 操作，这些正是 ClickHouse 的强项。

为什么它的聚合计算如此之快呢？因为它具有如下特性：

列式存储：顾名思义，列存的数据是按列存储的。这种存储方式可以减少无效 I/O，因为列存可以只读取查询中涉及的列。而非行存那样，读取整行后再丢掉不需要的列
并行计算：列存的另一个优势是数据更容易切分。单列数据的连续性和同构性更强，无需考虑与其他列的关联，因此可以更方便地按维度（如时间区间、数值分段）拆分并分配到不同节点。当然，这种设计的代价是使得插入操作变得更加昂贵
物化视图：物化视图可以把高频分析的结果提前算好存在表里，后续查询直接读结果，无需重新计算

二、安装过程

用 Docker 安装，过程相对简单。工业界在集群上装，比咱们这个复杂不少。

1. 配置 Docker 镜像源

中国大陆地区下载镜像，需要配置镜像源。

对于 Linux 系统，需要在 /etc/docker/daemon.json 文件中配置镜像源（如下）。Windows 和 MacOS 系统更方便一点，可以直接在 Docker Desktop 的 Settings -> Docker Engine 页面修改 daemon.json 文件。

新瓶装旧酒：纸牌魔术 MCP

Sat, 12 Jul 2025 00:00:00 +0000

Chico 和 Dico 是两名魔术师，他们有一个经典纸牌魔术：抽五张扑克牌，根据前四张，猜第五张是什么。完成这个魔术不需要任何魔术师的技巧，它完全建立在数学原理之上。只需要一点数学知识和充分的练习，你也能表演这个魔术。

GitHub 项目地址：card-magic-mcp

五年前，我写了一篇文章《用魔法打败魔法》，介绍 Chico & Dico 魔术的数学原理，并用 Python 实现了这个魔术。随着时代的发展、科技的进步，今天我们有更简单的方法来玩这个魔术，不需要运行 Python，不需要看懂公式，只需要打开 ModelScope 和大模型对话，就可以轻松体验这个魔术↓↓↓

访问 ModelScope Playground: card-magic-mcp

下面我将介绍这个魔术的数学原理和算法实现，然后讲解如何用 FastMCP 将魔术流程包装成大语言模型可以调用的工具（MCP Server）。

Chico & Dico 的魔术

Chico 和 Dico 是两位魔术师，他们经常表演的一个魔术是这样的：Chico 将一副 52 张的扑克牌交给观众，让他抽取其中的 5 张。然后 Chico 将这 5 张牌按一定的顺序重新排列，再将其还给观众。上述整个过程 Dico 都是看不见的。然而，当观众按 Chico 排好的顺序依次展示前四张牌之后，Dico 却能准确地说出第五张牌是什么。

乍一看这个魔术很神奇。随机抽取 5 张牌，你能从前 4 张牌中看出第 5 张牌是什么吗？对于普通人来说，当然不行。Chico 和 Dico 的秘诀在于 Chico 有机会将扑克重新排序。如果两人事先约定好某种协议，Chico 有可能通过前四张扑克排列的顺序，向 Dico 传递关于第 5 张牌的信息。

关键在于如何实现这种协议。

数学原理

在进行分析之前，我们需要把 Chico & Dico 的魔术抽象成一个数学模型。

魔术本身已经提供了一些建模信息。假设一共有 $n$ 张牌，抽取其中的 $k$ 张。在对牌进行某种排序之后，我们需要利用前 $(k - j)$ 张牌的信息，推测后 $j$ 张牌是什么。

Agent 实战：智能路由、任务拆解和链路工程

Sun, 15 Jun 2025 00:00:00 +0000

大模型天生具有幻觉，为了工程的准确性，我们奉行“非必要不Agent”原则。我们是专业的，除非忍不住，否则绝不用 Agent。

特别声明：本文使用 Qwen Agent 实现。

本文包含以下两个项目：

1）智能路由

概述：如果一个业务可以分很多种情况处理。针对每种情况，我们开发一个工具函数 (Function Calling)，来处理此种情况内部的复杂性。此时，Agent 充当智能路由的角色，将对应的情况路由到对应的工具函数。工具函数内部带有描述信息，Agent 可以访问这些信息，以此判断在何种情况下，调用这个工具函数。

具体来讲，本项目开发了一个 客诉核查 Agent。针对物流逾期和假货两种客诉，分别开发了对应的工具函数。Agent 通过接入工具函数，获得了核查以上两种客诉真实性的能力。当我们将客诉信息传递给 Agent，它会输出针对该客诉的 核查结论 和 相应证据。

2）数据库查询优化

概述：数据库查询是一个非常通用的需求，其中 NL2SQL 是难点。为了提升 NL2SQL 的准确性，很容易想到把数据表的 Schema、样例数据、个别字段的枚举值作为上下文 (context) 注入到原始 Prompt 中。本项目实现了这一点。

具体来说，本项目做了以下工作：

启用 Qwen Agent 的 ReActChat 模式，以提升多步骤情况下的性能
开发定制的 Workflow，用于将 Schema 等上下文信息注入原始 Prompt 中
开发可流式对话的 Gradio WebUI，以方便调试 Agent 和 Workflow

✨ 所有代码见 GitHub 仓库：luochang212/agent-project

一、引言

1. 尚未到来的涌现

We always overestimate the change that will occur in the next two years and underestimate the change that will occur in the next ten. – Bill Gates

AUV～演出现场

Sat, 17 May 2025 00:00:00 +0000

来看演出了，耶诶！✧\(>o<)ﾉ✧

– Shot on iPhone 16

三种方法实现监督微调：LLaMA Factory, trl 和 unsloth

Sat, 26 Apr 2025 00:00:00 +0000

尝试了三种流行的微调框架，其中最推荐的是 unsloth，因为快！另外两种框架 LLaMA Factory 和 trl 是在夜里跑的，显卡风扇响了一宿。第二天看日志，它们都跑了三个多小时才跑完。但是同样的任务，unsloth 只需要五分钟，快得有点离谱。当然，这么比不是完全公平的，因为它们的量化方法、LoRA 参数是不同的。但是 unsloth 快这一点依然是无可质疑的。如果在 GPU 服务器上认真微调，那么用 LLaMA Factory 没毛病；但如果只是在笔记本上随便玩玩，unsloth 的优势就太大了。

GitHub 项目地址：sft-note

⭐ 本文的内容包括：

大模型微调的三种范式：无监督微调、监督微调、强化学习微调
介绍用于监督微调的数据格式，以及如何加载数据集
如何下载 Qwen 模型，代码见 download_qwen.py
使用三种框架微调大模型：LLaMA Factory, trl, unsloth

一、引言

大语言模型有很强的通用能力，但在特定领域，它的表现不如领域小模型。为了让大模型适应特定任务，我们对大模型进行微调，使大模型在保持通用性的同时，兼具领域模型的专业知识、对话风格和输出格式等特质。

微调大模型有三种范式：

无监督微调：在海量数据上进行二次预训练
- PT 增量预训练
监督微调 (SFT)：构造领域数据集，增强模型的指令遵循能力，并注入领域知识
- 指令微调
强化学习微调：通过 reward 引导模型优化
- RLHF 基于人类反馈的强化学习
- DPO 直接偏好优化方法
- ORPO 比值比偏好优化
- GRPO 群体相对策略优化

本文聚焦 监督微调 (Supervised Fine-Tuning)。监督微调是一种简单但有效的微调方式，能够快速融合业务数据、适应业务场景，因此它的性价比极高！

1. SFT 的简单介绍

监督微调的优化目标是 最小化模型生成回答与目标回答之间的差异，通常使用交叉熵损失。为避免破坏预训练阶段获得的知识，SFT 阶段通常使用 较低的学习率，并且只更新部分参数层，其他参数保持不变。与预训练阶段所需的海量数据相比，SFT 只需 较小的数据量（数千到数十万样本），即可完成微调。

2. SFT 的使用场景

为了让大家感受一下 SFT 能做什么，下面列举一些使用场景：

DNN 模型聚类特征更新方法

Sat, 19 Apr 2025 00:00:00 +0000

本文探讨如何在 DNN 模型中天级更新聚类特征时，保持聚类标签的稳定性。

GitHub 项目地址：label-assignment

本文的主要内容包括：

使用 BLIP-2 将图片转为 embedding
使用匈牙利算法建立重训练标签到原标签的映射
- 开发以 样本重合率 为度量的方法
- 开发以 类心距离 为度量的方法
赋予 embedding 近似聚类 ID 的方法：最近邻法

时至今日，多塔模型仍以 ID 类特征为主。将模型特征以 raw data 的形式直接送入模型，效果往往不好。因此，我们通常先将特征 ID 化，然后用 mmh3 哈希打散后，再送入模型。其中，特征 ID 化 是一个重要步骤，如果 ID 的粒度太细，细到极致相当于每个样本一个 ID，这时样本就无法和与之相似的样本通过 ID 进行交互；如果 ID 的粒度太粗，则 ID 下的样本过多，此时模型无法从中学到指向足够明确的信息。

将模型特征 ID 化有很多方法，比如聚类（无监督）、分类（有监督）、量化等等。本文仅讨论 聚类算法 及其在深度学习模型中的应用。

一、引子：频繁变更索引的代价

为了理解聚类算法产生的聚类 ID 是如何在深度模型中发生作用的，有必要介绍一下 嵌入层 (Embedding Layer) 的工作原理。

嵌入层是聚类 ID 与深度模型连接的桥梁。嵌入层的输入是聚类 ID，输出是该聚类 ID 对应的 embedding。在嵌入层中，聚类 ID 的每个枚举值都对应一个可学习的 embedding。如下图，假设聚类 ID 有 5 个枚举值 [0, 1, 2, 3, 4]，枚举值对应的索引分别为 idx0, idx1 … idx4。当一个样本进入模型，它会根据聚类 id 号（比如 2 号）去找对应的索引（idx2），然后将索引下的 N 维 embedding 取回。嵌入层在有些地方也被称为码本 (codebook).

本地部署大模型：Ollama 和 vLLM

Fri, 21 Mar 2025 00:00:00 +0000

2023 年本地部署大模型的报价近千万，2024 年初便骤降至百万，如今是 2025 年，只需要一行 vLLM 命令就可以部署大模型，人工成本几近于零。

GitHub 项目地址：llm-deploy

本文内容包括：

3 种方式部署 DeepSeek R1：Ollama, vLLM 和 Transformers
使用 vLLM 部署 Qwen2.5 模型
安装 Open WebUI 作为本地模型的前端聊天框
通过 vllm serve 实现一行代码启动 vLLM 推理服务

✨ 快速部署说明在 /deploy，vLLM 服务启动脚本在 /server.

一、本地部署 DeepSeek R1

大模型本地部署依赖推理引擎，目前比较流行的推理引擎有：

推理引擎	场景	介绍
Ollama	适合个人开发者和轻量级应用	基于 llama.cpp 开发，支持 CPU 推理，安装简单，开箱即用，适合快速原型开发和测试
vLLM	适合高并发生产环境	支持多 GPU 并行、批处理、PagedAttention，吞吐量高，延迟低，适合大规模服务部署
Transformers	适合模型研究和实验	提供完整的模型训练和推理接口，支持模型微调、量化、加速，适合研究人员和需要深度定制的场景
SGLang	适合需要复杂推理流程的场景	支持结构化输出、并行推理、流式输出，特别适合需要多轮对话和复杂推理的应用
LMDeploy	适合企业级部署和边缘计算	由上海人工智能实验室开发，提供完整的模型量化、加速和部署工具链，支持多种硬件平台，特别适合资源受限场景

下面介绍如何部署 Ollama, vLLM, Transformers 这三款推理引擎，简要部署步骤见本项目的 deploy 目录。

Langflow 实现本地知识库

Sat, 15 Mar 2025 00:00:00 +0000

本项目将用 langflow 实现一个本地知识库。

Langflow 是大模型可视化组件编排工具。它可以为大模型赋能，比如可以为大模型应用增加对话记忆、文档检索等等的功能。它基本上站到了 LangChain 类似的生态位。开发大模型应用的需求通常比较 flexible，在功能和性能都满足的条件下，Langflow 可以快速实现原型开发和模块复用，是目前的效率之选。

GitHub 项目地址：langflow-rag-app

本文的内容包括：

介绍 RAG 的相关概念
使用 Langflow 实现简单的知识库
使用 Langflow 实现带对话记忆功能的知识库
使用 Langflow 实现代码检查 (code review) 功能

✨ 环境部署相关的脚本，我放在这里了 deploy.

一、RAG 的概念介绍

这一节，我们先介绍 RAG 的相关概念，

知识库 就像大语言模型的“小抄”。在回答你之前，大模型先瞅一眼小抄，看有没有和你的问题相关的内容。如果有，就会从知识库中取回相应的文本片段，再结合大模型自身的能力生成最终回答。

知识库使用了一种叫 RAG（检索增强生成） 的技术。通过 RAG，大模型可以检索我们给它的文档。比如我们给它数学、法律、金融相关的文档，它可以事先进行“消化”、“吸收”。当我们对它提问时，它就能够像真正的专家一样，结合这些领域知识回答问题。

提示词模板
RAG 技术
- 文本向量化
- 向量数据库

二、简单的 RAG 应用

本节我们完成一个简单的 RAG 应用。我们将一个文档向量化后，存入向量数据库中，然后用 deepseek-r1:1.5b 模型，整合 RAG 取回的内容后输出回答。

最终的 langflow 工作流如下：

环境准备
- 安装 Ollama
- 安装 langflow
- 安装 chroma
langflow 搭建工作流
- 创建一个新的 Flow
- 初始界面
- 本地改造计划
- 启动 Ollama 服务
- 添加 Ollama Embeddings 组件
- 添加 Chroma DB 组件
- 添加 Ollama 组件
- 传入文档

三、带对话记忆功能的 RAG

通过添加 Messsage History 组件，就可以为 RAG 添加对历史对话的记忆。

深度嵌入聚类算法 DEC

Sun, 09 Mar 2025 00:00:00 +0000

如何对图片做聚类，我的直觉是：先用预训练模型计算图片 Embedding，然后用 cosine 度量的 DBSCAN 无监督地计算图片 label，再用 MLP 有监督地学习上一步产生的 label。DBSCAN 的好处是可以把无监督转为有监督，且由于它基于密度的特性，还不需要指定聚类的类别数，这方便了生产环境使用，因为生产环境通常也是不知道类别数的。MLP 的好处是可以对输入泛化，即使没见过的输入，在不重训练的情况下，也可以有一个对应输出。图片特征提取器 + 传统聚类 + 神经网络，是简单且符合直觉的方法，但恐怕不是最好的方法。

我们探索使用更端到端的方法实现图片聚类：DINOv2 特征提取器 + DEC 聚类器

使用 DEC 的好处起码有两点。一是让训练过程更简单，端到端的架构肯定比两阶段模型的架构更简单。二是 DEC 用特征向量表示聚类中心，这和传统聚类用标签表示不同。特征向量表示的类心更便于微调和增量更新。K-Means 每次更新 label 都是乱的，需要用匈牙利算法，对前后两次结果进行桥接。神经网络在这一点上天生有优势，因为它是顺着梯度一点一点更新的，所以前后两次结果是天然有联系，并且可以限制更新的幅度。

GitHub 项目地址：dec-pytorch

本文的工作包括：

用 DINOv2 模型生成图片 Embeddings
用 FastAPI 开发 DINOv2 批量推理服务，支持分 batch 和模型结果归一化
训练 DEC 模型的三阶段：训练降噪自编码器、初始化聚类中心、训练 DEC
开发集成的 DEC 训练框架，支持训练、推理、保存，详见 dec.py
在我的数据集上，对比 DEC 与传统聚类算法的效果：与 K-Means 接近
介绍 DEC 的创新点：软分配策略和目标分布优化
在线学习探索：尝试两种思路，对 DEC 模型做小幅度的增量更新

✨ DEC 论文在这里 Unsupervised Deep Embedding for Clustering Analysis.

搭建一款简单的『以文搜图』应用

Sun, 29 Dec 2024 00:00:00 +0000

在手机相册搜索框中输入“笔记本电脑”时，即使照片本身并未包含“笔记本电脑”这几个字，相关图片依然能够被精准地检索出来。这说明现代相册 APP 不仅使用图片 OCR 文本来召回搜索结果。它综合使用了多种技术，包括多模态技术。

本文使用多模态模型 CLIP 搭建一个简单的『以文搜图』应用，实现与相册 APP 类似的搜索效果。

GitHub 项目地址：clip-app

本文涉及的内容包括：

用 FastAPI 搭建图文向量生成服务
用 FastAPI 搭建 Faiss 向量搜索服务
集成以上两个服务，实现『以文搜图』应用
使用 @torch.inference_mode() 装饰器，优化推理性能

✨ 如果你对多模态模型的效果有更高的要求，可以尝试 BLIP-2。

一、加载 CLIP 模型

加载 CLIP 模型，生成图文 Embedding。

获取文本 Embedding
获取图像 Embedding
多条文本对一张图片
一条文本对多张图片
多条文本对多张图片

二、Faiss 向量搜索

用 FastAPI + Faiss 写一个向量检索服务 faiss/server.py，该服务提供两个接口：

路由名	描述
`add`	用于向索引中添加新的 Embedding
`search`	用于从索引中取回给定 Embedding 的最近邻 Embedding

三、CLIP 向量生成

用 FastAPI 写一个简单的 CLIP Embedding 生成服务 embedding/server.py。接口输入是图片、文本，输出是图文 Embedding。该服务提供 3 个 API 接口：

流式聚类算法：DenStream 和 CluStream

Sun, 01 Dec 2024 00:00:00 +0000

直接说结论：全量聚类用 DBSCAN；无监督流式聚类用 DenStream；已知聚类数、按较大时间间隔获取聚类标签且对计算量敏感，用 CluStream.

GitHub 项目地址：stream-clustering

本文涉及的内容包括：

提供 DBSCAN、DenStream 和 CluStream 三种聚类算法的使用示例
开发对 DBSCAN 自动调参并输出聚类标签的函数 auto_dbscan
验证 DenStream 的推理结果（簇号）是否在学习过程中发生变化：会变
DBSCAN、DenStream 和 CluStream 全量训练效果对比：DBSCAN 最好
DenStream 和 CluStream 增量训练效果对比：DenStream 最好

✨ 注意：运行以下代码依赖 utils.py 文件。

一、DBSCAN

DBSCAN 是一种基于密度的聚类算法，用于从大量数据中识别出高密度区域并将其分为不同的簇。与传统的基于划分的聚类算法（如 K-means）不同，DBSCAN 不需要预先指定簇的数量，并且能够识别噪声数据和异常值。

DBSCAN 算法介绍
DBSCAN 的简单示例
DBSCAN 的可选参数
DBSCAN 自动调参：
- 基于 K 距离图选择 eps
- 选择 min_samples 的经验法则
- 使用网格搜索结合合适的评估指标
使用 best_params 进行聚类
一站式 DBSCAN 函数

二、DenStream

DenStream 适合不知道具体的聚类数，且需要实时获取聚类标签的情况。

DenStream 算法介绍
DenStream 的简单示例
DenStream 的可选参数
验证：推理结果是否随时间变化
DBSCAN 与 DenStream 效果对比
使用 DBSCAN 优化过的 epsilon 参数

三、CluStream

CluStream 是一种需要明确指定聚类数的算法。它在一段时间内的聚类效果不错，也就是说，如果你的需求是有时间间隔的，比如每 10 分钟获取一次聚类结果，CluStream 的效果是可以接受的。

Triton 部署 CLIP 图文 Embedding 推理服务

Sat, 30 Nov 2024 00:00:00 +0000

本文介绍如何用 Triton 在多 GPU 环境下部署高性能 CLIP 推理服务。

GitHub 项目地址：clip-server

CLIP 是一个多模态模型。它能将图像和文本映射到同一个向量空间中，由此可以产生诸多应用。比如，通过计算图片与文本的相似性，可以用近似最近邻 (ANN) 从相册中检索与给定 query 语义相近的图片。此外，CLIP 的 Vision Encoder 可以作为特征提取器使用，用于生成的图像 Embedding。如果在 Vision Encoder 后加一个 fc 层，并且冻住骨干网络仅对 fc 层做训练，通常可以得到一个效果不错的图像分类器。

本文涉及的内容包括：

用 transformers 库运行 openai/clip-vit-base-patch32 的简单示例
在 titanic 数据集上训练一个 MLP 并导出成 ONNX 格式
介绍如何安装预装了 Triton 的 Nvidia 官方 Docker 镜像 & 启动容器
介绍如何将 MLP 的 ONNX 模型配置到 Triton 模型仓库中
写了一个简单的客户端用于获取 Triton 的推理结果
介绍 Triton 的 Python Backend，其通常用于模型预处理和后处理
用 Model Ensemble 组装 Python Backend 和 ONNX 组成完整的推理服务

✨ 注意：运行以下代码依赖 utils.py 文件和 mlp.py 文件。

Docker 命令速查手册

Sat, 23 Nov 2024 00:00:00 +0000

在低版本的服务器或存在共用关系的大组环境里，Docker 是个好东西。Docker 可以提供独立的运行时环境，以免受其他服务和人的干扰。

GitHub 项目地址：docker-command

一、什么是 Docker

Docker 是一种容器技术。它通过轻量级的虚拟化，将程序及其依赖打包到一个被称为容器的独立运行环境里，从而保证应用在不同环境中的一致性。

容器与虚拟机，在功能上类似，但更加轻量化。容器提供的是操作系统级别的虚拟化；而虚拟机提供的是硬件级别的虚拟化。不同于虚拟机要为每个实例运行完整的操作系统，容器共享操作系统内核，因此更轻量、更高效。不过，轻量化的设计也带来了一些限制，例如 systemctl 等服务管理工具通常在容器中不可用。

1.1 核心组件

在上手 Docker 前，有必要了解它的核心组件：

镜像 (Image): 镜像拥有运行应用所需的一切，包括操作系统、代码、依赖等
容器 (Container): 容器由镜像创建，每个容器拥有独立的运行环境

你无法直接运行镜像，必须由镜像创建对应的容器才能运行。可以认为容器是镜像的实例。镜像负责存储与分发，容器负责提供服务。

1.2 主要用途

Docker 的主要用途包括：

轻量级虚拟化：可以当成虚拟机使用
支持微服务架构：每个服务运行在独立容器中，易于扩展和管理
支持 CI/CD 流水线：一次打包，即可在所有环境中运行
保证环境的一致性：确保测试、开发、生产环境一致

如果你还不了解 Docker，可访问以下资源：

官网：https://www.docker.com/
入门文档：https://docs.docker.com/guides/

二、常用命令

2.1 基础操作

命令	描述
`docker info`	查看 docker 系统信息
`docker version`	查看 docker 版本信息
`docker --version`	查看 docker 简略版本信息
`docker login`	登录 DockerHub
`docker login nvcr.io`	登录 nvcr.io

2.2 镜像管理

命令	描述
`docker images`	查看镜像
`docker pull [IMAGE]`	拉取镜像
`docker rmi [IMAGE]`	删除镜像
`docker commit [CONTAINER] [IMAGE]:[TAG]`	将容器保存为新的镜像
`docker save -o myimage.tar [IMAGE]`	将镜像保存到指定路径
`docker load -i path/to/myimage.tar`	从 tar 文件中加载镜像
`docker tag [IMAGE_ID] [NEW_NAME]:[NEW_TAG]`	重命名 docker 镜像

2.3 容器管理

命令	描述
`docker create [IMAGE]`	创建容器
`docker run [IMAGE]`	创建并运行容器
`docker start [CONTAINER]`	启动容器
`docker stop [CONTAINER]`	停止容器
`docker restart [CONTAINER]`	重启容器
`docker ps`	列出运行容器
`docker ps -a`	列出所有容器
`docker exec -it [CONTAINER] /bin/bash`	启动交互模式
`docker rm [CONTAINER]`	删除容器
`docker port [CONTAINER]`	查看端口映射
`docker top [CONTAINER]`	查看容器内进程
`docker stats [CONTAINER]`	查看资源使用情况
`docker cp [CONTAINER]:[PATH] [LOCAL_PATH]`	拷贝文本到本地
`docker cp [LOCAL_PATH] [CONTAINER]:[PATH]`	拷贝文件到容器
`docker export -o mycontainer.tar [CONTAINER]`	将容器存成文件
`docker import path/to/mycontainer.tar [IMAGE]:[TAG]`	文件加载成镜像

2.4 容器运行

命令	描述
`docker run --name [NAME] [IMAGE]`	创建运行并命名容器
`docker run -d [IMAGE]`	创建容器并在后台运行
`docker run -p [LOCAL_PORT]:[CONTAINER_PORT] [IMAGE]`	创建容器并指定端口映射
`docker run -v [LOCAL_PATH]:[CONTAINER_PATH] [IMAGE]`	创建容器并将本地目录挂载到容器目录
`docker run -it [IMAGE] /bin/bash`	创建容器并启动交互式 shell

三、Docker 的简单使用

Docker 是客户端 / 服务端分离的，因此使用前，通常需要检查一下服务端和客户端是否都在运行：

频繁模式挖掘

Thu, 05 Sep 2024 00:00:00 +0000

挖掘 频繁项集 和 频繁序列 是频繁模式挖掘的两个经典任务。它俩的区别是：前者是顺序无关的，而后者关注顺序。对于这两种任务，Spark 已经有非常成熟的解决方案了，在当前主流公司的数据量级下是够用的。

GitHub 项目地址：frequent-pattern-mining

频繁项集 经常被念叨的一个用途，是挖掘经常被一起购买的商品（比如奶粉和尿布）。如果知道哪些商品经常被一起购买，就可以将这些商品打包出售。或者放在超市里相隔较远的两个地方，引导用户多逛。

频繁序列 也很有用。用户的连续行为可以看作一个序列。通过分析用户的频繁序列，产品经理可以发现用户习惯，进而优化功能排布和页面顺序，达到提升链路转化效率的效果。

✨ 注意：运行以下代码依赖 utils.py 文件。

一、频繁项集算法：FPGrowth

数据预处理
频繁项挖掘
- 频繁项集
- 关联规则

二、频繁序列算法：PrefixSpan

一个简单的例子
子序列挖掘
- 商品编码
- 生成商品序列
- 计算频繁子序列
- 通过子序列回溯原始数据

参考：

初见向量引擎：RediSearch 和 Milvus

Sun, 18 Aug 2024 00:00:00 +0000

建索引 Redis 够用了。一旦需要搜索向量，就可以考虑使用向量引擎。

GitHub 项目地址：redis-util

本文干了啥：

使用容器启动 Redis，并将数据卷挂载到本地
通过 Redis 的 Python API 做基础的 CRUD 操作
在不借助任何插件的情况下，使用原生 Redis 存取向量
使用 RediSearch 存取向量，并获取 TOP N 最近邻向量
尝试使用向量引擎 Milvus 的一些基础功能
基于 Redis “自制”向量引擎，支持设置索引过期时间，支持生成文本嵌入

✨ 注意：运行以下代码依赖 util.py 文件。

一、安装 Redis

下载镜像文件
启动容器
交互式 shell
测试连接
处理 CRUD 逻辑

二、用 Redis 存取 Embedding

Word2vec 生成 Embedding
数据类型转换
存取 Embedding

三、RediSearch 模块

安装 Docker 镜像
存取向量
查找最近邻向量

四、开源向量引擎 Milvus

Milvue 是一款为机器学习设计的开源向量数据库，支持存储、查询、索引向量。Milvus 的核心功能是向量相似度搜索，它使用近似最近邻搜索算法来加速搜索过程，找到与查询向量最相似的向量。Milvus 支持多种索引类型，包括 FLAT、IVF_FLAT、IVF_SQ8、IVF_PQ、HNSW 和 ANNOY，以适应不同的查询需求和数据规模。

三种图神经网络算法：GraphSAGE, GCN 和 GAT

Sat, 10 Aug 2024 00:00:00 +0000

GNN 处理图数据的方式还是很符合直觉的，基本沿袭了 CNN 的思路：每个神经元只看局部信息，通过层层汇聚掌握全貌。

GitHub 项目地址：graph-embedding

本文做了什么：

对 GraphSAGE 的简单实现做逐行注释
在 Docker 环境运行 GraphSAGE 的原版示例
用 PyG 实现了 GCN 和 GAT
为运行 PyG 写了一些 pipeline 代码

✨ 注意：运行以下代码依赖 util.py 文件。

一、GraphSAGE 的简单实现

主流图算法大致分两种：

图嵌入算法 (GE): DeepWalk, Node2Vec 等
图神经网络算法 (GNN): GraphSAGE, GCN, GAT 等

1.1 绪论：图神经网络

图神经网络算法做的事，相当于把图这种复杂的数据结构，转换成低维向量，而低维向量往往是很好用的。

拿到图嵌入可以做很多事情，比如：

节点分类
链接预测
社区发现
相似度量

总之，图嵌入是一种非常有用的特征。在实践中，甚至可以将图嵌入和其他特征 concat 起来，训练更复杂的模型。

1.1.1 GNN 和 CNN

GNN 和 CNN 的思路还挺像的，可以看作 CNN 在图数据上的推广。

SynchroTrap 算法实现

Sat, 27 Jul 2024 00:00:00 +0000

SynchroTrap 是基于 Jaccard 相似度和最大连通子图的异常检测算法，出自 Facebook 的论文 Uncovering Large Groups of Active Malicious Accounts in Online Social Networks.

GitHub 项目地址：SynchroTrap

本文做了什么：

用 mimesis 生成源数据，并基于源数据构造正态分布的样本
通过构造一个 $\lambda$ 可调的泊松过程，生成用户到访时间戳
提供一个由 7 个变量控制的异常数据生成函数，见 gen_attack_df
用 Jaccard 相似度构图，再用 NetworkX 对图做可视化
用 Spark 的 graphframes 计算最大连通子图
复现了论文 2.2 节的可视化效果，见评估与可视化
介绍如何使用 Docker 构建 Spark 开发环境

✨ 注意：运行以下代码依赖 utils.py 文件和 gen_data 库。

一、样本生成

脱离互联网企业，我们很难拿到可供挖掘的异常数据样本。一种方法是自己生成。自己生成样本的好处是能拿到真正的 ground truth，而且可以精细地控制异常的规模和程度。

生成源数据
生成大盘数据
- 生成正态样本分布
- 生成 uid 并计算访问次数
- 时间与时间戳
- 用户日志表
生成异常数据
- 选择攻击开始时间
- 获取 ip 池
- 发起攻击
整合两份数据

Note: 与异常捕获的难度有关的变量：

像搭积木一样搭神经网络

Sun, 07 Jul 2024 00:00:00 +0000

搭积木的时候，需要将不同类型的积木搭在一起：门框、窗子、走廊、屋顶。对每一种类型的积木，又有多种变体可供选择。比如，屋顶可以用文艺复兴风格，也可以用中式庭园风格。神经网络也是，学神经网络，本质上就是认识各种各样“积木”的过程。

GitHub 项目地址：dl-tricks/note.ipynb

一、必要组件

1.1 从 MLP 说起

我们从最简单的深度神经网络 多层感知机 (MLP) 开始说起。麻雀虽小，五脏俱全。了解数据如何在 MLP 中流动，就能大致勾勒一个神经网络的 必要组件。

下图是一个 4 层感知机，左边是特征，右边是标签。训练开始时，样本数据先从左到右做 正向传播。待数据流到右侧，用 损失函数 计算损失。此时损失是一个标量，而最后一层的节点权重 $W$ 是一个矩阵，标量对矩阵的偏导是矩阵。优化器 会用大小合适的梯度矩阵，沿负梯度方向逐层反向更新权重 $W$ 。这样下一批量 (batch) 数据进入网络时，正好能用上一轮更新后的参数做正向传播。

1.2 DataLoader

样本是有限的，为了让模型获得最强性能，必须榨干每个样本的价值。

因此在训练中，一个样本往往要复用多次。DataLoader 就在做这样一件事。它把数据编排成一个个批量，并构建一个迭代器。每次调用它，会返回一个从第一个批量开始遍历的迭代器。这个特性使得复用样本变得更加方便。

原生的 PyTorch DataLoader 很复杂，让我们来实现一个野生 DataLoader：

import math
import torch

class DataLoader:
    def __init__(self, data: list, batch_size: int):
        self.i = 0
        self.batch_size = batch_size
        self.batch_num = math.ceil(len(data) / batch_size)
        self._data = self.gen_batch(data)

    def gen_batch(self, data):
        lst = []
        s = self.batch_size
        for i in range(self.batch_num):
            start, end = s * i, s * (i + 1)
            X = torch.tensor([e[0] for e in data[start:end]])
            y = torch.tensor([e[1] for e in data[start:end]])
            lst.append((X, y))

        return lst

    def __iter__(self):
        self.i = 0
        return self

    def __next__(self):
        if self.i < len(self._data):
            self.i += 1
            return self._data[self.i - 1]
        else:
            raise StopIteration

假设有 2560 个样本。计划分成 10 个批量，则每批量有 256 个样本。我们可以用上面的野生 DataLoader 加载这些样本。

文本情感分析

Sat, 06 Jul 2024 00:00:00 +0000

用 Bert + Transformer Encoder + MLP 做文本情感分析。

GitHub 项目地址：sentiment-analysis
IMDB 数据集：imdb-dataset

本文要点：

建立词向量 ⇋ CSV 文件双向 Pipeline
用两种方法对 IMDB 电影评论做情感分析：
- Bert 预训练词向量 + MLP
- Bert + Transformer Encoder + 全连接层

✨ PS: 前两章是 Pipeline 代码，建议从第三章看起。

一、读写词向量

本节的主要目标是完成 词向量 -> CSV 文件 和 CSV 文件 -> 词向量 的 Pipeline。

对语料做预处理
获取词向量和句子向量
将词向量存入 csv
从 csv 中读取词向量
将读写词向量功能整合成函数

二、获取 IMDB 数据集的 Embedding

将 IMDB 数据集中的电影评论转换成句子向量，然后存在 CSV 文件中。

文本预处理
计算句子向量

三、用 MLP 做文本情感分析

用 Bert + MLP 做 IMDB 电影评论文本情感分析。

中文词向量生成

Sat, 29 Jun 2024 00:00:00 +0000

本文做了一件有意思的事，用 Bert 生成《红楼梦》人名的词嵌入，再用 t-SNE 将高维的词向量降为二维后做可视化。结果发现，主角团三人的名字在向量空间中是紧紧挨在一起的。

GitHub 项目地址：luochang212/chinese-embedding

本文探索的内容包括：

如何生成词向量
如何生成句子向量
如何找到语义相近的词
如何对 embedding 做降维及可视化

一、用 Word2Vec 生成词向量

用 Word2Vec 生成中英文词向量。

英文词向量
中文词向量

二、用 Bert 生成句子向量

用 Bert 生成中英文句子向量。

英文句子向量
中文句子向量

三、寻找最近邻 embedding

我的构想是：拿到红楼梦里所有词汇的 embedding，然后看我们感兴趣的词（比如林黛玉）离哪个词最近。

分词
批量计算 embedding
计算每个词的 embedding
计算我们关心词汇的近邻 embedding
整合成一个类

四、Embedding 可视化

用 t-SNE 和 PCA 对 embedding 降维，做 2D & 3D 可视化

红楼梦中的人物关系
中英美城市群
- t-SNE
- PCA

五、头脑风暴

Embedding 的稳定性
Embedding 差值的意义
输出 embedding 的数量

附录：和 Qwen-2.5 的聊天记录

Q: nn.Embedding 是一种预训练的embedding模型吗

Attention Is All You Need 论文精读

Sun, 16 Jun 2024 00:00:00 +0000

Transformer 的编码器变成了 BERT，解码器变成了 GPT。BERT 推动过去几年搜广推算法增长，而 GPT 促成了今天 GenAI 浪潮的爆发。这篇发表于 2017 年的论文，对今天产生了难以估量的影响。

原文：Attention Is All You Need

论文翻译

摘要

主流 seq2seq 模型是基于编解码器架构实现的复杂 RNN 或 CNN 网络，其中表现最好的模型还会使用注意力机制来连接编码器和解码器。我们提出一种全新的简单网络架构：Transformer。它完全基于注意力机制，不使用 RNN 和 CNN。在两个机器翻译任务上的实验表明，它拥有更好的并行度，并且训练时间大大减少。在 WMT 2014 英德翻译任务上，我们的模型取得了 28.4 的 BLEU 分数，比现有最好模型提升 2 BLEU。在 WMT 2014 英法翻译任务上，我们的模型在 8 台 GPU 上训练 3.5 天后，在单一模型评分指标下获得 41.8 的最高分。相比之前文献的最佳模型，Transformer 极大降低了训练成本。我们还通过英语成分句法分析任务展示了 Transformer 的泛化能力，无论数据集大小，Transformer 都能很好地泛化到其他任务上。

1. 介绍

循环神经网络、长短记忆网络和门控循环网络被证明是序列模型和处理语言建模和机器翻译这类转换问题的最先进方法。在此之后，人们又花费大量努力挖掘循环神经网络语言模型和编解码器架构的潜力。

循环神经网络对输入输出词元按位置进行计算，将词元的位置与时间步进行对齐，生成一系列隐状态 $h_t$。该隐状态是前一个隐状态 $h_{t-1}$ 和时间步 $t$ 时刻输入 $X_t$ 的函数。在训练样本时，这种内在的序列关系天然阻碍并行。对长序列文本，因为内存限制了批量样本的处理，导致这种阻碍更加明显。最近的研究利用因子分解和条件计算两种方法显著提升了计算效率，尤其后者还提高了模型的性能。但是序列计算这个最根本的限制依然存在。

注意力机制在多种序列建模和转换建模任务中占有重要地位，它能对输入输出序列中的依赖关系进行位置无关的建模。除了少数几个例子外，注意力机制通常和循环神经网络一起使用。

我们提出了 Transformer，一种不使用循环神经网络、纯基于注意力来捕获输入输出全局依赖关系的模型。Transformer 显著提高了并行度，并且在 8 台 P100 GPU 上训练 12 小时后，翻译质量达到了前所未有的高度。

注意力机制笔记

Sun, 09 Jun 2024 00:00:00 +0000

马毅：要想正确理解深度神经网络，就必须认识到其本质是学习高维数据中的低维结构的手段。从第一性原理出发，把目的和手段分清楚，其余的都很容易被统一、被解释。

从 Attention 的角度理解马毅老师这句话，Embedding 的时候本来就升维了，再做 QKV 就相当于在高维里面抽低维信息。而且 Q 也是可学习的，所以就既能学到好的抽取方法；对于每一种抽取方法，又能特别高效地抽取。

GitHub 项目地址：rnn-note / attention-note

一、语言模型入门：RNN, LSTM, GRU

1.1 序列模型

马尔可夫假设，当前数据只跟最近 τ 个数据点相关。把最近 τ 个数据点作为特征，用 MLP 预测当前数据点的值。

1.2 文本预处理

对文本词元化 (tokenize) 并构建词表，就是把文本映射到从 0 开始的索引。

1.3 语言模型和数据集

对语料分批量 (batch) 处理。介绍了两种（batch 内的）采样策略：

随机采样策略：每个 batch 内的相邻子序列是随机的
顺序分区策略：每个 batch 内的相邻子序列是顺序的

1.4 循环神经网络的从零开始实现

每次输出仅由前一个隐状态和当前新输入 x 决定，是为 RNN。

提及的知识点：

独热编码：文本经过词元化后，还要经过 one-hot 处理，才能进入模型
困惑度：我们用困惑度来描述文本生成的质量，通过一个序列中所有的 n 个词元的交叉熵损失的平均值来衡量 $$\frac{1}{n} \sum_{t=1}^n-\log P\left(x_t \mid x_{t-1}, \ldots, x_1\right)$$
梯度裁剪：对于 $T$ 长序列将产生 $O(T)$ 长矩阵乘法链。当 $T$ 较大时，可能导致数值不稳定，例如可能导致梯度爆炸或梯度消失。这种情况下优化算法可能无法收敛。下式通过将梯度 $g$ 投影回给定半径 $\theta$ 来限制梯度的大小。其中 $\frac{\theta}{|\mathbf{g}|}$ 可以理解为梯度 $g$ 的单位方向向量。 $$\mathbf{g} \leftarrow \min\left(1, \frac{\theta}{|\mathbf{g}|}\right) \mathbf{g}$$

1.5 循环神经网络的简洁实现

使用高级 API 实现循环神经网络。

后台管理工具介绍

Thu, 30 May 2024 00:00:00 +0000

呀嘞呀嘞，我的 JupyterLab 怎么又挂了。

简单的 nohup [CMD] & 已经不够用，该研究一下后台管理工具了。

问了一下 Qwen，大概有五款后台管理工具可用。这五款工具大致可分为两类：

进程管理器：systemd, pm2, supervisor
终端复用器：screen, tmux

总之，保持单个程序在后台运行，systemd 就够用。如果要维持多个后台程序，pm2 比较合适。screen 和 tmux 则是更临时的方案，适合偶尔用用的情况。

一、systemd

使用 systemd 管理 Jupyter lab 服务，必须先创建一个 systemd unit 文件来定义服务的启动、重启等行为。以下是创建 systemd 服务的步骤。

1.1 创建 unit 文件

用 vi 新建并打开 jupyterlab.service 文件：

sudo vi /etc/systemd/system/jupyterlab.service

配置如下：

[Unit]
Description=Jupyter Lab
After=network.target

[Service]
Type=simple
User=[YOUR_USERNAME]
ExecStart=/home/[YOUR_USERNAME]/miniconda3/bin/jupyter lab --ip=0.0.0.0 --port=443 --no-browser --allow-root
WorkingDirectory=/home/[YOUR_USERNAME]/
Restart=on-failure
RestartSec=8s

[Install]
WantedBy=multi-user.target

将 [YOUR_USERNAME] 替换为你的用户名。如果你在 root 上开服务，记得在 ExecStart 后加一个 --allow-root
如果你的服务不在 https 上，请用 --port=80 或 --port=8888 之类的其他端口
在 https 上搭建 jupyter lab 服务的方法，参见在服务器上使用 JupyterLab

1.2 启动服务

1）重启守护进程，使新增的 systemd unit 文件生效。

深度学习工具箱 FlameAI

Sat, 25 May 2024 00:00:00 +0000

在上一篇博客《LightGBM 工程实践》中，我把通用函数写到 util.py 文件，以实现代码复用。但是这么复用好麻烦，每次开新项目，得把 util.py 文件贴过去才行。为了省下这个贴的动作，我把它写成 Python 包了。现在下载一次，就可以到处使用啦！

GitHub 项目地址：flameai

一、简单介绍

我的这个包叫 FlameAI。作为一个深度学习工具包，它的主要功能是 数据预处理 和 模型评估。FlameAI 旨在解决最后一公里问题。即在框架之外，业务代码之内，寻求最佳实践。为了让我的包看起来上流一点，我让 Kimi 帮我想了几个名字，最后还是选择了 FlameAI，因为这个名字最霸气。

执行以下命令安装 FlameAI：

pip install flameai

如果嫌安装速度慢，可以使用腾讯源或阿里源：

# 腾讯源
pip install flameai -i https://mirrors.cloud.tencent.com/pypi/simple/

# 阿里源
pip install flameai -i https://mirrors.aliyun.com/pypi/simple/

如果发现 pip 缓存目录占用了太多磁盘空间，可执行以下命令（通常不需要清理）

# 清理 pip 缓存文件
pip cache purge

二、模块功能介绍

2.1 二分类模型评估

二分类模型评估是咱们的拳头产品。只需一行命令，就可以计算下面全部指标：

accuracy: 准确率
precision: 精确率
recall: 召回率
f1_score: 精确率和召回率的调和平均数
auc: ROC曲线下的面积
cross-entropy loss: 交叉熵损失
True Positive (TP): 真阳
True Negative (TN): 真阴
False Positive (FP): 假阳
False Negative (FN): 假阴
confusion matrix: 混淆矩阵

1）简单用法

你可以直接指定阈值，下面代码中指定阈值为 0.5。

JupyterLab 中有哪些黑科技

Wed, 15 May 2024 00:00:00 +0000

JupyterLab 你是真的火了…

5 月 14 号 OpenAI 春季发布会出现了这个画面：

才知道 JupyterLab 是 OpenAI 的日常开发工具。感谢 OpenAI 亲自带货。

JupyterLab 拥有丰富的功能，并不只是 Python 解释器这么简单，让我向你们展示它的强大！

〇、安装 JupyterLab

执行以下命令安装 JupyterLab：

# For miniconda user
conda install -c conda-forge jupyterlab

# For conda-forge user
# mamba install -c conda-forge jupyterlab

Note: mamba 是 miniforge 自带的包管理工具。在 miniforge 环境中，你可以用 mamba 替代 conda，比如 mamba info --envs。使用 mamba 通常可以获得更高的下载速度。

一、制作 PPT

1.1 Notebook 转 PPT

只需两步，就能把 Notebook 转成 PPT：

设置 Slide Type：为保证页面被正确渲染，你需要设置 Cell 的 Slide Type。对于新版 Jupyter Lab，在右侧边栏上有带俩齿轮的按钮，点进去，然后一路点 [Property Inspector] -> [COMMON TOOLS] -> [Slide Type]，在这里对 Cell 进行设置。

LSTM 家庭用电预测

Sun, 12 May 2024 00:00:00 +0000

长短期记忆网络（Long Short-Term Memory，LSTM）是一种 RNN 模型，常用于序列数据建模。尤其适合需要挖掘序列中长期依赖关系的问题。

GitHub 项目地址：luochang212/lstm-model

一、keras 模型训练

数据导入
数据预处理
趋势可视化
分割训练集和测试集
定义 & 训练网络
预测
预测整个序列

二、keras 模型推理

数据预处理
用训练好的 keras 模型做预测
预测下一个值
预测下一个序列

三、PyTorch 模型训练

施工中

参考资料：

LightGBM 工程实践

Sat, 13 Apr 2024 00:00:00 +0000

LightGBM 是一种梯度提升树算法，可用于排序、分类和回归任务。本文由一系列 Jupyter Notebook 串成，介绍如何使用 LightGBM 训练二分类模型。本项目使用的数据集是 adult (・ω< )★

GitHub 项目地址：lightgbm-binary

🚀 本文亮点

✅ 使用 Optuna 做超参数寻优
✅ 使用 Treelite 做推理加速
✅ 使用 Graphviz 做决策树模型可视化
✅ 使用 scale_pos_weight 参数，解决样本不均衡问题
✅ 对标签概率生成标签的阈值寻优 (y_pred -> y)，详见 util.gen_threshold
✅ 编写自适应学习率衰减函数提高 AUC，详见 util.AdaptiveLearningRate
✅ 编写一站式评估函数，可一次性输出多种指标，包括 accuracy, precision, recall, f1_score, auc, cross-entropy loss, confusion matrix，详见 util.eval_binary

✨ 注意：以下代码运行时依赖 util.py 文件

一、数据可视化

导入数据
统计描述
- describe() 方法
- info() 方法
- 统计各字段枚举值数量
- 查看字段下所有枚举值
- 查看空值个数
可视化
- 标号的值的比例
- 小提琴图 (Violin Plot)

二、预处理与特征选择

预处理
- 标签编码
- 更好的编码方式？
初次训练
- 使用 lgb.LGBMClassifier 进行训练
- 使用原生 API 进行训练
简单评估
模型存储与导入
- 模型存储
- 模型导入
特征选择
- 计算特征的重要程度
- 多次实验求均值

三、超参数微调

简单的例子
稍微复杂的例子：随机森林
- 导入数据
- one-hot 编码
- 训练
- 评估
- 超参数微调
- 使用微调后的超参数训练
LightGMB 超参数微调
- 单次训练
- 超参数寻优
- 使用微调后的超参数训练
学习率衰减
- 指数衰减
- 自适应衰减

四、训练与评估

基础模型
N 折交叉验证
超参寻优：N 折交叉验证
使用微调后的超参数训练
阈值选择 (y_pred -> y)
- 使用 np.rint
- 尝试：考虑原标号的分布
  - 训练标号的分布情况
  - 预测标号的概率密度函数 (PDF)
  - 预测标号的概率分布函数 (CDF)
  - 当 CDF = 训练数据 0 标号比例 时反推阈值
- 使用 optuna 寻优
评估
- 混淆矩阵
- 准确率
- 精确率和召回率
- f1 值
- log_loss 交叉熵损失
- ROC 曲线与 AUC
- 一站式评估函数

五、加速推理

导入模型和数据
使用 Treelite 加速推理
- 推理速度
- 推理准度
- 通用函数

六、部署

模型训练
模型部署
- 离线部署
- 在线部署

七、模型可视化

创建可交互的可视化界面
将决策树存成 PNG / PDF

参考：

家庭网络拓扑

Sat, 02 Mar 2024 00:00:00 +0000

本文介绍家庭局域网的数据传输过程。

常见家庭网络拓扑如下：

flowchart LR
    A[外网] -->|光纤入户| B[光猫] -->|路由器WAN| C[路由器] --> D[交换机]
    D -->|交换机LAN1| E[电脑]
    D -->|交换机LAN2| F[笔记本]
    D-->|交换机LAN3| G[电视机盒子]

现代的 路由器 和 交换机 其实是一个设备，统称路由器。为了便于理解，我们还是把它们拆开。

一、局域网设备

光猫、路由器、交换机的连接方法。

1）光猫

光猫一般放在弱电箱，它有一个 WAN 口和多个 LAN 口。我们把路由器插在其中一个 LAN 口上，假设插的是 LAN1

WAN	LAN1	LAN2	LAN3	`...`
接外网网线	接路由器	空闲	空闲	空闲

2）光猫接路由器

然后将网线从光猫 LAN1 接到路由器 WAN

WAN	LAN
接光猫 LAN1	接交换机（为了便于理解，虚拟出来的 LAN，实际不存在）

3）路由器接交换机

最后将网线从路由器 LAN 接到交换机 WAN

WAN	LAN1	LAN2	LAN3	`...`
接路由器 LAN	接电脑	接笔记本	接电视机盒子	空闲

二、局域网概念

当我们把网线从光猫到路由器再到设备一路接好，就有了一个 局域网 (Local Area Network，LAN)。由于我们主要关心局域网中发生了什么，因此不画光猫。下图是我们的局域网：

图算法笔记

Sun, 25 Feb 2024 00:00:00 +0000

记笔记能让脑子里的知识结构化说是

GitHub 项目地址：graph-algorithm

一、图的基础操作

1.创建图
- 1.1 从空图开始创建
- 1.2 用边文件创建
- 1.3 用已经存在的图、边的列表创建
- 1.4 创建带权边
- 1.5 为图添加属性
- 1.6 创建有向图
2.可视化
- random
- circular
- spectral
- shell
3.中心性度量
- Degree Centrality
- Closeness Centrality
- Betweenness Centrality
- Eigenvector Centrality
4.随机图生成
5.读写文件
- 写入文件
- 读出数据

二、通用图算法

连通性 Connectivity
最短路 Shortest Paths
相似性度量 Similarity Measures
距离度量 Distance Measures
链接预测 Link Prediction
匹配 Matching

三、社区检测算法

1.常见社区检测算法
- 1.1 label Propagation
- 1.2 Girvan-Newman
- 1.3 Greedy Modularity
- 1.4 Louvain
2.是否接受边权作为输入
- 推荐使用 louvain

四、图嵌入

施工中

树莓派 5 装机指南

Sat, 24 Feb 2024 00:00:00 +0000

2024 年 2 月，给我的 Raspberry Pi 5 安装 Ubuntu，最后踩了两次坑才装好。感觉搜索前几的教程都不对，没一个让我顺利装完的。那么我来记录一下安装过程吧

一、下载

你需要下载两个东西：

ubuntu-23.10：适用于树莓派 5 的 Ubuntu 镜像
Raspberry Pi Imager：将镜像写入 TF 卡的工具

1）ubuntu-23.10 的下载页面：ubuntu.com/download/raspberry-pi

PS: 你可以选择服务器版或桌面版，我安的是桌面版

2）Raspberry Pi Imager 的下载页面：raspberrypi.com/software

二、将镜像写入 TF 卡

下载好镜像之后，你需要把镜像写入 TF 卡。

打开 Raspberry Pi Imager，界面上有三个白框，分别是：

CHOOSE DEVICE: 选择你的树莓派版本。选 Raspberry Pi 5
CHOOSE OS: 选择你要安装的镜像。由于我们用的是本地镜像，下拉栏划到最底，选 Use custom
CHOOSE STORAGE: 选择你的 TF 卡。没插卡的请插卡，然后在下拉栏选中你的卡。由于后续步骤会抹除 TF 卡数据，清确保卡内没有重要文件

三、首次启动 Ubuntu

在不插电源的情况下，将 TF 卡插入板子。

然后连接外接显示屏、鼠标、键盘、网线（如果有），插电即可直接点亮。如果 1 分钟后没有任何反应，可以尝试按 TF 卡旁边的电源键。需要注意的是，树莓派 5 新加了实体电源键，老版本没有。

手写深度学习

Fri, 09 Feb 2024 00:00:00 +0000

与其说深度学习是一门技术，不如说深度学习是一种语言

GitHub 项目地址：AI-Project/scratch

一、自动微分

1. 简单的例子

1.1 张量 x 的梯度

张量 $x$ 的梯度可以存储在 $x$ 上。

要点：

x.grad: 取 $x$ 的梯度
x.requires_grad_(True): 允许 tenser $x$ 存储自己的梯度
x.grad.zero_(): 将 $x$ 的梯度置零

import torch

# 初始化张量 x (tensor x)
x = torch.arange(4.0)

x.requires_grad_(True)  # 允许 tensor x 存储梯度
x.grad is None  # 梯度默认为 None

> True

初始化带梯度的张量，下面是两个例子：

torch.tensor([1., 2., 3.], requires_grad=True)

> tensor([1., 2., 3.], requires_grad=True)

torch.randn((2, 5), requires_grad=True)

> tensor([[ 0.4075, 1.1930, 0.5716, -1.0924, 0.0653], [-1.2869, 1.5768, 1.3445, 0.6309, -0.0484]], requires_grad=True)

Linux 运维手册

Sat, 03 Feb 2024 00:00:00 +0000

基于 CentOS 系统

一、常见操作

1）文件操作

命令	描述
ls	列出当前文件夹下的文件
ls -alh	列出包括隐藏文件在内的所有文件，显示详细信息，并以人类可读的方式显示占用的磁盘空间大小
touch [FILE]	创建文件
vim [FILE]	打开文件
cat [FILE]	打印文件
head [FILE]	打印文件头 10 行，展示 20 行用 `head -n 20 [FILE]`
tail [FILE]	打印文件尾 10 行，展示 20 行用 `tail -n 20 [FILE]`
tail -f [FILE]	实时查看文件的末尾新增的内容，一般用于打印监控日志
less [FILE]	打印文件，可以用 `上键` `下键` 翻页
rm [FILE]	删除文件
rm -rf [DIR]	递归删除路径`DIR`下所有文件
mv [FILE_A] [FILE_B]	文件`FILE_A`改名为`FILE_B`
mv [FILE] [DIR]	文件`FILE`移动到路径`DIR`
cd [PATH]	打开目录`PATH`
mkdir [PATH]	创建目录
mkdir -p [PATH/TO/DIR]	创建多级目录
tar cvf file.tar ./data	把 `data` 目录压缩成 `file.tar` 文件
tar xvf file.tar	解压 `file.tar` 文件

2）网络操作

命令	描述
lsof -i	列出所有与网络连接有关的进程及其打开的端口信息
lsof -i :[PORT]	列出特定端口的进程信息
lsof \| grep deleted	列出占用未被正确删除的文件的句柄的进程
ifconfig	查看有效的网络接口的状态
ifconfig -a	查看所有的网络接口的状态
arp -a	查看局域网中设备的ip地址
ping [SERVER_IP]	检查远端服务器连通性
telnet [SERVER_IP] [SERVER_PORT]	检查远端服务器的端口的连通性
hostname -I	awk ‘{print $1}’
wget [URL]	下载文件到当前路径
curl [URL]	访问网页
netstat -tnpl	显示TCP类型的端口
netstat -unpl	显示UDP类型的端口
netstat -r	显示路由表信息
netstat -g	显示多重广播功能群组组员名单
netstat -s	显示按协议分类统计信息
netstat -l	显示所有监听端口
netstat -n	使用域名解析，将域名解析成ip地址
netstat -p	显示程序名和进程PID
netstat -t	显示所有的tcp协议的端口
netstat -u	显示所有的udp协议的端口
ssh -p [SERVER_PORT] [USER]@[SERVER_IP]	ssh连接远端服务器
ssh-keygen -R [SERVER_IP]	同IP机器重装后重连前注销老host
dig [example.com]	是 Linux 系统用于查询 DNS 信息的工具

3）系统操作

命令	描述
top	查看CPU占用率
hostname	查看主机名
uname -m	查看linux架构
uname -a	查看系统详细信息
cat /etc/centos-release	查看centos版本
ps aux	查看进程
ps -ef	查看进程
kill -9 [PID]	杀掉进程`[PID]`
df -h	查看磁盘空间
du -h / \| sort -rh	根据文件磁盘占用倒排
du -h --max-depth=1	查看当前目录占用的磁盘空间大小
history	查看历史命令
type [CMD]	查看命令所在路径，如`type mkdir`
echo $LANG	查看字符编码
su -	切换到root用户
pip cache purge	pip缓存清理
conda clean --all	conda缓存清理
ldd --version	查看 GLIBC 版本

4）文本处理

命令	描述
awk	取列
awk -F	指定分割符取列
grep -v	查找不包含特定匹配模式的行
wc -l	输出文件的行数
echo “ABC” > [FILE]	将文本`ABC`写入文件`FILE`行尾
echo “ABC” » [FILE]	用文本`ABC`覆写文件`FILE`

5）Bash 表达式

命令	描述
-gt	大于
-lt	小于
-eq	等于
-ne	不等于
-ge	大于等于
-le	小于等于
!	非
==	等于
=～	正则匹配，等式右侧写正则表达式
-a file	如果file存在则为真
-d file	如果file存在且为目录则为真
-f file	如果file存在且为普通文件则为真
sleep 1m	休眠一分钟
export PATH=[/some/new/path]:$PATH	新增环境变量`/some/new/path`
$#	保存传递给shell脚本的命令行参数的数量
$*	保存所有传递给shell脚本的命令行参数 ($1 $2 …)
$@	保存所有传递给shell脚本的命令行参数 ("$1" “$2” …)
$0	保存shell脚本的名字
$?	保存上一个执行的命令的退出码
set -x	脚本调试命令，会打印当前脚本执行的所有命令及其参数

6）vim 命令

以下命令需用 vim 打开文件，再按 esc 后输入，再按 enter 执行

居家物资清单

Mon, 01 Jan 2024 00:00:00 +0000

Build your home from scratch.

GitHub 项目地址：new_home

一、随身物品

身份证
手机
钥匙
钱包
脑子

二、文具

通勤双肩包
雨伞
拍纸本
中性笔
铅笔
毛笔
秀丽笔
少量专业书籍

三、生活用品

衣服
衣架
毛巾 * 2
- 洗澡用
- 垫枕头上
牙具
- 牙杯
- 牙膏
- 牙刷
鞋
- 拖鞋
- 运动鞋
水杯：
- 工位：带盖水杯
- 家用：陶瓷水杯
脸盆
指甲刀
剃须刀
剪刀

四、床上用品

被子
枕头
床单
床笠
可爱靠枕

五、电子产品

手机
手机支架
手表
耳机
平板
树莓派
Switch
Mac mini
笔记本电脑
笔记本电脑支架
外接显示器
外接显示器支架
鼠标
鼠标垫
拓展坞
移动硬盘
移动WIFI
游戏手柄
自拍杆
充电宝
充电器
- 充电头
- 充电线
- 插线板

六、家具

桌子
镜子
阅读灯
氛围灯
拖把
垃圾桶
桶装矿泉水倒立支架

七、电器

体重秤
烧水壶
智能音箱
桌面时钟（带温度湿度功能）
桌面风扇
暖风机
空气净化器

八、消耗品

洗衣液
沐浴露
洗发液
洗面奶
面霜
唇膏
抽纸
酒精湿巾
垃圾袋
保鲜袋
抹布

九、食品

调味料
- 基础
  - 盐
  - 生抽 / 蒸鱼豉油 / 寿喜烧酱汁 / 照烧汁
  - 食用油 / 香油 / 黄油
  - 生粉 / 粘米粉 / 白凉粉 / 面包粉
  - 辣椒 / 二荆条 / 辣椒面 / 辣椒酱 / 泡椒
  - 白砂糖 / 冰糖 / 红糖
  - 生姜 / 泡仔姜
  - 蒜 / 蒜泥 / 香蒜酱 / 青蒜酱 / 黑蒜酱 / 糖蒜
  - 香醋 / 米醋 / 白醋
  - 咖喱块 / 咖喱粉
- 进阶
  - 蜂蜜 / 蜂蜜芥末酱
  - 黑胡椒 / 白胡椒 / 花椒
  - 花生酱
  - 八角
  - 月桂叶
  - 蚝油
  - 麻酱
  - 牛油火锅底料
  - 柠檬 / 青柠
- 药膳
  - 当归
  - 党参
  - 黄芪
食材
- 主食
  - 大米 / 小米 / 莲子 / 薏米 / 黑米
  - 红豆 / 黄豆 / 绿豆 / 黑豆
  - 粉丝 / 米线 / 河粉
  - 挂面 / 龙须面 / 车仔面 / 荞麦面 / 刀削面 / 方便面 / 意大利面
  - 水饺 / 馄饨
  - 地瓜 / 土豆
  - 麦片 / 藕粉 / 芝麻糊
  - 茶泡饭速食包 / 真空装玉米 / 真空装卷饼
- 佐食
  - 牛奶 / 酸奶
  - 鸡蛋 / 咸鸭蛋 / 溏心蛋 / 皮蛋
  - 茶叶 / 咖啡
  - 豆腐
  - 榨菜 / 香菜心 / 脆瓜 / 脆萝卜 / 海带丝
  - 香菇肉酱 / 红烧肉罐头 / 咖喱牛肉罐头 / 鱼罐头 / 午餐肉罐头
  - 猪肉松 / 鱼肉松
  - 板鸭 / 腊肉
  - 蛋挞皮 / 蛋挞液
  - 盐酥鸡 / 唐扬鸡块
  - 白斩鸡 / 烤鸭
  - 冰鲜披萨
- 蔬菜
  - 小白菜 / 娃娃菜
  - 空心菜 / 地瓜叶
  - 包菜
  - 西红柿
  - 胡萝卜 / 白萝卜
  - 黄瓜 / 南瓜 / 西葫芦
  - 西兰花
  - 笋
  - 芹菜 / 香菜 / 韭菜
  - 四季豆 / 豌豆 / 毛豆
  - 香菇 / 红菇
  - 海带 / 紫菜
- 肉类
  - 鸡肉 / 鸭肉 / 鸽子肉
  - 猪肉 / 牛肉 / 羊肉
  - 鱼 / 龙利鱼排 / 鱿鱼圈 / 虾仁
  - 鱼丸 / 牛肉丸
  - 牛排 / 汉堡肉 / 火腿
- 水果
  - 苹果
  - 橘子
  - 橙子
  - 香蕉
  - 梨
  - 芒果
  - 椰子
  - 香瓜
  - 西瓜
  - 奇异果
  - 牛油果
  - 蓝莓 / 草莓
  - 葡萄
- 速食
  - 面包 / 华夫饼
  - 饼干 / 小熊饼干 / 趣多多 / 奥利奥 / 脆脆鲨
  - 蛋糕 / 提拉米苏 / 巧克力派 / 蛋黄派
  - 混合坚果
- 零食
  - 巧克力
  - 冰淇淋 / 雪糕
  - 青团 / 糯米糍 / 年糕
  - 无骨鸭爪 / 鸭脖
  - 猪肉干 / 牛肉干 / 肉脯干
- 饮料
  - 可乐
  - 雪碧
  - 菠萝啤 / 米酒 / 桂花酿
  - 橙汁
  - 椰汁
  - 咸柠七

十、药品

口罩
体温计
药箱
- 感冒
  - 藿香正气胶囊
  - 999感冒灵颗粒
- 化痰止咳
  - 川贝枇杷颗粒
  - 乙酰半胱氨酸片
- 咽喉肿痛
  - 咽喉清颗粒
- 发热流感
  - 布洛芬（散利痛 / 布洛芬缓释胶囊）
  - 复方氨酚烷胺胶囊
  - 复方对乙酰氨基酚片(Ⅱ)
- 抗生素（抗细菌）
  - 头孢
  - 阿莫西林（青霉素）
  - 罗红霉素分散片
  - 盐酸左氧氟沙星片 [肠胃炎可用]
  - 诺氟沙星胶囊
  - 盐酸莫西沙星片
- 抗病毒
  - 磷酸奥司他韦胶囊
- 唇炎
  - 单乳膏 [上海市皮肤科医院有售]
- 抗过敏
  - 氯雷他定
- 蚊虫叮咬
  - 999皮炎平
- 消炎
  - 莫匹罗星软膏（百多邦）
- 消毒
  - 碘伏
  - 酒精棉球
- 包扎
  - 创可贴
  - 纱布片 / 绷带
  - 棉签
  - 医用胶带
  - 医用剪刀
  - 医用镊子

十一、工具

螺丝刀
卷尺

十二、厨具

中式炒锅
电饭煲
电磁炉
碗 / 盘子
勺子 / 筷子
菜刀
菜板
茶漏

十三、运动用品

瑜伽垫
俯卧撑支架
双节棍
长棍
泳镜
泳帽
泳裤

十四、保暖用品

手套
护膝

十五、证件

护照
驾驶证
银行卡
其他身份材料

十六、XOX

拍立得
To签色纸
应援棒

参考：

深度学习笔记

Sat, 11 Nov 2023 00:00:00 +0000

跟李沐老师学深度学习，课程见 d2l，如有错误，欢迎拍砖

GitHub 项目地址：AI-Project

〇、技术路线图

flowchart TD
    A[softmax 回归] -->|无法拟合 XOR 函数| B[多层感知机]
    B --> |高像素图片作为输入，模型参数爆炸| C[卷积]
    C -->|数据的长宽下降太快| D[填充]
    C -->|数据的长宽下降太慢| E[步幅]
    C -->|缓解卷积对位置敏感| F[池化]
    C -->|多模式识别与组合| G[多通道输入/输出]

❤️ powered by mermaid

一、softmax 回归

1. 虽然叫回归，但是softmax 解决的是分类问题

回归估计是一个连续值
分类预测是一个离散类别

2. 分类应用举例

MINIST
ImageNet
human-protein-atlas-image-classification (Kaggle)
malware-classification (Kaggle)
jigsaw-comment-classification (Kaggle)

3. 从回归到多类分类 – 均方损失

对分类结果做 one-hot 编码：

$y = [y_1, y_2, , ... , y_n]^T$

$y_i=\left\{\begin{array}{l}1 \text { if } i=y \\ 0 \text { otherwise }\end{array}\right.$

PyPI 打包小记

Wed, 18 Oct 2023 00:00:00 +0000

你们这些家伙，好好看看我是怎么打包的吧！

GitHub 项目地址：hit-and-blow

官方教程：Packaging Python Projects
背景知识：Modules

一、文件结构介绍

打包前，需构建如下文件结构：

packaging_tutorial/
├── LICENSE
├── pyproject.toml
├── README.md
├── src/
│   └── YOUR_PACKAGE_NAME/
│       ├── __init__.py
│       └── example.py
└── tests/

各个 文件 / 文件夹 说明：

packaging_tutorial: 项目文件夹
LICENSE: 开源协议，可由 GitHub 生成
pyproject.toml: 打包配置文件
README.md: 项目文档
src: 项目结构要求的，用来放主程序
YOUR_PACKAGE_NAME: 主程序文件夹，以“你的包名”命名文件夹

二、添加配置文件

将以下内容修改一下，改改名字邮箱什么的，存成配置文件 pyproject.toml

[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"

[project]
name = "example_package_YOUR_USERNAME_HERE"
version = "0.0.1"
authors = [
  { name="Example Author", email="author@example.com" },
]
description = "A small example package"
readme = "README.md"
requires-python = ">=3.7"
classifiers = [
    "Programming Language :: Python :: 3",
    "License :: OSI Approved :: MIT License",
    "Operating System :: OS Independent",
]

[project.urls]
"Homepage" = "https://github.com/pypa/sampleproject"
"Bug Tracker" = "https://github.com/pypa/sampleproject/issues"

三、打包

3.1 准备打包环境

python3 -m pip install --upgrade pip
python3 -m pip install --upgrade build

3.2 打包

来到 pyproject.toml 所在目录，打开命令行，运行代码：

Hive SQL 笔记

Sun, 25 Dec 2022 00:00:00 +0000

Hive SQL 不需要注释，它会自己解释自己

1. 数据表操作

1.1 创建 Hive 表

CREATE TABLE [DATABASE].[TABLE_NAME] (
    `id`    BIGINT    COMMENT '学号',
    name    STRING    COMMENT '姓名',
    ttl_score    DOUBLE    COMMENT '总分'
)
COMMENT '枝江中学五年级学生成绩明细表'
PARTITIONED BY (day STRING COMMENT 'day', hour STRING COMMENT 'hour')
ROW FORMAT DELIMITED 
FIELDS TERMINATED BY ',' 
STORED AS TEXTFILE;

Note: 想了解更多，请参考 CREATE TABLE with Hive format

1.2 删除 Hive 表

DROP TABLE [DATABASE].[TABLE_NAME];

DROP TABLE IF EXISTS [DATABASE].[TABLE_NAME];

ALTER TABLE [DATABASE].[TABLE_NAME] DROP IF EXISTS PARTITION (dt='2024-09-01', country='US');

1.3 插入新的行

从查询结果插入：

因果推断笔记

Sat, 16 Jul 2022 00:00:00 +0000

不谜语人的因果推断笔记！

学习统计最好还是学习一下 R 语言。相比 Python，R 是专门用于统计的语言，它提供了更细致的函数和更标准的实现方法。

1. 因果推断入门

小朋友感冒，家长给他吃药，一个星期后就痊愈了。那么“吃药”和“痊愈”是否有因果关系呢？

我们知道普通的小感冒，即使不吃药，一个星期后也会痊愈。因此未必是因为吃药才痊愈的，也有可能是小朋友凭借抵抗力恢复了健康。此时，要进一步分析“吃药”与“痊愈”的因果关系，就要用到因果推断技术。

注意在上述例子中，原因存在两种状态：吃药/不吃药。结果也存在两种状态：痊愈/未痊愈。为了描述方便，我们把：

作为原因的变量：x 叫做控制变量 (control variable)，或解释变量 (explanatory variable)
作为结果的变量：y 叫做响应变量 (response variable)，或被解释变量 (explained variable)

1.1 如何测量因果关系

反事实因果分析框架 是统计学中分析因果关系的一种常见思路。这种思路把一种“状态”与其“反事实状态”造成结果的差异当作因果效应。对于小朋友 $i$ ，反事实因果分析框架反映的因果效应 $\tau_{i}$ 表示为： $$\tau_{i} = Y_{i}(1) - Y_{i}(0)$$ 这里 $Y_{i}(1)$ 代表吃药， $Y_{i}(0)$ 代表不吃药，它们都是观测值。

不难发现， $Y_{i}(1)$ 和 $Y_{i}(0)$ 是无法同时观测到的。这被称为 因果推断的根本性问题 (Holland, 1986)。正如“人不能两次踏入同一条河流”，一旦做出某种选择，其他选择的结果就无从观测了。

由于此“根本性问题”的存在，对 $\tau$ 算不了真实值，只能估计。因果效应 $\tau$ 有三种常见的估计值：

我们约定：是否吃药用 $X$ 表示， $X = 0 \space or \space 1$ ，其中 1 代表吃药，0 代表不吃药。这里有必要区分下， $Y_{i}|X=1$ 是指那些真的吃了药的人的 $Y$ 值。 $Y_{i}(1)$ 、 $Y_{i}(0)$ 则是看不到的一个潜在状态，可能是用统计方法算出的估计值，也可能是模型的外推。

1.ATT (average treatment effect on treated)：实验组平均因果效应 $$\tau_{ATT} = E( \space (Y_{i}|X=1) - Y_{i}(0) \space )$$ 2.ATU (average treatment effect on untreated)：控制组平均因果处理效应 $$\tau_{ATU} = E( \space Y_{i}(1) - (Y_{i}|X=0) \space )$$ 3.ATE (average treatment effect)：平均因果处理效应 $$\tau_{ATE} = \pi * \tau_{ATT} + (1 - \pi) * \tau_{ATU} $$ 其中， $\pi$ 是吃药的人（即 $X=1$ ）在所有样本中所占的比例。

摸鱼侠极客版

Sun, 03 Jul 2022 00:00:00 +0000

老板：退退退

GitHub 项目地址：moyu-bash

1. 缘起

最近刷到一个微信小程序，叫 “摸鱼侠”，它长这样：

这里面有个栏目叫 “今日已摸到”，还挺有意思的，它会计算今日截至当前为止挣到的工资。

我寻思这小程序颜色太过艳丽，容易被老板抓包，便计上心来，打算写个 bash 版摸鱼侠。和生产环境融为一体，纯键盘操控，老板来了一个 ctrl c 便能毁尸灭迹，大大滴方便。

2. 出生

这要实现起来也不难，只要把 (工作秒数 - 休息秒数) * 每秒工资 就好嘛。

我纯纯的 bash 新手，不对之处大家批评。

# Author: github@luochang212

work_start=10:00:00    # 上班时间
lunch_start=12:00:00    # 午饭开始
lunch_end=13:00:00    # 午饭结束
dinner_start=18:00:00    # 晚饭开始
dinner_end=19:00:00    # 晚饭结束
work_end=20:00:00    # 下班时间
salary=40000    # 月薪
day=22    # 每月工作天数


CURRENT_TIME=$(date +"%T")
EMOJI_ARRAY=("(・▽ < )★" "─=≡Σ((( つ•̀ 3 •́)つ" "┗|｀O′|┛" "_(┐「ε:)_" "ヽ( ˘ω˘ )ゝ")

get_second() {
    read -r h m s <<< $(echo $1 | tr ':' ' ')
    echo $(((10#$h*60*60)+(10#$m*60)+10#$s))
}

calc_duration() {
    local start=$(get_second $1)
    local end=$(get_second $2)
    echo $((end-start))
}

calc_work_time() {
    local lunch_time=$(calc_duration $lunch_start $lunch_end)
    local dinner_time=$(calc_duration $dinner_start $dinner_end)
    if [ $(calc_duration $CURRENT_TIME $work_start) -gt 0 ]; then
        echo 0
    elif [ $(calc_duration $CURRENT_TIME $lunch_start) -gt 0 ]; then
        echo $(calc_duration $work_start $CURRENT_TIME)
    elif [ $(calc_duration $CURRENT_TIME $lunch_end) -gt 0 ]; then
        echo $(calc_duration $work_start $lunch_start)
    elif [ $(calc_duration $CURRENT_TIME $dinner_start) -gt 0 ]; then
        echo $(($(calc_duration $work_start $CURRENT_TIME) - lunch_time))
    elif [ $(calc_duration $CURRENT_TIME $dinner_end) -gt 0 ]; then
        echo $(($(calc_duration $work_start $dinner_start) - lunch_time))
    elif [ $(calc_duration $CURRENT_TIME $work_end) -gt 0 ]; then
        echo $(($(calc_duration $work_start $CURRENT_TIME) - lunch_time - dinner_time))
    else
        echo $(($(calc_duration $work_start $work_end) - lunch_time - dinner_time))
    fi
}

show_work_time() {
    local work_sec=$(calc_work_time)
    echo "$(($work_sec / 3600)) hours and $(($work_sec % 3600 / 60)) minutes and $(($work_sec % 60)) seconds"
}

calc_money() {
    local lunch_time=$(calc_duration $lunch_start $lunch_end)
    local dinner_time=$(calc_duration $dinner_start $dinner_end)
    local mnt=$((($(calc_duration $work_start $work_end) - lunch_time - dinner_time) / 60))
    local salary_per_mnt=$(($salary * 100000000 / $day / $mnt))
    local work_sec=$(calc_work_time)
    local money=$((salary_per_mnt * (work_sec / 60) / 1000000))
    echo $money
}

show_money() {
    local money=$(calc_money)
    echo "已挣到：$(($money / 100)).$(($money % 100)) 元"
}

calc_work_end() {
    if [ $(calc_duration $CURRENT_TIME $work_start) -gt 0 ]; then
        echo "距离下班还有：[还没开始上班]"
    elif [ $(calc_duration $CURRENT_TIME $work_end) -gt 0 ]; then
        local time_left=$(calc_duration $CURRENT_TIME $work_end)
        echo "距离下班还有：$(($time_left / 3600)) 小时 $(($time_left % 3600 / 60)) 分钟 $(($time_left % 60)) 秒"
    else
        echo "距离下班还有：[下班啦]"
    fi
}

random_emoji() {
    local len=${#EMOJI_ARRAY[*]}
    echo ${EMOJI_ARRAY[RANDOM % $len]}
}


random_emoji
show_money
calc_work_end

Note: 为了让界面可爱一点，我用颜文字润色了一下！

统计学补完计划

Sat, 01 May 2021 00:00:00 +0000

统计学绝非一门生硬无趣的学科，它有着鲜活的案例和丰富的实验，让我们循着公式乘着代码在统计的海洋里尽情摇摆叭

1. 回归分析

1.1 简单线性回归模型

(1) 回归方程

许多回归分析都是在如下假设前提下开始的： $y$ 和 $x$ 是两个代表某个总体的变量，我们希望用 $x$ 解释 $y$ ，通过一个线性方程，我们可以刻画 $y$ 和 $x$ 之间的关系： $$y=\beta_{0}+\beta_{1} x+u \quad (1.1)$$ 假定方程 (1.1) 在我们所关注的总体中成立，它便定义了一个简单线性回归模型 (simple linear regression model).

其中，各符号含义如下：

$y$ : 因变量（或被解释变量、回归子）
$x$ : 自变量（或解释变量、回归元）
$u$ : 误差项（或干扰项）
$\beta_{1}$ : 斜率参数
$\beta_{0}$ : 截距参数

举例来说，假设我们用方程 (1.1) 来刻画大豆收成： $y$ 表示收成， $x$ 表示施肥量， $u$ 则包括了诸如土地质量、降水量等因素。

(2) 零条件均值假设

只有在我们对 $x$ 和 $u$ 之间的关系做出某种约束时，我们才能计算出 $\beta_{1}$ 和 $\beta_{0}$ 的可靠估计量。

🌟 零条件均值假定： $$\begin{aligned} &\mathrm{E}(u)=0 \quad (1.2) \\ &\mathrm{E}(u \mid x)=\mathrm{E}(u) \quad (1.3) \end{aligned}$$ 方程 (1.2) 和 (1.3) 称作零条件均值假定 (zero conditional mean assumption). 有了这两个约束，我们就能计算 $\beta_{1}$ 和 $\beta_{0}$ 了。

FastAPI 初见

Sat, 21 Nov 2020 00:00:00 +0000

什么是 API？如何从零开始，搭建自己的第一个API？本文带你搭建一个 API 小应用以了解 FastAPI 的使用细节

GitHub 项目地址：calendar-api

什么是 API？

简单来说，API 是软件间相互传输数据的接口。它在生活中十分常见，比如博物馆订票系统中就使用了 API. 当你在手机应用上订票时，手机实际上发送了一个 HTTP 请求给远程服务器。远程服务器解析该请求。当确认所有字段信息均准确无误后，它才会把你的订票信息录入数据库，并回调成功标识。只有当上述操作全都被正确执行时，你的手机才会显示订票成功。

API 程序通常运行在服务端 (server) 上。客户端 (client) 通过向 API 提供的网络接口发送请求，以实现对服务端的通信。服务端收到请求后，对请求进行解析。如果请求是合法的，则执行该请求，并将请求结果回调给客户端。一次典型的 API 请求大体上是这么个过程。

在业务中，有时需要记录每次请求产生的中间状态、运行结果和日志数据。这时就需要 服务端 调用 数据库 (database) 以存储业务中产生的各种信息。

1. REST API

API 本身是高度个性化的，软件间可以用任意数据类型进行通信。但如果 API 缺少规范、各行其是，就会导致软件间沟通成本高企。REST API 就是其中一种规范。REST API 提出了六项指导原则，只要 API 符合这六项指导原则，就可称之为“符合 REST 风格的 API”。

REST API 提出的六项指导原则分别是：

Client–server

Stateless

Cacheable

Uniform interface

Layered system

Code on demand (optional)

[了解更多]

泊松分布的仿真及可视化

Sat, 19 Sep 2020 00:00:00 +0000

本文介绍泊松分布和泊松函数的定义，并通过 Python random 库对泊松分布进行仿真，带你触摸复杂表象下的简单本质。

GitHub 项目地址：python-tips/poisson

1. 从泊松函数讲起

泊松分布表示在给定时间段内发生给定数量的事件的概率。这个定义比较抽象。举个具体的例子，假设你每小时接到电话的概率是固定的，比如每小时 0.05 个，那么你在接下来 1 小时内接到电话个数的概率，就服从泊松分布:

1 小时内接到 0 个电话，对应一个概率值 $P_0$ ；

1 小时内接到 1 个电话，对应一个概率值 $P_1$ ；

… …

1 小时内接到 n 个电话，也对应一个概率值 $P_n$ 。

这些概率值组成一个概率分布列，它们的值 $(n, P_n)$ 在二维坐标下连成一条曲线。这条曲线所在的函数就是泊松分布的概率密度函数。其公式及图像如下：

$$\boxed{P(k | t, \lambda)=\frac{(\lambda t)^{k}}{k !} \exp (-\lambda t)}$$

从公式中，我们可以看出：只要确定了 $\lambda$ 和 $t$ ，该式就退化成了概率 $P$ 关于事件发生次数 $k$ 的函数。类似地，如果我们确定了 $\lambda$ 和 $k$ ，则该式退化成概率 $P$ 关于时间范围 $t$ 的函数。

“确定哪些参数，让函数最终退化成哪些参数的函数”，这个选择和我们的研究目的有关。如果你对不同 $k$ 如何影响 $P$ 值感兴趣，那么就应该确定参数 $\lambda$ 和 $t$ 。如果对 $t$ 和 $P$ 之间的关系感兴趣，那么就应该确定参数 $\lambda$ 和 $k$ 。

漫谈 Hadoop Streaming

Sat, 25 Jul 2020 00:00:00 +0000

本文聚焦如何通过 Hadoop Streaming + Python 编写 Hadoop 程序。

众所周知，实现分布式计算是一个繁琐的过程。Hadoop 通过一个标准化的数据处理流程，简化操作步骤，让没有分布式计算背景的程序员也能轻松写出分布式程序。Hadoop 本身是用 Java 写的，因此对于非 Java 程序员来说，学 Hadoop 必须先学 Java，这大大降低了 Hadoop 的友好程度。

Hadoop Streaming 就是为了解决这个问题而生的，它支持用其他编程语言编写 Hadoop 程序。

1. 分布式系统的由来

经历半个多世纪的高速增长，半导体工业在本世纪初触及了它的物理瓶颈，摩尔定律失灵，硬件算力不再高速增长，人们开始关注利用软件方法来提升算力。

2003年，两名谷歌工程师开发了一个分布式存储系统，这是它的前身。经过几位后来者添枝加叶，该系统在 2006 年开源，并发展成为今天我们熟知的 Hadoop。

使用分布式系统，显而易见的好处是能够缩短程序运行的时间。在常规时间就能跑完的程序上使用 Hadoop 无异于画蛇添足。但是对大数据开发人员来说，使用 Hadoop 意味着不必坐在电脑前为了结果等上一整天。如果集群效率够高，完全可能在几分钟内完成单机一天的计算量。

2. Hadoop 基本介绍

Hadoop 有两个重要的组成部分：HDFS 和 MapReduce。

HDFS 是一个分布式存储系统，它负责将文件切割成分片，然后分发到集群中的目标机器上进行存储；MapReduce 负责构建一个标准化的数据处理流程，在完成其规定的几道数据处理流程之后，用户将得到他们期望的结果。

这意味着 Hadoop 的学习至少包括两个部分。要掌握 HDFS，你需要掌握 Hadoop 命令行命令，这将在第7节详细介绍。要掌握 MapReduce，如果你是 Python 开发者，你需要掌握 Hadoop Streaming，这将在下一节中介绍。

3. MapReduce

MapReduce 的重要性不言而喻，它定义了数据在 Hadoop 中被如何处理。MapReduce 包含三个重要过程：Map, Shuffle 和 Reduce。其中，Map 和 Reduce 由我们来编写，Shuffle 则由系统自动完成。

Python 工程化实践

Sun, 14 Jun 2020 00:00:00 +0000

学 Python 不应仅限于学编程，同样应该学习工程知识，比如虚拟环境、编码风格以及单元测试等。本文致力于介绍 Python 工程化所需的前置知识。

⚠️ 注意：以下教程适用于 MacOS。

部署环境

1. Anaconda

Anaconda 是一个包管理器，它能让你方便的管理 Python 版本和包版本。并且， Anaconda 聚合了 Jupyter notebook，使其大受数据科学家和人工智能工程师的欢迎。下面我们来介绍如何用 Anaconda 管理我们的 Python 环境。

如果你还没有 Anaconda，安装一个：

海外用户直接访问 Anaconda 官网下载即可
国内用户无法访问 Anaconda 官网(被墙)，建议选择清华镜像替代。

安装完以后，在命令行界面输入 conda，会打印一个帮助文档。

帮助文档大概是说 conda 有哪些常用命令，比如下面这些：

$ conda help  # 打印帮助文档
$ conda info  # 查看conda信息，包括当前在哪个环境，环境路径，Python版本等信息
$ conda list  # 列出conda下安装了哪些包
$ conda install [package_name]  # 在conda环境中安装某个包
$ conda update [package_name]  # 升级conda环境中的某个包

Note：后文仅专注介绍虚拟环境相关内容，更多内容请在 Anaconda 官方文档中查看。

Python 环境分为本地环境(lcoal env) 和全局环境 (global env) 。为一个项目配置环境，应该配置本地环境；为本机所有项目配置环境，则应该配置全局环境。

① 部署全局环境

📖 新建环境

算法集萃

Fri, 03 Apr 2020 00:00:00 +0000

算法学习笔记，长期更新

GitHub 项目地址：python-tips/algorithms

排序

本节介绍各种排序算法的思路和特点，并提供了示例代码。

用魔法打败魔法！

Fri, 21 Feb 2020 00:00:00 +0000

Chico 和 Dico 是两位魔术师，他们有一个经典魔术：根据任意四张牌猜第五张牌。但完成这个魔术并不需要任何魔术师的技巧，因为它完全建立在数学原理之上。只需要一点数学知识和充分的练习，你也能表演这个魔术！

GitHub 项目地址：chico-and-dico

Chico 和 Dico 的魔术

Chico 和 Dico 是两位魔术师，他们经常表演的一个魔术是这样的：Chico 将一副 52 张的扑克牌交给一位观众，让他随机抽取其中的 5 张。然后 Chico 将这 5 张牌按一定的顺序重新排列，再将其还给观众。上述整个过程 Dico 都是看不见的。然而，当观众按 Chico 排好的顺序依次展示前四张牌之后，Dico 却能准确地说出第五张牌是什么。

乍一看这个魔术很神奇。随机抽取 5 张牌，你能从前 4 张牌中看出第 5 张牌是什么吗？对于普通人来说，当然不可能。Chico 和 Dico 的秘诀在于 Chico 有机会将扑克重新排序。如果两人事先约定好某种协议，Chico 是有可能通过扑克排列的顺序，向 Dico 传递关于第 5 张牌的信息的。

关键在于如何实现这种协议。

数学模型

在进行分析之前，我们需要把 Chico 和 Dico 的魔术抽象成一个数学模型。

魔术本身已经提供了一些建模信息。我们可以假设一共有 n 张牌，抽取其中的 k 张。在对牌组进行某种排序之后，我们需要利用前 (k - j) 张牌的信息，推测后 j 张牌是什么。

现在我们有 n, j, k 三个变量，下面我们来进一步探究三个变量之间究竟服从何种关系。

达尔文的故乡

Wed, 12 Feb 2020 00:00:00 +0000

英国小镇 Shrewsbury 是达尔文的故乡。这里有丰沛的水系、星罗棋布的公园、历史悠久的建筑。这里没有如织的游人，是一座安静的小镇。

9月初，新生乍到老生未还，突然涌现的短租需求，使本地短租公寓一时爆火。

看着 Airbnb 上比平时高了百分之两百的房租。我决定离开这座城市，去别处居住一段时间。

达尔文的故乡

Shrewsbury 是达尔文的故乡。这座小镇水系纵横，有很多河流、小桥、公园。人不多，十分安逸。

这并不是我第一次来这里。寒假我曾周游英国，游历 11 座城市，对 Shrewsbury 颇有好感。所以这次离开英国之前，选择故地重游。

房东

房东是一对老夫妻，有很多孩子，现在已与他们分居，所以剩下了许多空房。我住的是他们小儿子的卧室。

吃完早餐，我问女房东英国还有像 Shrewsbury 这样美丽的小镇吗？房东对我的问题有些不解，她说 everywhere in this country。嘿嘿嘿，这回答可有些过于骄傲了。英国美丽的小镇不少，但此地绝对算中上水平。

夫妻俩日子过得讲究，早上要喝茶，晚上要下馆子。只有中午吃得简陋一点，一般是烤面包或者三明治。

他们下午去遛狗。狗是一只小母狗，叫莉莉。

有天我去超市买东西，正好遇见他们遛狗回家。逆着夕阳，两人牵手回家的场景让我有一瞬恍惚，仿佛我看到的是两个夕阳下的青年，他们脸上明媚的笑容和热情的招呼让我忘记他们的年纪。

屋里屋外

房子是独栋别墅，有车库和后院。从房子的年龄看，他们已经富裕了很多年。

我房间的窗外是一片森林。夜晚森林里黑得诡异，让人想起中世纪的欧洲。白天森林里阳光普照，林间空地上，几个孩子在做游戏，边上是孩儿妈，坐在木头长椅上发呆。

房东很有品味，屋里挂着很多抽象到看不懂的布艺和画，桌子上摆着陶的、木的装饰品。当然，最令人羡慕的还是他们的阳光房，布置得实在太美啦！

小镇风光

房东家在郊区，但距离小镇不算太远，步行半小时能到镇上。

和大多数英国小镇一样，这里有许多老房子、老街道。数百年前的城市风貌一直延续到了今天。

众多的水系、桥梁、公园组成了这座小镇迥异的风景线。

一条凶狠霸道的链子！

后记

为什么英国城市会形成如此风光，我试图总结一些因素：

英国的主要产业是金融、教育和文化产业。这些行业污染低利润高，所以英伦三岛才有如此美丽的自然风光
近代城市文明是英国率先建立起来的。无论是建筑技术还是审美都是一脉相承。所以英国的古建筑和现代建筑之间能够相处融洽、相得益彰
英国的城市一般规模小车流小，很少有建宽大主干道的需求。客观上道路对行人通行的切割和限制就少了很多，更加 walkable
重视社区氛围营造，社区内有充足的休憩空间和社交空间，比如驻唱酒吧、公园长椅、咖啡馆、书店、中古商店

这些因素造就了英国独特的城市风貌和交通格局。有些优点中国无法照搬照抄，但也许可以启发当代中国建设者。尤其是城市格局与英国相似的中国县城和小镇，颇能借鉴英国在城市交通、景观园林、商业布局方面的设计。

贝叶斯方法

Fri, 31 Jan 2020 00:00:00 +0000

统计学中有两大学派，频率学派和贝叶斯学派。频率派用总体信息和样本信息进行统计推断。而贝叶斯派除了使用以上两种信息之外，还使用先验信息进行统计推断。本文从数学原理和编程实践两个方向探究贝叶斯方法。

本文从数学原理和编程实践两个方面来介绍贝叶斯方法。

数学原理

贝叶斯理论包含很多内容。我们熟悉的利用先验分布推后验分布的方法被称为贝叶斯推理（Bayesian inference）。此外，还可以利用参数的后验分布的均值作为该参数的点估计，这种方法被称为贝叶斯估计（Bayesian estimation）。本文数学原理部分主要介绍贝叶斯推理和贝叶斯估计。

理论部分为六节，各节的主要内容如下。

章节	主要内容
第一节	用一个简单的实例，让大家对贝叶斯方法有一个形象的认识。
第二节	用一个复杂的实例，让大家对贝叶斯方法的术语有一个形象的认识。
第三节	介绍贝叶斯公式的事件形式及其推导。
第四节	介绍贝叶斯公式的密度函数形式及其推导。
第五节	介绍贝叶斯估计。
第六节	探索联合分布蕴含了哪些信息。

一、实例：癌症化验的准确率

下面请各位做题家们做一下你们最爱的经典老题

📖 题目

有两个可选的假设：

病人有癌症（cancer）、病人无癌症（normal）

可用数据来自化验结果：

正（+）、负（-）

有先验知识：

在所有人口中，患病率是 0.8%。对确实有病的患者的化验准确率为 98%，对确实无病的患者的化验准确率为 97%，总结如下：

$ P(cancer) = 0.008, P(normal) = 0.992 \\ P(+ | cancer) = 0.98, P(- | cancer) = 0.02 \\ P(+ | normal) = 0.03, P(- | normal) = 0.97 $

问题：

我的 Python 不可能这么可爱

Thu, 14 Nov 2019 00:00:00 +0000

Python 学习笔记，如有错误，欢迎指正

GitHub 项目地址：python-tips

相关书籍推荐：

入门：《Python编程从入门到实践》 [豆瓣链接]

初级：《Python学习手册》(英文名 Learning Python) [豆瓣链接]

中级：《流畅的Python》[豆瓣链接]

PS: 针对每个阶段，我推荐的是我认为最好的那本书。

语言基础

列表

本文从以下几个方面介绍列表：

Elasticsearch 初探

Thu, 24 Oct 2019 00:00:00 +0000

Elasticsearch 是一个开源分布式全文搜索引擎。它建立在当前最先进有效的搜索引擎库 Lucene 之上。Elasticsearch 集成了 Lucene 的检索功能，并通过一套简单的 API 隐藏了 Lucene 的复杂性，使之简单易用。

初识

ES 的初步介绍

本节将介绍 ES 的几个特性。这些介绍能帮助我们理解 ES 是应什么需求诞生的？它解决了什么问题？它为何如此架构？以及这种架构方式为它带来哪些性能上的提升？这些信息虽然不能直接提升我们使用 ES 的能力，但能从更深的维度帮助我们使用好它。

不仅仅是搜索

ES 不仅能够搜索，它还提供一套分布式实时存储文档的解决方案。 ES 允许用户将数据存储在多个服务器节点上。这些节点能实时共享数据。一旦主节点的内容发生改变，这些改变会实时传递到副节点上，以保证主副节点的内容一致。如果主节点掉线，ES 能立即选举出一个副节点充当主节点。选举过程就像切换开关一样，能够在瞬间完成，从而保证了 ES 的可靠性。

分布式的存储方案不仅仅是基于数据安全的考量，同时也是为了加快检索的速度。利用 MapReduce，ES 可以在多个节点上并行地检索数据，大大缩短了海量数据处理的时间。

领域专用语言

为了统一查询语法，ES 设计了一套领域专用语言 (DSL, domain specific language)。这套语言基于 JSON，优点是简单易学，缺点是在表达复杂的查询时，会显得格外冗长，阅读起来也不太友好。

SQL 和 NoSQL

SQL 全称 Structured Query Language。SQL 中的 Structured 突出了它是结构化的查询语言。结构化即受字段限制。SQL 数据库中的每条数据都具有相同的长度，因此可以被视作一张数据表。相比于 SQL，NoSQL 能表达更复杂的内部数据结构。字段之间不相互影响，可以拥有各自的层级结构。因此 NoSQL 数据库要比 SQL 数据库更加灵活且易于拓展。NoSQL 数据库中的数据通常用 JSON 表示。

入门

一些简单概念

文档

在 ES 中，文档是一个特定的术语。它表示用来存储对象的存储单元。一个对象通常不会是简单的键值对，它可能包含更复杂的数据结构，比如日期、地理数据、数组等。为表达这种复杂的、多层次的数据，ES 将 JSON 作为文档存储的固定格式。也就是说在 ES 里，一个文档被存成一个 JSON 值。

Monaco Editor 入门指南

Mon, 07 Oct 2019 00:00:00 +0000

⚠️ 注意：本教程已过时。本教程的正确食用方法是从 GitHub monaco-editor-demos 上直接下载代码，然后点击 index.html 直接查看 Demo 及源码。本文中描述的构建方法可能已不适用（更新于 2024.04）

GitHub项目链接：monaco-editor-demos

在学习 Monaco Editor 的过程中，我发现网络上的中文教程很少。为了填补这部分空白，我决定写一份入门教程，帮助初学者快速熟悉 Monaco Editor。通过阅读本文，你可以了解以下内容：

如何安装
如何搭建
如何调用常用 API
如何寻找学习资源

安装

新建项目文件夹，打开它：

$ mkdir my-application
$ cd my-application

确保你已经下载了 npm，然后安装 Monaco Editor：

【项目】摩纳哥语音编辑器

Thu, 22 Aug 2019 00:00:00 +0000

摩纳哥语音编辑器（Monaco Speech Editor）是一款适用于视障人群的在线代码编辑器。它在开源编辑器 Monaco Editor 的基础上，开发了专为视障者设计的语音辅助功能，包括鼠标悬浮提示，快捷键操作和代码阅读。

其代码阅读功能尤其强大，用户可以用键盘精确定位指定内容进行阅读。针对同一段代码，它提供多种语音输出模式：字符模式、代码模式、音乐模式、全局模式。这些模式根据用户在不同编程阶段的不同需求，提供差异化的语音输出。比如，当用户对一个语句进行 debug 时，推荐使用字符模式进行语音播放。

如果你对它的功能感兴趣，点击下方链接尝试一下吧

GitHub 项目地址：monaco-speech-editor

项目背景

根据世界卫生组织2010年的数据，全盲者在全年龄段人口中所占比例为0.58%。在全盲人口中，大部分是中老年人口。从下图可以看出，致盲风险随着年龄快速升高。在0～14岁人群中，全盲比例仅有0.07%；在15～49岁人群中，全盲比例稍高一些，为0.16%；而在50岁以上人群中，全盲比例则达到了2.39%。

全盲人口的比例不大，但从绝对数值来看却是非常可观的。2010年，世界全盲人口比例为0.58%，但全盲人口数却达到了3936.5万。即使14岁以下人口的全盲比例仅有0.07%，但考虑绝对数值，也达到了142.1万人。

而且并非只有全盲者才需要语音辅助。有相当比例的视力障碍者，即使使用眼镜，也无法矫正到正常视力。这部分的视障者，也是需要语音辅助的。相比于全盲者，视力障碍者的人口则更为庞大，达到了惊人的2亿8538万。

在提倡公平的原则下，我们希望视障者和视力正常的人一样，也能自由地选择职业。事实上现在已经有[部分视障工程师](http://www.xinhuanet.com/2018-01/04/c_1122206710.htm)，出现在程序员岗位上，证明着他们的实力。本项目旨在为视障程序员编程无障碍化做一些贡献，[项目源代码](https://github.com/luochang212/monaco-speech-editor)现已在GitHub上以MIT许可证开源。

技术选择

本编辑器是用JavaScript编写的网络应用 (web application)。它只有两项功能需要外部依赖，一个是在线代码编辑器模块，一个是文字转语音模块。

（一）在线代码编辑器

开源的在线代码编辑器还是挺多的，比如：

它们对语法高亮、缩进、代码补全等基础功能都有比较好的支持，用起来大同小异。选择Monaco Editor是因为用惯了VSCode。毕竟Monaco Editor的源代码就是直接从VSCode贴过去的，两者的界面风格和操作方式都极其相似，对VSCode用户比较友好。但后来使用过程中发现打脸了，当然这是后话。

（二）文字转语音

文字转语音 (text to speech) 的应用就更多了，几乎各大公司都推出了自己的应用：

但鉴于这些应用都需要网络连接，才能获取语音。考虑到网络延迟和脱机使用的问题，本项目并未采用以上任何一种API，而是选择了Web Speech API。Web Speech API本身并不提供语音服务，它事实上起到资源连接的作用。它首先会搜索操作系统，然后将操作系统提供的语音支持集合成一个列表，提供给浏览器使用。所以Web Speech API提供的语音支持会随用户系统的语音支持项而发生变化。因此不排除一些较老的机型无法使用的可能。但本项目认为本地化语音支持比之于对老机型的支持更加重要，因此选择了Web Speech API。这也是一个取向问题。

排队论在网络性能分析中的应用

Thu, 04 Jul 2019 00:00:00 +0000

排队论(queueing theory)也称随机服务系统理论，它研究的内容有三部分：性态问题、最优化问题和统计推断问题。（《运筹学》清华大学出版社）

下图描述了排队过程的一般流程：

现实中的排队问题是多种多样的，对上述“顾客源”和“服务机构”应该作宽泛的理解。顾客和服务机构可以是生物，也可以是非生物；排队结构可以是有形的，也可以是无形的，比如向交换台要求通话的请求；顾客可以走向服务机构，也可以相反，比如送货上门。

在网络中，服务器和用户之间相互传送数据包。数据包的传送需要时间，因此或多或少都会产生延迟。为了分析这些延迟，我们引入了一系列假设，并利用排队论对网络延迟进行建模分析。

本文将着重介绍网络性能分析(Network performance analysis)中几种常见的排队模型。它们是：

The M/M/1 queuing system
The birth-death process
The M/M/m queuing system
The M/M/1/m queuing system
The M/M/∞ queuing system
The M/M/m/m queuing system

另外，作为以上模型的理论基础，本文将首先介绍泊松过程(Poisson process)。

泊松过程的推导

泊松过程是马尔可夫过程的一个特例，在排队论中经常被用来估计顾客到达的概率分布。

（一）泊松过程的假设

在时间间隔$\Delta t$内，有且仅有一位顾客到达的概率$P$和$\Delta t$成比例，比例系数为$\lambda$
在时间间隔$\Delta t$内，至多只允许一位顾客到达（否则应该选取一个更短的时间间隔） $$\begin{aligned} P(\text { 在时间间隔 }[t, t+\Delta t] \text { 内，有且仅有一位顾客到达 }) &=\lambda \Delta t \\ P(\text { 在时间间隔 }[t, t+\Delta t]\text { 内，没有顾客到达 }) &=1-\lambda \Delta t \\ P(\text { 在时间间隔 }[t, t+\Delta t]\text { 内，多于一位顾客到达 }) &=0 \end{aligned}$$

厨房笔记（二）：快手菜合集

Tue, 02 Jul 2019 00:00:00 +0000

做饭累不累？如果你只是偶尔做一顿饭以娱身心，还是挺快乐的。但要是餐餐下厨，就没那么好玩了。一日三餐，少说也要花费两三个小时的光景，不但耗损精力，还挤占学习时间。日复一日地做下来，不累才怪。因此，长期做饭的留学生往往会体现三种趋势：做饭价格向便宜收敛，做饭速度向手快收敛，做饭味道向好吃收敛。因为咱追求的就是便宜美味的同时，又省时省力不麻烦。那么下面就由我来给大家盘点一下那些好吃又方便的快手菜吧

牛肉丸子汤

原料：牛肉丸、醋、香油、白胡椒粉、辣椒粉、葱

做法：

锅内放牛肉丸，加水至没过牛肉丸，火开到最大。
等水煮开的同时，把葱切成葱花备用。
待水煮开，调成中火，保持水面沸腾。然后开始调味，按个人口味加醋和辣椒粉。加白胡椒半勺，香油数滴。
牛肉丸还是比较易熟的，水开后再煮五至七分钟，加葱花，稍微再煮一分钟，即可起锅。

炸三文鱼

原料：三文鱼片、面粉、盐

做法：

TESCO买的厚三文鱼片，均匀地敷上面粉，直至表面摸不到水分。
锅里倒少量油铺匀锅底，开中火将油烧热。
注意三文鱼易焦，只能开小火煎。翻面也不能太勤，否则鱼容易碎。大概三分钟左右翻一次面，反复翻面直至两面煎至金黄。
煎十分种左右起锅。注意火候，煎得太短里面不熟，煎得太久肉会变柴。

烤羊排

原料：羊排、酱油、孜然、黑胡椒、盐、芝麻

做法：

羊排切段，加黑胡椒，加酱油，加孜然，加盐腌二十分钟。
放入烤箱，开170度，烤四十分钟。
出烤箱后撒点芝麻点缀。

淡菜排骨汤

原料：排骨、淡菜、豆腐、生姜、蒜

做法：

烧一锅水，同时把豆腐切块，淡菜洗干净备用。
下排骨，煮出浮沫后，将排骨捞出，用冷水把排骨冲洗干净。
再烧一锅水，下淡菜、排骨、豆腐、两瓣蒜、几片生姜，盖上锅盖煮十分钟。
淡菜有自身的鲜味，不用调味，起锅即食。

炒鸡蛋

原料：鸡蛋、葱、洋葱、猪油

做法：

葱和洋葱切段备用。蛋打成蛋液，加盐备用。
把葱白和洋葱下锅炒香，剩余葱段放入蛋液中拌匀，待锅内葱香味溢出，下鸡蛋液。
鸡蛋液微微凝固时，立刻用筷子从四周向中间拨动，使蛋液凝固过程中均匀受热。注意拨动的节奏，不需要拨得太勤或者太缓。
当鸡蛋熟了以后，应该还是一整块的，而且比较滑嫩。此时，把筷子插入鸡蛋块中，画圆圈将鸡蛋块打散。
把打散的鸡蛋再翻炒几下，当鸡蛋表面微焦、香味溢出时即可出锅。

注：如果油放得少，油温不宜太高，因为鸡蛋容易焦。如果油放得多，那么油温可以适当高一点，这样炒蛋会有油炸的效果，蛋的边边被油炸过后会卷起来，酥酥脆脆的很香。

生态系统建模

Wed, 12 Jun 2019 00:00:00 +0000

本文介绍如何用 Agent-based model 的方法，对一个包含狼、麋鹿、草三种生物的生态系统建模。

GitHub 项目地址：nature-system

Agent指个体，Agent-base model即基于个体的模型。在Agent-based model中，虚拟实体(virtual entity)和现实个体一一对应。一般来说，虚拟实体的属性是对现实个体的抽象，虚拟实体的行为则是依照已经写好的规则迭代。这种建模方式往往涉及个体详细的行为模式，因此适合以研究个体行为规则为目的的建模。

需要注意的是，利用Agent-based model方法建模，并不是变量越多越好，过多的变量会造成调试上的困难。选取的变量足够支撑起我们研究的问题就可以了。

Note: 除了Agent-base model之外，Equation-based model也是一种比较常见的建模方式。Agent-based model适合表达每个个体身上发生了什么，比如个体的速度、位置的变化等。Equation-based model则而更适合表达系统平均发生了什么，比如人口模型中人口数量变化就更适合用Equation-based model建模。

模型假设

（一）生物的属性

模型内有三种生物：狼(wolf)、麋鹿(moose)、草(grass)。此外，狼还分为头狼和普通狼。下面这张表展示了头狼、普通狼、麋鹿的属性：

#	age	food	pos	speed	last_breed	population	packNo	range	eaten
头狼	√	√	√	√	√	√		√	√
普通狼	√	√	√	√			√
麋鹿	√	√	√	√	√

从上表可以看出，年龄、食物、位置、速度是头狼、普通狼和麋鹿的共有属性。last_breed指和上一次生育的时间间隔，在模型内用一次迭代表示一次时间间隔，因为迭代必须是整数，因此last_breed也是整型变量。头狼特有population属性，用来表示该头狼所在狼群中狼的数量；头狼特有range属性，表示该狼群活动的范围；头狼特有eaten属性，表示狼群在一次迭代中，全体成员吃到的麋鹿的总数。普通狼特有packNo属性，用来标记其所属狼群的头狼在列表中的索引号。普通狼没有last_breed属性，是因为其生育是以整个狼群为单位的。由于狼群是由头狼定义的，狼群相关的属性和行为也绑定在头狼身上，因此在代码实现上，狼群的生育是通过头狼实现的。

草没有上述生物那么复杂的模型，本模型中的草均匀平铺在环境中，且不会生长，吃完就没了。因此麋鹿为了获取新的食物来源，需要经常迁徙。

（二）生物的行为

头狼、普通狼和麋鹿都具有四种行为：死亡、迁徙、生育、捕猎。这四种行为在不同的生物种类上有不同的定义。比如麋鹿的迁徙规则是等到自己的位置没草吃了，才开始迁徙。而头狼迁徙规则则比较复杂，头狼会根据狼群内的种群数量，判断狼群的散布范围，以及调整迁徙的积极性。

1.死亡(die)

狼有两种死法：饿死或老死。麋鹿则有三种死法：饿死、老死或者被吃。

JavaScript 初探

Fri, 24 May 2019 00:00:00 +0000

初次学习JavaScript，用JS写了一个计划表生成工具。

项目链接：计划表生成工具

JavaScript是一个神奇的语言。它既不像Java原生地支持类和继承，也不如Python声明变量方便，更兼闹出"===“这样的麻烦。但我依旧深知它的强大，尤其是在可视化这一方面，在接触qtwebengine的时候已经感受过一次了。目前，我学习JS的平台是W3Schools 和廖雪峰的网站。

话说这是我自学JS以来写的第一个程序，求轻虐(￣▽￣)

我的初衷

我的初衷是制作一个习惯统计工具，用来分析我在长期计划上的坚持能力。于是照例我对它做了一个需求分析。

习惯统计工具的需求分析：

需要用户能够注册。即能够声明我是谁，并且把我和我的数据绑定。
需要将数据存在文件里，而不是存在缓存文件里。
需要按时间戳对生成的数据进行统计。
需要对最终结果制作统计图表。

通过分析，我发现静态网页很难实现第一第二步。能不能实现我不敢下定论，但肯定有技术难度。目前，我只有一个由GitHub page托管的静态网页，因此我选择退而求其次。先学习生成一个单一的表格，来记录当天计划的执行情况。我把这个工具叫做计划表生成工具。

需求分析

计划表生成工具好比是习惯统计工具的一个子系统。习惯统计工具面向的是连续多天，而计划表生成工具只面向单独一天。

计划表生成工具的需求分析：

一个UI界面（前端）
一个允许用户做输入、选择和修改操作的数据流（后端）
一个最终显示的表格（前端）
判断此工具是否easy to use，找到不好用的因素并改进（测试）

此时我们的big picture就已经明确。战略定了，下面来定战术。

步骤分析

（一）添加计划

对于前端UI，首先我们需要一个textarea，用来接收每项计划的内容。还需要一个按钮，点下这个按钮时，将文本框内的信息添加到计划列表。为了便于存储，我为计划(item)设计了一个类。

这个类的声明如下：

var Items = {
　　　　    name: "",
　　　　    isCheck: "false",
           isDelete: "false"
    };

可以看出这个类有三个值。它们分别表示该对象的名称，是否完成，以及是否删除。每次添加计划，用以下代码实例化这个类(items)，生成一个对象(item)：

var item = Object.create(Items);

（二）生成表格

这一步要把复选框(checkbox)和按钮(button)都和每一行的计划绑定。那么如何绑定呢？

要知道，用for loop遍历subArray的过程，就是生成表格内容的过程。所以，checkbox和button也都是在这次遍历中生成的。那么，我们就可以在它们的生成过程中，创建它们的id，并把id和计划对应起来。

具体到代码中，我用了i.toString(10)将循环数转成string类型，然后加到id上。于是，第一项计划对应的checkbox的id就是"cb0”, 对应的button的id就是"btn0", 以此类推。

for (i = 0; i < subArray.length; i++) {
    var index = i+1;
    body += '<tr>';
    body += '<td>' + index.toString(10) + '</td>';
    body += '<td>' + '<input type="checkbox" id=\"cb' + i.toString(10) + '\" onclick="isChecked(this);">' + '</td>';
    body += '<td>' + '<input type="button" id=\"btn' + i.toString(10) + '\" onclick="isDeleted(this);">' + '</td>';
    body += '</tr>';
}

然后在勾选复选框或者删除的时候，只需要把前面的"cb"和"btn"去掉，剩下的数字i带入subArray()，得到的subArray(i)就表示着该checkbox或者button对应的计划。

（三）下载表格

这一步在我编程之前，还不知道用什么方法实现。最后被我查到了一段代码，它能在静态网页下生成文件并提供下载。

    function download(filename, text) {
        var element = document.createElement('a');
        element.setAttribute('href', 'data:text/plain;charset=utf-8,' + encodeURIComponent(text));
        element.setAttribute('download', filename);

        element.style.display = 'none';
        document.body.appendChild(element);

        element.click();

        document.body.removeChild(element);
    }

技术总结

总体来说，这三步都不困难。我花了大约8小时写这个project，其实还是吃亏在初学。前期两小时左右，在画图、规划、分析、简化功能……直到把野心降低到我能完成的程度。接着连续编了四小时的程序，整个项目就从无到有做出来了。然后又花了一些时间修改CSS，美化页面。第二天上午又花了近两小时，把Enter键变成“添加计划”的快捷键，并用Shift + Enter替代原本Enter键的功能。这是easy to use上的改进。

PyQt5 侧边栏布局

Fri, 10 May 2019 21:43:09 +0100

GitHub 项目地址：pyqt5-demo

主流软件如网易云音乐、腾讯电脑管家，都有侧边栏。侧边栏能有效扩展应用空间，使软件功能的层次更加分明。

但PyQt5并没有一个专门的方法实现侧边栏。要实现侧边栏，主要有两种技术路线。一是从标签部件(QTabWidget)改造而来，二是用网格布局(QGridLayout)画出来。本文采用第一种技术路线，制作一个简单的侧边栏应用。

Note: 两种技术路线制作的侧边栏有细微的差别。如果采用第二种技术路线(QGridLayout)，侧边栏和内容页之间没有明显的分界。所以需要额外地在侧边栏和内容页之间加一条线，来突出两者属于不同的组件。而第一种技术路线(QTabWidget)不需要，创建的侧边栏和内容页之间的区别明显。

下图是一个用第二种技术路线(QGridLayout)制作的应用，可以看到侧边栏和内容页中间画了一条线，以突出两个组件的分界。

步骤分析

在开始写代码之前，我们先分析一下制作侧边栏需要几个步骤。

添加部件
为部件设置布局
将标签部件改造成侧边栏的内容页
为侧边栏按钮编写函数，实现内容页之间的跳转

添加部件并设置布局

此段不详述。关于部件和布局的基础知识，在上一篇中有介绍，详见PyQt5 布局浅析。

下面这段代码添加了部件且设置了布局。

from PyQt5.QtWidgets import *
import sys


class Window(QMainWindow):
    def __init__(self):
        super().__init__()

        # set the title of main window
        self.setWindowTitle('Sidebar layout - www.luochang.ink')

        # set the size of window
        self.width = 800
        self.height = int(0.618 * self.width)
        self.resize(self.width, self.height)
        
        # add all widgets
        self.btn_1 = QPushButton('1', self)
        self.btn_2 = QPushButton('2', self)
        self.btn_3 = QPushButton('3', self)
        self.btn_4 = QPushButton('4', self)

        self.initUI()

    def initUI(self):
        left_layout = QVBoxLayout()
        left_layout.addWidget(self.btn_1)
        left_layout.addWidget(self.btn_2)
        left_layout.addWidget(self.btn_3)
        left_layout.addWidget(self.btn_4)
        left_layout.addStretch(5)
        left_layout.setSpacing(20)
        left_widget = QWidget()
        left_widget.setLayout(left_layout)

        self.right_widget = QTabWidget()
        self.right_widget.tabBar().setObjectName("mainTab")

        main_layout = QHBoxLayout()
        main_layout.addWidget(left_widget)
        main_layout.addWidget(self.right_widget)
        main_layout.setStretch(0, 40)
        main_layout.setStretch(1, 200)
        main_widget = QWidget()
        main_widget.setLayout(main_layout)
        self.setCentralWidget(main_widget)


if __name__ == '__main__':
    app = QApplication(sys.argv)
    ex = Window()
    ex.show()
    sys.exit(app.exec_())

PyQt5 布局浅析

Fri, 03 May 2019 00:00:00 +0000

PyQt5是Python环境下用来开发UI界面的一个包。它容易上手，对初学者友好，并且拥有丰富的函数库，可以实现大部分桌面应用的开发需求，且支持QSS语言，能够对界面风格做个性化调整。总体来说，PyQt5是一款开发效率极高的UI框架。这篇文章从零开始，教你搭建一个属于自己的桌面应用。

GitHub 项目地址：pyqt5-demo

创建第一个窗口

一般来说，桌面应用都以窗口(window)形式呈现。因此，要搭建桌面应用，首先要创建窗口。

下面这段代码创建了一个空的窗口。

from PyQt5.QtWidgets import *
import sys


class Window(QMainWindow):
    def __init__(self):
        super().__init__()

        # set the title of main window
        self.setWindowTitle('My first window - www.luochang.ink')

        # set the size of window
        self.Width = 500
        self.height = int(0.618 * self.Width)
        self.resize(self.Width, self.height)


if __name__ == '__main__':
    app = QApplication(sys.argv)
    ex = Window()
    ex.show()
    sys.exit(app.exec_())

这段代码仅仅设置了窗口的标题和大小。下一步，我们要往这个空的窗口里添加部件(widget). 为了规范性，我们在Window类里新建一个函数initUI, 然后在initUI里为窗口添加部件。

为窗口添加部件

下面这段代码为窗口添加了一个按钮部件(QPushButton).

from PyQt5.QtWidgets import *
import sys


class Window(QMainWindow):
    def __init__(self):
        super().__init__()

        # set the title of main window
        self.setWindowTitle('My first window - www.luochang.ink')

        # set the size of window
        self.Width = 500
        self.height = int(0.618 * self.Width)
        self.resize(self.Width, self.height)

        self.initUI()

    def initUI(self):

        # create a new button
        self.btn = QPushButton('first Button', self)
        self.btn.resize(300,90)


if __name__ == '__main__':
    app = QApplication(sys.argv)
    ex = Window()
    ex.show()
    sys.exit(app.exec_())

微博数据可视化

Sat, 20 Apr 2019 00:00:00 +0000

GitHub 项目地址：weibo-analysis

这次的数据用的是本科期间就已经爬好，但因为当时没有足够的处理技巧，这些数据在硬盘里一丢就是两年。如今，本Python初丁趁着还有机会摸鱼，赶紧把数据翻出来，让它们发光发热。

文本获取

因为新浪微博的严防死打，现如今微博的数据越来越不好爬。GitHub上的微博爬虫生存周期通常都很短，使爬取数据的成本大大增加。这里我用的是微博@失眠狸同学的方法，用鼠标精灵写了个插件，控制快捷键和页面拖动，把内容从浏览器上粘贴到sublime里。

生成csv文件

有了原始数据，接下来我们要把数据归一化，做成方便处理的数据。一个常用的方法就是将数据整理成csv文件。

Step 1. 分析需要保存的字段以及数据的维度，从而设计出数据的存储结构。根据原数据，我划分了五个字段: id, date, time, device, content, 它们分别记录一条微博的文件位置、发布日期、发布时间、发送设备和文本内容。

Step 2. 分割raw data. 先用split函数进行粗略分割，再用find函数精确分割。接着将分割好的内容提取到各字段，并依次存入csv。

经过上述两步，数据的整理工作就做完啦。

可视化微博数据

有了csv文件，做数据可视化是分分钟的事。此时我把工作平台从PyCharm搬到了Jupyter Notebook。这是因为Jupyter Notebook可以制作的各式各样的可视化图表和窗口小工具(widget), 比PyCharm更适合数据处理。至于工具包，这里我选的是pandas和seaborn.

首先是需求分析，我的目标如下:

绘制日期分布热力图，观察今年使用微博频率的趋势
绘制设备使用直方图，看看平时最常用什么平台发博
绘制时间分布直方图，观察一天之中各时段的发博频率
使用窗口滑块小部件，拖动查看各个时间段都发了什么内容

这里不描述具体过程，详见GitHub Repository.

分析结果如下:

热力图总体来说颜色逐年加深，说明我正在逐渐成为一个微博控。而且注意到往年年初我是不怎么玩微博的，但随着年纪渐长，1-3月份我玩微博的频率越来越高，这意味着过年可能越来越无聊，没有年味，从而加长了我混迹微博的时间。

是你吗？华为的舔狗~

晚上2点不睡的坏小孩，早上10点起的偷懒者。（此处是一个卑微的笑容）

附录：部分代码

下面这段代码分割了文本。

    def classification(self, txt_array, file_index):
        id = np.array([])
        date = np.array([])
        time = np.array([])
        device = np.array([])
        content = np.array([])

        count = 0
        for ite in range(1, np.size(txt_array), 1):
            if txt_array[ite].find("\n"+"YOUR_NAME") != -1:
                cur_sentence = txt_array[ite][txt_array[ite].rfind("\n"+"YOUR_NAME") + len("\n"+"YOUR_NAME")+1:txt_array[ite].find("\u200b")]
                count += 1
                id = np.append(id, str(file_index) + '.' + str(count))
                device = np.append(device, cur_sentence[cur_sentence.find("come from") + 10:].split("\n")[0])
                content = np.append(content, str(cur_sentence[cur_sentence.find("\n") + 1:]))
                if cur_sentence != '':
                    start = cur_sentence[0:11].rfind("-")
                    end = cur_sentence[0:16].rfind(":")
                    date = np.append(date, cur_sentence[0:start+3])
                    time = np.append(time, cur_sentence[end-2:end+3])
                else:
                    date = np.append(date, '')
                    time = np.append(time, '')


        flag = 0
        if count != len(time):
            print("Error: time and sentence do not have same size in file {}".format(str(file_index)))
            flag = 1
        if count != len(device):
            print("Error: device and sentence do not have same size in file {}".format(str(file_index)))
            flag = 1
        if count != len(content):
            print("Error: content and sentence do not have same size in file {}".format(str(file_index)))
            flag = 1

        if flag == 1:
            id = np.array([])
            date = np.array([])
            time = np.array([])
            device = np.array([])
            content = np.array([])

        return id, date, time, device, content

下面这段代码绘制了热力图。

【项目】TSP旅行路线规划

Wed, 10 Apr 2019 00:00:00 +0000

GitHub 项目地址：tsp-route

对于在欧洲的小伙伴们，复活节假在这一周就正式开始啦。大家都是怎么计划旅行的呢？

我的习惯是在出发前最后一晚，花上半小时，搜索目的地景点 (Point of interest, POI), 然后在Google Maps上为它们点上小星星，以免和它们擦肩而过。我的地图经过一番操作，就成了下面这副模样。

此时此刻，望着这些密集的星星，我不禁自问：如何才能走最少的路，遍历所有景点呢?

搜索了谷歌和百度，都没找到我要路径规划功能。最接近需求的是谷歌地图的"Add destination"功能。然而这个功能只是依次连接你点选的地点。并不能由一组地点，确定连接它们的一条全局最短路径。

没有现成应用怎么办，我打算自己动手写一个。

下图是Google Add destination功能。

适用模型：TSP 模型

用一句话概括需求就是：我们需要一条从某地方出发，遍历所有地点，最终回到起点的最短路径。

这个需求其实就是运筹学的一个经典问题，旅行商问题(TSP)。旅行商问题的确切描述是这样的：一个商人在各个城市之间旅行，要求遍历所有城市并返回到出发点，要如何规划路线，才能使总路径最短。（打开维基百科了解更多)

解决思路

用googlemaps包获取纬度和经度信息
用OR-Tools包求解TSP问题
最后用gmaps可视化结果

在敲代码的过程中，最难的地方莫过于看文档查API, 搞清楚输入输出和调用结构。不过敲完这一顿之后我还是不禁感慨，Google 太为开发者着想了。一旦学会调用API，实现一个简单应用的代码量还是很小的 orz

食用指南

项目地址 –> 传送门

在运行代码之前，你需要以下配置：

一个Jupyter Notebook.
你需要安装这些包：googleplaces, googlemaps, gmaps, ortools.
你需要一个Google Maps API key, 从这里获取API.

完成配置等于成功的一半。在Jupyter notebook打开TSPSolver.ipynb，将第二个代码块的所有变量，改成自己的，比如自己的目的地自己的区域和自己的API密码……最后从头到尾运行所有代码块，你就可以得到自己的定制路线辣~

配置代码如下。

# input the places of interest (POI)
places = 'YHA London Central Hostel', 'Coca-Cola London Eye', 'St. Paul\'s Cathedral', 'Leadenhall Market', 'The National Gallery' \
          'Big Ben', 'Buckingham Palace', 'Waterloo Station'

# the region
Location='London'

# choose a mode
Mode = "walking"  # "driving", "walking", "bicycling", "transit"

# get Google API key from following website: 
# https://developers.google.com/maps/documentation/distance-matrix/start#get-a-key
password = "YOUR_GOOGLE_API_KEY_HERE"

欢迎Star, Pull, Pr.

Python 解置换群问题

Sat, 16 Mar 2019 00:00:00 +0000

室友问我一个问题，把我难住了。

想不出解法，遂写了个程序暴力求解。

**题目：**A permutation is applied to the string SUPERBGOLDHAT. The same permutation is applied to the output from this operation. The second output is OGTHLEPDSUARB. What was the first output? (Note: as an example, the permutation(1 3 4) applied to WOLF gives FOWL. Write your answer in capital letters inside quotation marks, e.g. “BEARDPLUGHOST”.)

把它译成中文就是：已知将某个置换作用于字符串SUPERBGOLDHAT两次，生成字符串OGTHLEPDSUARB. 求该置换作用于字符串SUPERBGOLDHAT一次时，生成的结果。

Note: 作用两次的意思就是，当一个置换规则作用于字符串一次时，会生成一个新字符串。将这个规则作用在这个新字符串上，又会生成一个字符串，这个字符串就是两次作用的结果。

近世代数基础

如果你不知道什么是置换的话，可以看一下本节。学过近世代数的同学请自觉跳过这部分ꉂ(ˊᗜˋ*)

我们给定一个序列$a ={1, 2, 3, 4, 5, 6} $ 。然后给定一个作用于该序列的置换：

厨房笔记（一）：牛刀小试

Mon, 06 Aug 2018 00:00:00 +0000

刚到英国那会儿，做饭的兴致很高。每天都跟过家家似的，买菜，钻研菜谱，然后做饭，在厨房里待上四五个小时也不觉得累。大概这就是“人生若只如初见”吧。

拌牛肉

原料：牛肉3两，猪油，葱，酱油，地瓜粉1匙半，盐

做法：

牛肉顺纹路切成宽约一寸的肉条，肉条逆纹路切片，装碗，用自来水清洗，沥干，加入一匙猪油和适量的盐与酱油，用手抓揉片刻后，加入一匙半的地瓜粉，继续抓握揉捏约3分钟即可，葱切好备用；
五匙猪油下锅，至微热，放入适量葱头和小半葱段，煎至略有香味溢出，起锅备用；
水烧沸，调至小火，牛肉下锅，先不要搅动，待地瓜粉固结后，可用筷子将牛肉摊开，当水再次沸腾时，用漏勺将肉舀出，趁热放入煎好的猪油中搅拌，菜即成。

亲子丼

原料：米饭，鸡肉，洋葱，鸡蛋，酱油，盐，糖，料酒

做法：

米饭下锅煮，可弃之不顾。
鸡肉切小块，放酱油、盐、料酒腌一下；洋葱切短条；鸡蛋稍稍打散。
鸡肉下锅煎至出油，起锅。此时锅不必洗，放半碗水，加酱油、少量料酒和糖。
待水烧开，放入鸡肉和洋葱。盖锅盖将鸡肉焖熟，然后倒入一半蛋液，盖锅盖小火焖3分钟。
起锅盖，倒入剩下一半蛋液。菜即成。

红烧肉

原料：五花肉，葱，姜，蒜，大料，老抽，生抽，糖，油

做法：

五花肉切块，葱切段，蒜切末，姜切条。
倒油，加葱头、姜条、蒜末、大料，小火熬油。油熬出香味后，放五花肉翻炒，闻香即可起锅。
另起一锅油，倒六七小勺糖，中火将糖煮化。倒入五花肉，翻炒片刻后，加少量水、老抽、生抽。
时不时搅拌，尝肉汁甜度，不够可加糖。待锅内汤汁收浓稠，起锅享用。

牛肉丸意大利面

原料：意面、牛肉丸、葱、蒜、番茄、番茄酱

做法：

烧一壶开水，倒入电饭锅，加两勺盐，放入螺旋意大利面。面煮不烂，可以弃之不顾。
切葱头，剁蒜泥，番茄切小块备用。
烧一锅油，放入丸子，翻面煎至定型。
起锅后油不倒，加入蒜泥葱头炒香。番茄块倒入锅中炒软，然后加大量番茄酱，继续翻炒，以防番茄酱烧焦。
捞面放入锅中和酱汁搅和搅和，放入丸子，起锅开吃。

葱油鸡

原料：大鸡腿、葱、姜、蒜、料酒

做法：

鸡肉处理干净后，用盐给它来个大宝剑。盘中先放葱结、姜片、鸡肉，次淋白葡萄酒。
鸡肉盛于盘内，冷水入锅，小火蒸20分钟。
此时切葱末、蒜泥、姜泥备用。
起油锅，小火炸葱头，出香味后放入葱末、蒜泥、姜泥，煸炒出香味。待肉出锅后，可拿干净的刀切片，再浇葱油。亦可不切，大口嚼之可也。

芋头的鸡丝凉面！

原教程链接：https://www.bilibili.com/video/av28407533

原料：鸡胸肉、黄瓜、意大利面、花生酱、松子、生抽、醋、料酒、辣椒、蒜头、橄榄油

做法：

电饭锅加水放面，加盐巴煮。
鸡胸肉处理干净，将肉肉锤松。开水放肉，加八角、葱段、姜片、料酒。再次煮沸后关火，焖十分钟。
意面起锅，放凉水里泡一哈，滤出面条，加橄榄油拌一拌，放在一边就好啦！
黄瓜去皮切条，葱切成细细的小圈，菜码就做好啦！
花生酱加两份生抽一份醋，调成酸奶一样的质感，凉面汁就做好啦！
蒜切末，松子装进保鲜袋用书脊砸碎。碗内放辣椒、松子碎末、蒜末。烧一锅油，倒入碗中搅合搅合，油泼辣子（伪）就做好啦！
拿个盘中，放面，放菜码，放葱花，放凉面汁，放油泼辣子。鸡丝凉面就做好啦~

注：根据个人口味适当调整了生抽和醋的比例，凉面汁的稠度以及简化了蒜汁的制作（直接把蒜末加到油泼辣子中）另本人冰箱里没有鸡胸肉，所以本次图片中的成品是牛肉丝凉面，事实证明牛肉丝并不适合做凉面，别问我怎么知道的（皮）

【项目】基于蚁群算法的证券投资组合优化

Tue, 15 May 2018 00:00:00 +0000

在证券交易中，为了降低风险，经常使用一笔资金购买多支股票。那么，如何合理地选择证券组合，并确定每支证券的资金分配系数，以使预期风险最低，预期收益最高，就成了一个经典的经济学问题 – 证券投资组合优化问题。

1952年，马科维茨首次提出均值-方差模型(Markowitz Mean-Variance Model)。该模型利用股票的历史交易数据，定义了股票的预期风险与收益，并引入“无差异曲线”和“有效市场边界”的概念，最终导出了最佳投资组合的计算公式。

本文利用蚁群算法，求解马科维茨均值-方差模型。蚁群算法是一个群体智能算法，因其较强的鲁棒性和适用性，被广泛应用于工业界，是一种研究较为成熟的算法。

研究背景

一个证券投资组合，简单来说就是一组证券及其选购系数的组合。选购系数均大于零（不允许做空），且和为1。

余超在**《基于蚁群算法的投资组合优化研究》**中给出了完整的模型假设。概括如下：

一只蚂蚁代表了一个投资组合；
在投资组合优化问题中的蚁群算法要采用连续域优化；
相较于传统蚁群问题，该算法中信息素应该在城市而非路径上积累；
可在蚂蚁移动过程中加入随机扰动以增加全局搜索能力。

余超在模型基础上已经做了非常完整的工作，但是没能求出完整的有效市场边界。

于是，卞蓓丽在**《蚁群算法在多目标优化的证券投资组合中的应用研究》**中指出，多目标优化的证券投资组合问题是没有绝对最优解的，而是有一群无法相互支配的解形成的有效边界。对多目标优化问题而言，最重要的是求出有效边界，而不仅仅是求出一两个更优解，后者用单目标就可以完成。余超的多目标研究没有求出有效边界。”

卞蓓丽提示我们：因为，投资组合问题，本质上是一个多目标优化问题。所以，我们要计算出完整的有效边界曲线，才算达成预期目标。

余超建立了基础模型，而卞蓓丽在余超的基础上进行了改进。本文借鉴他们二人建立的数学模型，利用多元函数连续域蚁群算法，求解马科维茨均值-方差模型。

研究方法

（一）马科维茨投资组合理论简介

投资组合的预期收益( $𝒓_𝒑$ )：单一证券i的预期收益为 $E\left(r_{i}\right) $ ，式中 $r_{i s}$ 为针对状况s证券i的收益率， $P_{s}$ 是状态s出现的概率；在计算了所有N个证券的预期收益率后，就可以计算出证券组合的预期收益率 $𝒓_𝒑$ ，式中 $x_{i}$ 表示组合中证券i所占的比例，即加权系数。

单一证券i的预期收益: $E\left(r_{i}\right)=\sum_{s=1}^{n} r_{i s} * P_{s}$
证券组合的预期收益: $\overline{r_{p}}=\sum_{i=1}^{N} x_{i} * E\left(r_{i}\right)$

投资组合的预期风险($𝝈_{𝒑}$)：单一证券i的预期风险为 $\sigma_{\mathrm{i}} $ ，式中 $r_{i s}$ 为针对状况s证券i的收益率， $P_{S}$ 是状态s出现的概率， $E\left(r_{i}\right) $ 为证券i的预期收益率；在计算了所有N个证券的预期风险后，就可以计算出证券组合的预期风险 $\sigma_{\mathrm{p}}$ ，式中 $\operatorname{cov}_{i j}$ 表示证券i和证券j的协方差， $x_{i}$ 和 $x_{j}$ 表示组合中证券i和证券j所占的比例，即加权系数。

单一证券i的预期风险: $\sigma_{\mathrm{i}}=\left(\sum_{s=1}^{n}\left[r_{i s}-E\left(r_{i}\right)\right]^{2} * P_{S}\right)^{\frac{1}{2}}$
证券组合的预期风险: $\sigma_{\mathrm{p}}=\left(\sum_{i=1}^{N} \sum_{j=1}^{N} \operatorname{cov}_{i j} * x_{i} * x_{j}\right)^{\frac{1}{2}}$

有效市场边界: 有效市场边界是所有最佳投资组合(Efficient Portfolio)的集合。有效前沿曲线上面的每一点都代表一个最佳投资组合。下图曲线就是有效市场边界，有效市场边界满足以下两个条件：

对每一水平的风险，该组合提供最大的预期收益；
对每一水平的预期收益，该组合能提供最小的风险。

（二）蚁群算法在马科维茨模型中的应用

具体到蚁群算法中，一只蚂蚁代表一个投资组合 $𝑃=\{𝑥_1,𝑥_2,⋯,𝑥_𝑛\}$ 。通过马科维茨理论，我们可以计算出该投资组合P对应的均值和方差。将均值、方差绘制在r-σ二维空间上，可以观察各个投资组合之间的帕累托关系，可分为三种情况：明显优于、明显劣于、和无法比较优劣。

最终我们求出的有效市场边界上的近似点，就是由这样一组无法比较优劣的点组成的，我们把它叫作一组无法相互支配的最优解。

研究模型

（一）模型假设

观影：少女哪吒

Tue, 11 Jul 2017 00:00:00 +0000

青春可贵，文学高华，可是越是珍贵就越脆弱越易碎。对于一般人来说，破碎的疼痛也许还能承受得住，可是对内心敏感的人，这几乎是欲死的折磨。

我发现，影片中很多人都沉浸于某种爱好。王晓冰喜欢文学和音乐，晓冰妈喜欢舞蹈，晓冰爸外面的女人喜欢钢琴。但他们的爱好不是为了艺术，他们只是借沉浸艺术来麻痹自己。

我猜，王晓冰对家人大喊“虚伪”的原因，大概就是看不惯家人的这种自我麻痹吧？看不惯这种因为怯懦、无法承受就转向麻痹自我的态度。她不满拿音乐和舞蹈麻痹自己的母亲，不满借口“恋爱自由”为自己脱责的父亲。

每个人都为着生活痛苦、狂燥、疲惫不堪，在生活的折磨下渐渐失去勇气。因为不忍正视生活之残酷，他们选择戴上虚伪的面具，假装做出幸福的样子。但晓冰不，她个性干爽利落，追求三毛式的真诚和坦率。就算现实让她疼痛到龇牙咧嘴，她也要把那撇开的嘴角当作笑容。

影片里李小路就像一个完美的存在，她的出现对晓冰而言是上苍的馈赠。就像徐杰说小路是侠女，小路确有一股特殊的气质。英气里带点活泼，让人倍感亲切。有时紧锁的眉头和尖利的眼神又不时提醒着她已是一个有了主见的少女。是小路，让晓冰的生活里有了短暂的纯粹的欢乐。

造成晓冰痛苦的原因是多方位的，家庭的破碎，平庸又手握权力的老师的刁难，爱情的不如意，学业的不顺遂等等。对于这一切，晓冰都毅然决然、不顾后果、绝不妥协地抗争。永远高昂着头，又不幸身为下贱，这场景让我想起妙玉。

总体上讲，电影的场景感觉很碎，只给人提供一种感觉。影片没有悲壮的结局，因此对应地也缺少回响。因为没有回响，因此又显得生涩。也不知道这生涩是好是坏，虽说失掉了反复品咂的回味，但又给思考和体验留了更多空间。

（看的电影很少，还是第一次看这么文艺的电影，写一点个人的感觉 Σ Σ Σ (|||▽||| )

基于蚁群算法的证券投资组合优化

Sat, 01 Jun 2019 00:00:00 +0000

在证券交易中，为了降低风险，经常使用一笔资金购买多支股票。那么，如何合理地选择证券组合，并确定每支证券的资金分配系数，以使预期风险最低，预期收益最高，就成了一种经典的金融问题 – 证券投资组合优化问题。

马科维茨均值-方差模型(Markowitz Mean-Variance Model)是一种用于求解证券投资组合优化问题的数学模型。本文改进了一种多元函数连续域蚁群算法，用于求解马科维茨均值-方差模型。

TSP旅行路线规划

Wed, 01 May 2019 00:00:00 +0000

旅行中的一天通常这样度过：清晨从宾馆出发，去第一个景点。第一个景点逛完，去下一个景点……直到最后一个景点逛完，行程结束返回宾馆。那么如何规划一条最短的路线走完一天的行程呢？这就涉及到一个经典的运筹学问题 – TSP问题。本项目用googlemaps库获取纬度和经度信息，用OR-Tools库求解TSP问题，用gmaps库可视化输出结果。利用本项目，用户只需输入景点名称，即可获得一张周游所有景点的最短路线图。可以说是一个即插即用的TSP路线规划工具。

团队软件项目

Mon, 01 Apr 2019 00:00:00 +0000

每年，教学经理(Learning and Teaching Manager)都必须从老师那里收集课程信息。如果发现考试时间重叠或者太过密集，教学经理都必须通知老师调整时间。此外，教学经理还必须核对课程信息是否正确。比如各项考核分数之和是否为100分，考试时间是否与节假日重叠，作业的截至日期是否在发布日期之后等。核对完成后，还必须将每个课程的信息打印出来。这个过程非常手动，对用户也不友好。因此，团队编写了本软件。本软件能自动核对、打印、可视化课程信息，并允许用户将课程信息以邮件形式返回给教学经理，以帮助课程经理提高工作效率。

自然系统的建模与仿真

Fri, 01 Mar 2019 00:00:00 +0000

本项目采用 Agent-based model 的方式，为狼-麋鹿-草生态系统建模。技术上采用了 MATLAB 面向对象编程，为狼和麋鹿的四种行为，分别是捕食、迁徙、生育、死亡，编写了规则。其中狼群拥有智能，可以利用有限信息搜索羊群，并且在头狼的带领下，狼群还表现出集群行为。给定初始条件以后，本模型会模拟生态系统的运作，输出一个时刻更新的二维图以展示各生物位置的变化情况。此外，还会输出一个折线图以表示各生物数量的变化情况。

Mon, 01 Jan 0001 00:00:00 +0000

算法集萃

1. 分配货物

有四条船，有一堆货物。往每条船上分配货物，要求每条船上货物的重量相等。列表中的元素表示每个货物的重量。返回 Ture 或者 False 表示是否存在满足条件的装货方式。

示例：

输入: [2,2,2,1,1]
输出: True

输入: [2,2,2,3]
输出: False

解答：

None

2. 复原IP地址[LeetCode]

给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。

示例：

输入: "25525511135"
输出: ["255.255.11.135", "255.255.111.35"]

解答：

None

Mon, 01 Jan 0001 00:00:00 +0000

[1706.03762] Attention Is All You Need

Provided proper attribution is provided, Google hereby grants permission to reproduce the tables and figures in this paper solely for use in journalistic or scholarly works.

Mon, 01 Jan 0001 00:00:00 +0000

百家号模拟器

主题：

属性：

Mon, 01 Jan 0001 00:00:00 +0000

Collective Motion

Speed Wiggle Collision Radius Alignment Radius Attraction Radius Blind Spot

Mon, 01 Jan 0001 00:00:00 +0000

Don't threaten me with a good time ♪

Mon, 01 Jan 0001 00:00:00 +0000

┗|｀O′|┛

Happy Birthday
To
赵公公

Mon, 01 Jan 0001 00:00:00 +0000

年龄可视化

A 90-Year Human Life in Months

Your Age:

Inspired by Your Life in Weeks.

Mon, 01 Jan 0001 00:00:00 +0000

Hydra hydra

Mon, 01 Jan 0001 00:00:00 +0000

Live2D！

隐藏

Mon, 01 Jan 0001 00:00:00 +0000

Monaco Speech Editor

Mon, 01 Jan 0001 00:00:00 +0000

墨子 | 读书笔记

墨子

原文及读书笔记

介绍

作者 : 墨翟
成书时间 : [春秋 - 战国] 公元前490年-公元前221年
篇目数量 : 原有71篇，现存53篇

墨家主张“兼爱”，和西方的“博爱”相似；墨家重视技术，这也与西方不谋而合。在诸子百家中，墨家可能是最接近西方文明的学派。因此，当近代中国在西方的坚船利炮下生灵涂炭之时，中国的学者们不由开始缅怀墨子。倘若当年汉武帝不尊儒而尊墨，或许就能引领中华文明走上一条科技之路，从而免于两千多年后落得一个被列强欺凌的下场。这当然是臆想，但这却让墨家在近代意外走红，引起了关注。

Mon, 01 Jan 0001 00:00:00 +0000

Document

Mon, 01 Jan 0001 00:00:00 +0000

JS Piano

Use your keyboard. Hover for hints.

;

Mon, 01 Jan 0001 00:00:00 +0000

Plan

2020年2月计划

一、计划内容

学习计划 📖

LeetCode (1 题/天)
读书 (10 页/天)

运动计划 🏃

跑步 (1000 米/天)
仰卧起坐 (10 次/天)

注：括号内是计量单位，不是计划数。

Mon, 01 Jan 0001 00:00:00 +0000

现在几点了？

Mon, 01 Jan 0001 00:00:00 +0000

React App

Mon, 01 Jan 0001 00:00:00 +0000

计划表生成工具

Mon, 01 Jan 0001 00:00:00 +0000

Read a zip file demo

zip.js

A JavaScript library to zip and unzip files

Read a zip file demo

choose a zip file
choose temporary storage
download zip content

Mon, 01 Jan 0001 00:00:00 +0000

3D场景建模

用OpenGL搭建3D室内场景模型

效果展示

Mon, 01 Jan 0001 00:00:00 +0000

机器学习

用主成分分析法实现MNIST数据集下的图像分类

GitHub

Mon, 01 Jan 0001 00:00:00 +0000

基于蚁群算法的证券投资组合优化

基于蚁群算法的证券投资组合优化问题研究

北京邮电大学本科毕业论文
指导老师：赵新超
作者：罗畅

Mon, 01 Jan 0001 00:00:00 +0000

Monaco Speech Editor

适用于视障人群的在线代码编辑器

博客全文

Demo

Mon, 01 Jan 0001 00:00:00 +0000

微博数据可视化

基于Pandas和seaborn实现的新浪微博数据可视化

博客全文

GitHub

Mon, 01 Jan 0001 00:00:00 +0000

自然系统的建模与仿真

用MATLAB面向对象编程建立了狼、麋鹿、草生态系统模型

博客全文

GitHub

Mon, 01 Jan 0001 00:00:00 +0000

团队软件项目

基于PyQt5编写的课程管理软件

项目报告

项目PPT

Mon, 01 Jan 0001 00:00:00 +0000

TSP旅行路线规划

用 Google Map Api 在谷歌地图上绘制TSP旅行路线

博客全文

GitHub

Chang Luo

智能的本质是对抗不确定

在树莓派上搭建家用 Agent 服务

一、制作 TF 卡

1）下载

2）将镜像写入 TF 卡

二、首次启动 Ubuntu

三、环境配置

1）更新软件包

2）安装 pipx 和 uv

RAG：大模型时代的搜索基座

一、提示词模板

二、向量检索

1）从文本向量化说起

2）向量检索的原理

《LangGraph 1.0 完全指南》发布

一、在线资源

二、章节介绍

三、拓展阅读

使用 Docker Compose 部署大数据集群：Spark + Hadoop + Hive + JupyterLab

引子

一、集群功能

阿里发布新版 Quick BI，聊聊 ChatBI 的底层架构、交互设计和云计算生态

一、智能小Q能做什么？

1）问数界面

2）解读界面

二、拆解 Quick BI 技术路径

耶是 ClickHouse！我们有救了！！

一、分析利器

二、安装过程

1. 配置 Docker 镜像源

新瓶装旧酒：纸牌魔术 MCP

Chico & Dico 的魔术

数学原理

Agent 实战：智能路由、任务拆解和链路工程

一、引言

1. 尚未到来的涌现

AUV～ 演出现场

三种方法实现监督微调：LLaMA Factory, trl 和 unsloth

一、引言

1. SFT 的简单介绍

2. SFT 的使用场景

DNN 模型聚类特征更新方法

一、引子：频繁变更索引的代价

本地部署大模型：Ollama 和 vLLM

一、本地部署 DeepSeek R1

Langflow 实现本地知识库

一、RAG 的概念介绍

二、简单的 RAG 应用

三、带对话记忆功能的 RAG

深度嵌入聚类算法 DEC

搭建一款简单的『以文搜图』应用

一、加载 CLIP 模型

二、Faiss 向量搜索

三、CLIP 向量生成

流式聚类算法：DenStream 和 CluStream

一、DBSCAN

二、DenStream

三、CluStream

Triton 部署 CLIP 图文 Embedding 推理服务

Docker 命令速查手册

一、什么是 Docker

1.1 核心组件

1.2 主要用途

二、常用命令

2.1 基础操作

2.2 镜像管理

2.3 容器管理

2.4 容器运行

三、Docker 的简单使用

频繁模式挖掘

一、频繁项集算法：FPGrowth

二、频繁序列算法：PrefixSpan

初见向量引擎：RediSearch 和 Milvus

一、安装 Redis

二、用 Redis 存取 Embedding

三、RediSearch 模块

四、开源向量引擎 Milvus

三种图神经网络算法：GraphSAGE, GCN 和 GAT

一、GraphSAGE 的简单实现

AUV～演出现场

2）光猫接路由器

3）路由器接交换机