Posts on

随机积分小记：几个概念之间的关系

Tue, 31 Mar 2026 00:00:00 +0000

前言

本文的目标是理清SDE（随机微分方程）、generator（生成元）和 Fokker-Planck 方程之间的关系，并说明 generator 或许才是最本质的对象，而 SDE 只是 generator 的一种具体实现方式。

基本对象：Markov 过程和 Semigroup

考虑 Markov 过程 $X_t$，定义：

$$P_t f(x) = E[f(X_t) \mid X_0 = x]$$

即：给定初值 $x$，函数 $f$ 在随机演化时间 $t$ 后的期望值。

考察性质：

$P_0$ 为恒等算子：

$$P_0 f(x) = E[f(X_0) \mid X_0 = x] = f(x)$$

算子的组合性：

$$ \begin{align} P_{t+s} f(x) &= E[f(X_{t+s}) \mid X_0 = x]\\ &= E[E[f(X_{t+s}) \mid X_t] \mid X_0 = x]\\ &= E[P_s f(X_t) \mid X_0 = x]\\ &= P_t(P_s f)(x) \end{align} $$

因此，算子族 $\{P_t\}_{t\ge 0}$ 对于算子复合（composition）构成半群。
而 Markov 过程的无记忆性保证了算子的组合结构。

Generator：Semigroup 的微分

自然地，定义 generator 为参数化的算子 $P_t$ 在 $t=0$ 处对时间参数 $t$ 的导数：

$$\mathcal{L}f(x) = \lim_{t\to0} \frac{P_t f(x)-f(x)}{t}$$

其描述了函数在随机演化下的瞬时变化率。
换言之，若函数 $f$ 沿着随机过程漂移，generator 告诉我们它的期望值以多快的速度变化。至此，仍不需要 SDE。只要有 Markov 过程，就自动具有 generator。

SDE：Generator 的一种实现

现在引入 SDE。考虑一个由以下随机微分方程驱动的过程：

$$dX_t = a(X_t)dt + b(X_t)dW_t$$

其中 $a(x)$ 是漂移系数，$b(x)$ 是扩散系数，$W_t$ 是标准 Brownian 运动。

利用 Itô 引理，可以证明这个 SDE 对应的 generator 具有特殊形式：

$$\mathcal{L}f(x) = a(x)f'(x) + \frac{1}{2}b^2(x)f''(x)$$

证明：对于光滑函数 $f$，应用 Itô 引理：

$$df(X_t) = f'(X_t)dX_t + \frac{1}{2}f''(X_t)(dX_t)^2$$

将 $dX_t = a(X_t)dt + b(X_t)dW_t$ 代入。注意二次变分规则：

$(dt)^2 = 0,\ dt \cdot dW_t = 0,\ (dW_t)^2 = dt$

于是：

$$(dX_t)^2 = [a(X_t)dt + b(X_t)dW_t]^2 = b^2(X_t)dt$$ $$ \begin{aligned} df(X_t) &= f'(X_t)[a(X_t)dt + b(X_t)dW_t] + \frac{1}{2}f''(X_t)b^2(X_t)dt\\ &= \left[a(X_t)f'(X_t) + \frac{1}{2}b^2(X_t)f''(X_t)\right]dt + f'(X_t)b(X_t)dW_t \end{aligned} $$

对两边求期望，由于 $dW_t$ 项的期望为零：

$$E[df(X_t) \mid X_0 = x] = E\left[\left[a(X_t)f'(X_t) + \frac{1}{2}b^2(X_t)f''(X_t)\right]dt \mid X_0 = x\right]$$

在微小时间 $dt$ 内，$X_t$ 接近初值 $x$，所以：

$$E[f(X_{t+dt}) - f(X_t) \mid X_0 = x] \approx \left[a(x)f'(x) + \frac{1}{2}b^2(x)f''(x)\right]dt$$ $$\lim_{dt \to 0} \frac{E[f(X_{dt}) \mid X_0 = x] - f(x)}{dt} = a(x)f'(x) + \frac{1}{2}b^2(x)f''(x)$$

根据 generator 的定义 $\mathcal{L}f(x) = \lim_{t \to 0} \frac{P_tf(x) - f(x)}{t}$，我们得到：

$$\mathcal{L}f(x) = a(x)f'(x) + \frac{1}{2}b^2(x)f''(x)$$

这表明 SDE 的 generator 形式是由 Itô 引理唯一确定的。

这是一个重要的反演（inversion）：给定 SDE，我们可以计算出对应的 generator；反过来，给定一个这种特殊形式的 generator，我们可以构造一个相应的 SDE。
理论上，generator 可以不对应任何 SDE——特别是对于跳过程、Lévy 过程或一般的 Markov 过程，它们有 generator 但没有 SDE 表示。

密度的演化：Fokker-Planck 方程

现在考虑随机过程的概率密度 $p(x,t)$ 的演化。这涉及到 generator 的一个重要伴侣，即 对偶算子 $\mathcal{L}^*$。

从 Backward 方程到 Forward 方程

由 generator 定义出发，对任意光滑函数 $f$ 和概率密度 $p(x,t)$，有：

$$\frac{d}{dt}E[f(X_t)] = E[\mathcal{L}f(X_t)]$$

展开期望积分形式：

$$\frac{d}{dt}\int_{\mathbb{R}} f(x)p(x,t)dx = \int_{\mathbb{R}} \mathcal{L}f(x) \cdot p(x,t)dx$$ $$\int_{\mathbb{R}} f(x)\partial_t p(x,t)dx = \int_{\mathbb{R}} \mathcal{L}f(x) \cdot p(x,t)dx$$

对于 $\mathcal{L}f = af' + \frac{1}{2}b^2f''$：

$$\int_{\mathbb{R}} \mathcal{L}f(x) \cdot p(x,t)dx = \int_{\mathbb{R}} \left[af' + \frac{1}{2}b^2f''\right]p dx$$

第一项分部积分（假设边界项消失）：

$$\int_{\mathbb{R}} af' \cdot p \, dx = -\int_{\mathbb{R}} f \cdot \partial_x(ap) dx$$

类似地，第二项分部积分两次后：

$$\int_{\mathbb{R}} \frac{1}{2}b^2f'' \cdot p \, dx = \int_{\mathbb{R}} f \cdot \frac{1}{2}\partial_{xx}(b^2p) dx$$ $$\begin{aligned} \int_{\mathbb{R}} f(x)\partial_t p(x,t)dx &= -\int_{\mathbb{R}} f \cdot \partial_x(ap) dx + \int_{\mathbb{R}} f \cdot \frac{1}{2}\partial_{xx}(b^2p) dx\\ &= \int_{\mathbb{R}} f \left[-\partial_x(ap) + \frac{1}{2}\partial_{xx}(b^2p)\right] dx \end{aligned}$$

由于这对所有 $f$ 成立，必有：

$$\partial_t p = -\partial_x(ap) + \frac{1}{2}\partial_{xx}(b^2p)$$

这就是著名的 Fokker-Planck 方程（也称为 Kolmogorov 前向方程），其描述了概率密度如何随时间演化。

对偶性的意义

注意到：

Backward operator（向后方程的 generator）：$\mathcal{L}f = af' + \frac{1}{2}b^2f''$
Forward operator（向前方程的 generator）：$\mathcal{L}^* p = -\partial_x(ap) + \frac{1}{2}\partial_{xx}(b^2p)$

满足如下对偶性：

$$\int_{\mathbb{R}} \mathcal{L}f \cdot p \, dx = \int_{\mathbb{R}} f \cdot \mathcal{L}^* p \, dx$$

虽然 backward 和 forward 方程表面上不同，但它们是对偶的，描述的是同一个过程的两个互补视角。

三个视角，一个动力学

现在我们可以总结一下：一个随机系统本质上可以从三个不同的角度观察：

路径视角（SDE）：单条轨迹怎样演化，$dX_t = a(X_t)dt + b(X_t)dW_t$
函数视角（Generator）：可测函数的期望怎样变化，$d E[f(X_t)] = E[\mathcal{L}f(X_t)]dt$
密度视角（Fokker-Planck）：概率密度函数怎样演化，$\partial_t p = -\partial_x(ap) + \frac{1}{2}\partial_{xx}(b^2 p)$

这三个方程在本质上描述的是同一个动力学系统。

简而言之概括性来看，更清晰的分层为：

Markov 过程 → 最一般的随机过程，满足 Markov 性质
Semigroup → 由 Markov 过程导出的算子家族 $P_t$
Generator → Semigroup 的微分，是最本质的对象
Backward 方程 → Generator 诱导的 PDE
Forward 方程 → 密度演化的 PDE

只有当 generator 具有特殊的二阶微分形式时，我们才能构造对应的 SDE。很多重要的随机过程（如跳跃过程、稳定过程等）根本没有 SDE 表示，但它们有明确定义的 generator。

the left of us

Wed, 25 Mar 2026 00:00:00 +0000

起因

读到了朋友的文字。

引文

如文字作者之所言，他创建的 SKILL: what’s left for us 的职能不过是盘 TODO。
曰：放大一个尺度，问的是同一件事。

正文

工具循环流内的 PASS: what’s left for us 剥除的是待办的剩余。
原尺度下，剩余成了养料，我（它）自食其果了。

拉远一点。任务通过自动化流程一点点从【我】身上剥离后，【我】还有（剩）什么可做呢，【我】还是什么呢？
又或：我本剩余。

叩问于剩余的剩余，以至于剩余之外。

what's left of
 what's left of
 what's left...

Then, there be something for nothing.
And the left for us can be the left of us.

范畴论小记

Wed, 25 Mar 2026 00:00:00 +0000

起因

答辩完了，好舒服，让 LLM（流浪猫）带我学习。

等等！
友人云：单子不过是自函子范畴上的一个幺半群而已。何意味？

为了解答这个问题，我在流浪猫的带领下重构了段落。

基本概念

所谓幺半群 (Monoid)，即一个集合上定义一个二元运算，存在单位元，并满足结合律。这个和范畴无关。

（不过结合范畴定义可知，一个幺半群本身就可以看作是一个只有一个对象的范畴：态射就是幺半群的元素，态射的复合就是二元运算）

下面解释范畴的概念

一个范畴 (Category) $\mathcal{C}$ 由以下三个要素组成：

对象 (Objects)：$A, B, C$
态射 (Morphisms)：$f: A \to B$
组合律 (Composition)：考虑态射 $f: A \to B,\ g: B \to C$，必存在一个合态射 $g \circ f: A \to C$

另需满足：

结合律：对于 $h \circ (g \circ f) = (h \circ g) \circ f$
单位律：每个对象 $A$ 都存在一个态射 $id_A: A\to A$，使得 $\forall f, f\circ id_A = f = id_A \circ f$

题外话：同构是特殊的态射。

若对态射 $f: A \to B$ 存在态射 $g: B \to A$，s.t. $g \circ f = id_A$ 且 $f \circ g = id_B$
那么称：通过态射 $f$，$A$ 与 $B$ 是同构的。

一点例子：

集合范畴，集合为对象，集合间的映射为态射
- 双射且互为逆映射，那么两个集合在这个范畴意义下是同构的。
群范畴，群为对象，群同态为态射
- 群同构对应的对象是同构的。
偏序集范畴，自然数为对象，若 $n \le m$，构造 $n$ 到 $m$ 到一个态射。
- 同构对象只可能是同一个自然数。

接下来在范畴之间定义函子 (Functor)：$F: \mathcal{C} \to \mathcal{D}$

把 $\mathcal{C}$ 里的每个对象 $A$ 变成 $\mathcal{D}$ 里的对象 $F(A)$。
把 $\mathcal{C}$ 里的每个态射 $f: A \to B$ 变成 $\mathcal{D}$ 里的态射 $F(f): F(A) \to F(B)$。

注：函子本身也必须保持结合律和单位元性质。

例如，考虑一个从 Grp (群范畴) 到 Set (集合范畴) 的函子 $U$（遗忘函子 Forgetful Functor）：对给定群，得到群所在的集合。

自函子为映射到一个范畴自身的函子。自函子范畴 $[\mathcal{C}, \mathcal{C}]$ 的对象是所有的自函子，态射是这些函子之间的自然变换 (Natural Transformation)。

对于 $\mathcal{C}$ 中的每一个对象 $X$，在 $\mathcal{D}$ 中都对应一个态射（箭头）：

$$\alpha_X: F(X) \to G(X)$$

这个箭头被称为自然变换 $\alpha$ 在 $X$ 处的分量。

需满足自然性条件 (Naturality Condition)：如果在 $\mathcal{C}$ 中有一个态射 $f: X \to Y$，那么在 $\mathcal{D}$ 中，以下两条路径的结果必须完全相同：
A：先通过 $\alpha_X$ 从 $F(X)$ 变到 $G(X)$，再通过 $G(f)$ 变到 $G(Y)$
B：先通过 $F(f)$ 从 $F(X)$ 变到 $F(Y)$，再通过 $\alpha_Y$ 变到 $G(Y)$。

即：

$$\begin{CD} F(X) @>\alpha_X>> G(X) \\ @VF(f)VV @VVG(f)V \\ F(Y) @>>\alpha_Y> G(Y) \end{CD}$$

即：$G(f) \circ \alpha_X = \alpha_Y \circ F(f)$。

回到开篇那句话，函子复合就是这个范畴里的乘法运算。自函子范畴 $[\mathcal{C}, \mathcal{C}]$ 上的对象是自函子，“乘法"就是函子的复合 $\circ$：于是单子就是这个范畴上的幺半群。

单子 (Monad) 的组成：

一个自函子 $T: \mathcal{C} \to \mathcal{C}$
单位自然变换 $\eta: Id \to T$（对应幺半群的单位元）
乘法自然变换 $\mu: T^2 \to T$（对应幺半群的二元运算，这里 $T^2 = T \circ T$）

由此：

约定左复合 $T\mu$。其分量为：$(T\mu)_X = T(\mu_X)$。
约定右复合 $\mu T$。其分量为：$(\mu T)_X = \mu_{T(X)}$。
对于 $\eta$，有类似的约定。

这里视角比较巧妙，需要进一步的解释。

具体而言，自然变换 $\mu: T^2 \Rightarrow T$ 为底层范畴 $\mathcal{C}$ 中的对象 $X$ 指派了一个底层的态射 $\mu_X$。所以 $\mu_X$ 是底层范畴 $\mathcal{C}$ 里的一个普通态射。由于 $T$ 是一个函子，且 $\mu_X$ 是 $\mathcal{C}$ 中的一个态射，那么根据函子的性质，$T$ 能把这个态射映射成另一个态射，而这个新态射就是左复合的 $X$ 分量。
自然变换 $\mu: T^2 \Rightarrow T$ 为底层范畴 $\mathcal{C}$ 中的任何对象指派一个态射。考虑右复合 $\mu T$ 在对象 $X$ 处的分量时，我们首先应用自函子 $T$ 于对象 $X$，得到底层范畴 $\mathcal{C}$ 中的一个新对象 $T(X)$。由于 $\mu$ 是一个自然变换，它为这个新对象 $T(X)$ 指派一个对应的底层态射。根据 $\mu$ 的定义，这个指派给对象 $T(X)$ 的态射就是 $\mu_{T(X)}$。这个态射的类型是从 $T^2(T(X))$ 指向 $T(T(X))$，即从 $T^3(X)$ 指向 $T^2(X)$。这个由 $X$ 诱导出的新态射 $\mu_{T(X)}$，就是右复合的 $X$ 分量。

在定义了左右复合后，给出单子需要满足的交换条件：

结合律：

$$\begin{CD} T^3 @>T\mu>> T^2 \\ @V\mu TVV @VV\mu V \\ T^2 @>>\mu> T \end{CD}$$

即 $\mu \circ T\mu = \mu \circ \mu T$。

单位律（左箭头渲染有问题故如此别扭表示）：

$$\begin{CD} T @>\eta T>> T^2 \\ @| @VV\mu V \\ T @= T \end{CD} \qquad \begin{CD} T @>T\eta>> T^2 \\ @| @VV\mu V \\ T @= T \end{CD}$$

即 $\mu \circ \eta T = id_T = \mu \circ T\eta$。

代码

以 Haskell 为例。

自函子 $T$ $\leftrightarrow$ Functor
在 Haskell 里，对象是类型（Int, String），态射是函数（a -> b）。自函子对应 Functor 类型类，它提供了一个上下文（比如 Maybe 或 []），并用 fmap 映射态射：

class Functor f where
 fmap :: (a -> b) -> f a -> f b

单位自然变换 $\eta$ (eta) $\leftrightarrow$ return / pure
$\eta$ 的作用是把底层范畴的一个普通对象 $X$，放入到自函子 $T$ 的上下文中，即 $Id \to T$。
在 Haskell 中对应 Monad 的 return：把一个普通值放入最小的默认上下文中。

return :: a -> m a

乘法自然变换 $\mu$ $\leftrightarrow$ join
$\mu$ 的作用是 $T^2 \to T$。在 Haskell 里，$T^2$ 就是嵌套了两次的上下文，如 Maybe (Maybe Int) 或者 [[Int]]。
$\mu$ 的作用是 Flatten，对应 Control.Monad 里的 join。

join :: Monad m => m (m a) -> m a

Haskell 里的单子标志性动作是 >>= (bind)。>>= 可以看作是 fmap 和 join ($\mu$) 的组合。

(>>=) :: Monad m => m a -> (a -> m b) -> m b
x >>= f = join (fmap f x)

解释：

考虑值 x :: m a 和函数 f :: a -> m b
首先利用 fmap 把函数 f 应用到 x 内部。因为 x 本身有 m，f 又会产生一层 m，所以 fmap f x 的结果是嵌套的 m (m b) （即 $T^2$）
接着利用单子乘法 $\mu$（即 join）把 m (m b) 转换为 m b（即 $T^2 \to T$）。

简而言之，bind 操作可以理解为先做了一次自函子映射，然后执行了一次乘法运算。也就是嵌套成两层后拍平。

意义：

如果直接定义 m a -> m b 会失去通用性。如果是 a -> b，函数只关心业务逻辑（如加减法）；如果是 a -> m b，函数只关心逻辑结果是否合法（如除法是否除以0）;如果是 m a -> m b，函数还需要处理“输入 m a 本身是否为空这种复杂任务。

De Bruijn index

Mon, 23 Mar 2026 00:00:00 +0000

目的

考虑到 $\alpha$-等价性，$\lambda x. x$ 和 $\lambda y. y$ 在逻辑上是完全一样的，但写法不同，通过一套改写规则达到统一。

规则

定义

改写后的符号用自然数标识，标识为从当前位置往外数，第几个 $\lambda$ 符号是我的绑定者。一些例子：

$\lambda x. x$ 被改写成 $\lambda 1$
$\lambda x. \lambda y. x$ 改写成 $\lambda \lambda 2$
$\lambda x. \lambda y. \lambda z. x z (y z)$ 改写成 $\lambda \lambda \lambda 3 1 (2 1)$

形式化地，用 De Bruijn index 表示的 $\lambda$ 项，其语法为：

$$M, N ::= n | M N | \lambda M$$

其中 $n$ 是大于 0 的自然数，表示变量；$M N$ 表示应用；$λ M$ 表示抽象。

若变量 $n$ 处在至少 $n$ 个 $\lambda$ 的作用域内，则它是绑定变量；否则是自由变量。变量 $n$ 的绑定位置，是它所处作用域中从内向外数的第 $n$ 个 $\lambda$。

$\beta$ 规约

$(\lambda M) N$ 的 $\beta$-归约中，需要做三件事：

找出 $M$ 中那些由最外层这个 $\lambda$ 绑定的变量；
因为外层 $\lambda$ 被消去了，所以把 $M$ 中自由变量的编号整体减一；
用参数 $N$ 替换对应位置，同时根据替换发生时所在的 $\lambda$ 层深，适当提升 $N$ 中自由变量的编号。

例子：$(\lambda\ \lambda\ 4\ 2\ (\lambda\ 1\ 3))\ (\lambda\ 5\ 1)$

对应普通记号：$(\lambda x.\ \lambda y.\ z\ x\ (\lambda u.\ u\ x))\ (\lambda x.\ w\ x)$

替换过程：

标出将被替换的位置：$\lambda\ 4\ \Box\ (\lambda\ 1\ \Box)$
外层 $\lambda$ 消失，自由变量编号整体减一：$\lambda\ 3\ \Box\ (\lambda\ 1\ \Box)$
把方框 $\Box$ 替换为 $\lambda\ 5\ 1$，并根据所在 $\lambda$ 层提升自由变量编号：
- 第一个方框在 1 层 $\lambda$ 之下，因此替换成 $\lambda\ 6\ 1$
- 第二个方框在 2 层 $\lambda$ 之下，因此替换成 $\lambda\ 7\ 1$
得到 $\lambda\ 3\ (\lambda\ 6\ 1)\ (\lambda\ 1\ (\lambda\ 7\ 1))$

替换的形式化定义：一个替换可以写成无限序列 $M_1.M_2.M_3\ldots$，其中第 $i$ 项 $M_i$ 表示第 $i$ 个自由变量将被替换成什么。所有相关变量编号加上 $k$ (shift) 记作 $\uparrow^k$。$\uparrow^0$ 是恒等替换。一个有限替换 $M_1.M_2.\ldots.M_n$ 实际是 $M_1.M_2.\ldots.M_n.(n+1).(n+2)\ldots$，也就是只替换前 $n$ 个变量，其余保持不变。

替换作用记作 $M[s]$，替换的组合满足 $M[s_1\,s_2] = (M[s_1])[s_2]$。

变量：第 $n$ 个变量在替换后变成第 $n$ 个替换项；
应用：分别对左右两边替换；
抽象：进入 $\lambda$ 以后，要把替换表整体向上调整一层
- 即 $(\lambda M)[s] = \lambda (M[1 . (s \uparrow^1)])$
- 递归地，有 $(\lambda \lambda P)[s] = \lambda(\lambda P [1 . (s \uparrow^1)]) = \lambda (\lambda ( P [1 . 2 . (s \uparrow^2)] ))$

因此，$\beta$-归约可以简洁地写成 $(\lambda M)N \rightarrow M[N.1.2.3\ldots]$。例如，$(\lambda x. \lambda y. x)N$，也就是 $(\lambda \lambda 2)N$。$M = (\lambda 2)$，$s = N.1.2.3\dots$，要规约 $(\lambda 2)\ [N.1.2.3\dots]$。调整之后，$s' = 1 . (N[\uparrow^1]) . (1[\uparrow^1]) . (2[\uparrow^1]) \dots = 1 . (N\uparrow^1) . 2 . 3 . 4 \dots$。找到 $s'$ 的第二项，也就是 $N\uparrow^1$。所以，$(\lambda (\lambda 2))\ N$ 归约后的结果是 $\lambda (N\uparrow^1)$。

对于 $\uparrow^1$ 的解释为：若 $(\lambda x. \lambda y. x)\ N$ 的 $N$ 中含有自由变量 $z$，那么它原来往上索引会超出最外层环境，而在 $\beta-$规约之后，最外层环境增加了一层，自由变量 shift 是非常合理的。

优缺点

这样做的好处很明显：

机器友好，判断两个表达式是否相等，只需要看数字序列是否一致，不需要进行复杂的变量更名（$\alpha$-conversion）。
两个 $\alpha$-等价的项在内存中的表示是完全唯一的。可以直接通过哈希或简单的内存比较

但也有坏处：

代换复杂：在进行 $\beta$-归约时，被代入项跨越的 $\lambda$ 层数发生变化，其内部所有指向外部的数字都必须进行加减校准。带来实现上的复杂度。
人类难读。

其他

也有其他的策略，比如混合策略，对绑定变量使用 De Bruijn index 以方便计算，对自由变量使用名字以方便阅读。

扩散模型，蒸馏，以及量化

Mon, 23 Mar 2026 00:00:00 +0000

前因

读到朋友写的一篇博客，又想起来一两年前我的随机过程数学老师建议我去学习一下 diffusion model。现在我打算写一篇博客。由于没有正经阅读 AI 文献，以下部分有一些是 Gemini-generated，注意甄别。

几个概念

文生图模型

以扩散模型（Diffusion Models）为核心，并结合 Transformer 增强特征提取能力的复合架构。可以拆解为三个核心组件：Autoencoder（空间压缩）、Text Encoder（语义理解）和 Denoising Backbone（去噪骨架）。

Autoencoder (VAE) 空间压缩的目标是学习两个映射函数：编码器 (Encoder) $\mathcal{E}$ 和解码器 (Decoder) $\mathcal{D}$。

具体来说，给定一张图像 $x \in \mathbb{R}^{H \times W \times 3}$，通过编码器 $\mathcal{E}$ 可以将其转换为一个低维的潜在表示 $z = \mathcal{E}(x)$，其中 $z \in \mathbb{R}^{h \times w \times c}$，且通常 $h \ll H, w \ll W$。随后，解码器 $\mathcal{D}$ 可以用来将 $z$ 恢复回原始图像空间，即 $\mathcal{D}(z) \approx x$。

假设像素空间 $x$ 服从一个复杂的分布 $p(x)$，我们想要求潜变量的后验分布 $p(z|x)$；引入一个可计算的分布 $q_\phi(z|x)$（即编码器 $\mathcal{E}$）来逼近真实的后验分布。构造的数学目标是最小化 $q$ 与 $p$ 之间的 KL 散度。我们注意到对于一个给定的图像 $x$ 来说，$\log p(x)$ 是一个常数，满足：

$$ \begin{aligned} \log p(x) &= \mathbb{E}_q \left[ \log \frac{p(x, z)}{p(z|x)} \right]\\ &= \mathbb{E}_q \left[ \log \left( \frac{p(x, z)}{q_\phi(z|x)} \cdot \frac{q_\phi(z|x)}{p(z|x)} \right) \right]\\ &= \underbrace{\mathbb{E}_q \left[ \log \frac{p(x, z)}{q_\phi(z|x)} \right]}_{\text{ELBO}} + \underbrace{\mathbb{E}_q \left[ \log \frac{q_\phi(z|x)}{p(z|x)} \right]}_{D_{KL}(q \| p)} \end{aligned} $$

$D_{KL} \geq 0$，所以第一项就是 $\log p(x)$ 的下界。我们最大化这个下界以最小化两个分布之间的 KL 散度：

$$ \begin{aligned} \text{ELBO} &= \mathbb{E}_q [\log p(x|z) + \log p(z) - \log q_\phi(z|x)]\\ &= {\mathbb{E}_q [\log p(x|z)]} - {\mathbb{E}_q \left[ \log \frac{q_\phi(z|x)}{p(z)} \right]}\\ &= \underbrace{\mathbb{E}_{q_\phi(z|x)}[\log p_\theta(x|z)]}_{\text{重建项 (Reconstruction)}} - \underbrace{D_{KL}(q_\phi(z|x) \| p(z))}_{\text{正则项 (Regularization)}} \end{aligned} $$

反向传播要求损失函数对参数 $\phi$ 是可导的。编码器输出分布参数（比如均值 $\mu$ 和方差 $\sigma$）。$x \to \text{Encoder}(\phi) \to \text{Dist}(\mu, \sigma) \xrightarrow{\text{sampling}} z \to \text{Decoder} \to \text{Loss}$。

然而在计算 $\partial \text{Loss}/\partial \phi$ 时，梯度必须流经 $z$ 到达 $\phi$。但 $z$ 是采样得到的，因而是不可导的。就像掷骰子的结果（$z$）和骰子（分布）的参数（$\mu, \sigma$）之间的数学关系是断裂的。无法写出一个确定性的函数 $f(\mu, \sigma)$ 来表示这个采样过程的导数。

解决办法是从标准正态分布中采样一个噪声 $\epsilon \sim \mathcal{N}(0, 1)$。对于参数 $\phi$ 来说，$z$ 的表达式现在是完全可微的，而且还保持了分布

$$z = \mu + \sigma \odot \epsilon\sim \mathcal{N(\mu,\epsilon)}, \quad \epsilon \sim \mathcal{N}(0, \mathbf{I})$$

其中 $\mu$ 和 $\sigma$ 是编码器 $\mathcal{E}$ 输出的两个向量。这样，随机性被转移到了 $\epsilon$ 上，而对 $\mu$ 和 $\sigma$ 的梯度可以顺畅地流回编码器。这个技巧叫做重参数化。

这样一来，diffusion 就不再直接作用于像素空间 $x$，而是在潜在特征空间 $z$ 上进行，从而大幅减少了计算开销。

Text Encoder 文本编码器是一个将离散文本转为连续向量空间的映射 $c = \tau_\theta(y)$。定义：给定提示词（Prompt）$y$，编码器 $\tau_\theta$（如 CLIP 或 T5）将其转换为条件向量 $c$。数学意义：$c$ 通常是一个序列向量 $\in \mathbb{R}^{L \times d}$，其中 $L$ 是 Token 长度，$d$ 是特征维度。为生图提供语义指导。

去噪骨架是扩散模型的核心，数学上表现为一个噪声预测算子 $\epsilon_\theta$。在训练阶段，我们要最小化以下目标函数：

$$\mathcal{L} = \mathbb{E}_{z, \epsilon \sim \mathcal{N}(0,1), t, c} \left[ \| \epsilon - \epsilon_\theta(z_t, t, c) \|^2_2 \right]$$

变量含义：$z_t$：在 $t$ 时刻加噪后的潜变量。$c$：来自文本编码器的条件向量。$\epsilon_\theta$：神经网络（U-Net 或 Transformer），它学习预测注入到 $z$ 中的噪声 $\epsilon$。

这里 Gemini 给出了 “$t$ 代表噪声强度”的论述。在我的追问下，它给出如下说明：通常定义一系列随时间 $t$ 变化的参数，通常记作 $\alpha_t$。$\alpha_0\sim 1,\alpha_T\sim 0$。参数化：

$$z_t = \sqrt{\bar{\alpha}_t} z_0 + \sqrt{1 - \bar{\alpha}_t} \epsilon$$

其中 $\epsilon \sim \mathcal{N}(0, \mathbf{I})$，开根号是为了保持新分布的方差不变。

我的理解方式是，噪声是随机的，但去噪声的过程和 $c$ 有关，因而不是纯随机的，相当于带有一个 Guidance 的随机演化。

模型蒸馏

Practical Foundations For Programming Languages

Sun, 22 Mar 2026 00:00:00 +0000

简介

编程语言是由 Judgments 和 Inference Rules 定义的。Judgments 例如 “$e$ 是一个表达式（$e \text{ exp}$）” 或者 “$\tau$ 是一个类型（$\tau \text{ type}$）”。Inference Rules 的标记方法是：横线上方写前提（Premises）横线下方写结论（Conclusion）：

$$\frac{\Gamma \vdash e_1 : \text{nat} \quad \Gamma \vdash e_2 : \text{nat}}{\Gamma \vdash e_1 + e_2 : \text{nat}}$$

这种嵌套结构最后会成为证明树（Proof Tree）。

此外还有 Concrete Syntax 和 Abstract Syntax 的区别。前者是字符串，比如 1 + 1 或者 +(1, 1)。后者是抽象结构，可以使用抽象绑定树 (Abstract Binding Trees, ABTs) 来表示。比如表达式 1 + 2 在抽象语法中可能被表示为 plus(num[1]; num[2])。这种消歧表示直接体现了语言的逻辑结构。

$$\frac{\Gamma \vdash e_1 : \text{bool} \quad \Gamma \vdash e_2 : \tau \quad \Gamma \vdash e_3 : \tau}{\Gamma \vdash \text{if } e_1 \text{ then } e_2 \text{ else } e_3 : \tau}$$

中间的 $e_1$ 必须是 bool 类型；两个分支 $e_2$ 和 $e_3$ 必须具有相同的类型 $\tau$。结果类型就是那个共同的类型 $\tau$。

矩阵微积分简明教程笔记

Thu, 19 Mar 2026 00:00:00 +0000

前言

朋友发来了一个名为 gentle.pdf 的神秘文件。中文翻译可以是《矩阵微积分简明教程》。遂写一份笔记。不同的是与原文章不同，这篇笔记会更偏张量语言。

笔记

视矩阵为二阶张量 $X^i_j$。

那么 $\text {tr}(A) = A_i ^i$，于是迹的转置不变性显然。$\operatorname {tr}(AB) = \operatorname {tr}(A_i ^k B_k^j) = A_i^k B_k^i$。同理 $\operatorname {tr}(ABC) = \operatorname {tr}(A_i ^k B_k^j C_j^l) = A_i^k B_k^j C_j^i$。于是一列矩阵的积的迹在循环置换下的不变性显然。

线性型 $y^j = A_i^j x^i$。二次型 $f = A_{ij} x^i x^j$，注意到 $f = A'_{ji}x^jx^i = A'_{ij}x^ix^j$，因此 $f = (A_{ij}+A'_{ij}) x^ix^j/2$。也就是说，实际的有效输入只有 $(A+A')/2$。

Kronecker 积 $C^{ik}_{jl} = (A \otimes B)^{ik}_{jl} = A^i _j B^k_l$，得到的应该是一个 $4-$dim 的张量。只不过原文按照矩阵的表示方法。自然地，$(A \otimes B)^{ik}_{jl} (C \otimes D)^{jl}_{mn} = (A^i_j B^k_l) (C^j_m D^l_n) = (A^i_j C^j_m) (B^k_l D^l_n) = (AC)^i_{\phantom{i}m} (BD)^k_{\phantom{k}n}$，即 $(A\otimes B)(C\otimes D) = (AC)\otimes (BD)$。

vec 把一个指标对映射成一个单指标，根据原文的约定，对于 $\phi(i,j)$ 而言，前面的因子是慢指标，后面的因子是快指标（因为按列堆叠）。因此实际上对于矩阵 $A^i_j$ 而言，$\operatorname{vec} A$ 的行指标 $i$ 是快指标而列指标 $j$ 是慢指标，于是 $(\operatorname{vec} A)^{\phi (j,i)} = A^i_j$。而对于张量积的约定，很自然地有前面的指标是慢指标而后面的指标是快指标，于是很自然地有 $A^i_j\otimes B^k_l = C^{ik}_{jl} :\sim C^{\phi(i,k)}_{\phi(j,l)}$

我们定义 $Y_l^i = A_j^iB_k^jC_l^k$，则 $(\text{vec}Y)^{\phi(l,i)} = Y_l^i = C_l^k A_j^i (\text{vec} B)^{\phi(k,j)} = (C'\otimes A)_{\phi(k,j)}^{\phi(l,i)} (\text{vec} B)^{\phi(k,j)}$。即：在实际矩阵运算中 $C'\otimes A$ 这个 $(2,2)$ 型张量的上下指标分别被线性化展平，形成一个矩阵；而 $B$ 和 $Y$ 也分别被展平成向量。因此 $\operatorname{vec}(ABC) = (C' \otimes A) \operatorname{vec}(B)$。

对于原文中的 $K$，原定义为 $K \text{vec} A = \text{vec} A'$。这里采用张量的形式。按照上文约定，设 $B = A', x = \text{vec} A, y = \text{vec} B$，则 $y^{\phi(k,l)} = K^{\phi(k,l)}_{\phi(i,j)}x^{\phi(i,j)}$，且 $B^l_k = \delta_{jk}\delta^{il}A_i^j$。又 $B_k^l = K_{jk}^{il}A_i^j$，所以 $K_{jk}^{il} = \delta_{jk}\delta^{il}$。可以注意到这里的指标展平方式和前文两个矩阵的张量积的展平方式不同，一个简单的理解方式是，置换张量改变了指标的快慢次序。

于是很自然地，当 $m = n$，对于输入坐标 $\phi(i,j)$ 和输出坐标 $\phi(k,l)$，迹要求二者相等，求解得 $(i,j)=(k,l)$，于是 $\text{tr}(K) = \delta_{ji}\delta^{ij} = \delta_i^i = n$。

$K_{\phi(i,j)}^{\phi(k,l)} :\sim \delta_{jk}\delta^{il}, {K'} _{\phi(i,j)}^{\phi(k,l)} :\sim K_{\phi(k,l)}^{\phi(i,j)} :\sim \delta_{li}\delta^{kj}$，即得 $K$ 的对称性。又有 $(K^2)_{\phi(u,v)}^{\phi(k,l)} = \delta_{jk} \delta^{il}\delta_{vi}\delta^{uj} = \delta_k^u\delta_v^l$，即单位阵。

下面证明交换性定理 The Commuting Property，即 $K(A\otimes B) = (B\otimes A)K$。设等式左边为 $L$ 右边为 $R$。则 $L_{jl}^{uv} = K_{ik}^{uv}A^i_jB^k_l = \delta^v_i\delta ^u_kA^i_jB^k_l = A^v_j B_l^u$，$R_{st}^{ki} = A^i_jB^k_lK_{st}^{lj} = A^i_jB^k_l\delta^l_t\delta ^j_s = A^i_s B_t^k$，$(u,v)\mapsto(k,i),(j,l)\mapsto(s,t)$，因此 $L=R$，得证。

对于 $N_n = \frac{1}{2}(I+K)$，有 $N_n^2 = \frac{1}{4} (I+2K+K^2) = \frac{1}{4} (I+2K+I) = \frac{1}{2}(I+K) = N_n$。显然 $N_n$ 也满足 $N_n(A\otimes B) = (B\otimes A)N_n$。

定义一个还原矩阵 $D_n$，把一个 $n(n+1)/2$ 维的向量填充在矩阵的下三角位置还原并对称还原原矩阵对应的拉直的向量。即 $D_n \text{vech}(A) = \text{vec}(A)$，此处 $A = A'$。于是 $K_nD_n \text{vech} X= K_n \text{vec} X = \text{vec} X' = \text{vec} X = D_n \text{vech} X$，即 $K_nD_n = D_n$。

随机分析笔记

Thu, 19 Feb 2026 00:00:00 +0000

强化学习简记

Mon, 05 Jan 2026 00:00:00 +0000

起因：在实验室的书架上捞到一本强化学习（Richard & Andrew），简单记录一下笔记。享受线性阅读和手打笔记的乐趣。

导论

强调这本书是研究交互学习中的计算性方法，而不是直接建立关于人或动物如何学习的理论。

试错和延迟收益是强化学习的两个最重要最显著的特征。

当我们在提到强化学习（或者机器学习）的时候，要尤其注意这既表示一个问题，也表示解决问题的方法（甚至还表示一个领域）。不能混淆。

与监督学习不同，在一个未知领域中的交互问题场景下，若想要做到收益最大，智能体必须能够从自身的经验中学习。与无监督学习也不同，强化学习的目标在于最大化收益信号，而不是找出数据的隐藏结构。

强化学习有其独特的挑战：“试探”与“开发”的折中权衡。这个困境至今仍未被解决。另外一个关键的特征是明确了目标导向的智能体与不确定的环境交互这整个问题，通过感知环境的各个方面，选择动作来影响它们所处的环境。强化学习既可以涉及规划也可以涉及监督学习，因而如果想要有效地进行强化学习算法的研究，必须对自问题进行单独的考虑和研究。

强化学习和其他工程与科学学科之间有良好的互动，比如强化学习利用参数近似法解决了运筹学和控制论的研究中经典的“维度灾难”的问题。它和神经科学和心理学之间也有很强的相互作用。

曾经基于一般规则的方法，比如搜索或学习，被定性为“弱方法”，而基于知识的方法则被称为“强方法”。强化学习研究无疑在追求更简单的人工智能普适原则。

强化学习有四个核心要素：策略，收益信号，价值函数，（以及对环境建立的模型）。

策略是强化学习智能体的核心，是环境状态到动作的映射。它可能是简单的查找表，也可以是一个复杂的搜索的过程。一般来说，策略可能是环境状态和智能体所采取动作的随机函数。
收益信号是强化学习问题中的目标。收益信号表明了在短时间内什么是好的。
价值函数表示了从长远角度来看什么是好的。状态的价值是一个智能体从这个状态开始，对将来累积的总收益的期望。

从某种意义上来说，收益更加重要，而收益预测的价值次之。然而，在制定或者评估策略的时候，我们更关心的是价值。动作是基于对价值的判断做出的，但是确定价值的难度要比确定收益难得多。收益基本上是由环境直接给予的，但是价值必须综合评估，并根据智能体在整个观察过程中观察到的收益序列重新估计。事实上，价值评估方法才几乎是所有强化学习算法中最重要的组成部分。

对环境建立的模型是预测外部环境的下一个状态和下一个收益。环境模型会被用于做规划。简单的无模型方法是直接地试错，现代强化学习已经学会使用模型来进行规划。

强化学习非常依赖“状态”的概念。状态既作为策略和价值函数的输入，又作为模型的输入与输出。一般来说，可以非正式地思考状态的含义，并且把它理解为当前智能体可知的环境信息。这本书不处理构建状态信号的问题，并不是因为状态的表征不重要，而是希望专注于策略问题。

这本书对价值函数的估计进行了大量的讨论，但是一些优化算法，比如遗传算法、遗传规划、模拟退火算法以及其他算法也可以用来解决强化学习问题，而不用显式地估计价值函数。这些进化方法采用了大量静态策略，每个策略在扩展过的较长时间内与环境的一个独立实例进行交互，然后产生下一代。这类算法在当个个体的生命周期中不学习。如果决策空间足够小，或者可以很好地结构化地找到好的策略，或者智能体不能精确感知环境状态，那么进化方法是有效的（或者有优势的）。

然而，进化方法忽视了强化学习问题中的一些有用结构：忽略了索求策略是状态到动作的函数这一事实，也没有注意个体在生命周期内的状态和动作的迭代。这本书认为进化方法就其自身而言不适合强化学习问题，因此不介绍。

例子：井字棋。我们会将在贪心动作之后得到的状态所对应的价值“回溯更新”到动作之前的状态上。更准确地说，是对早先的状态的价值进行调整，使其更接近于后面的状态对应的价值。设 $S_t$ 表示在贪心动作之前的状态，$S_{t+1}$ 为转移之后的状态。价值函数用 $V(S_t)$ 来表示。那么：

$$ V(S_t) \gets V(S_{t+1}) + \alpha \Big [ V(S_{t+1}) -V(S_t) \Big] $$

$\alpha$ 称为步长参数，会影响学习速率。更新规则是时序差分的一个特例。如果步长参数随着时间的推移逐渐减小，对于任意固定对手，方法会收敛于最优策略下每个状态下真正的获胜概率。

此时再和评估策略的进化方法进行比较：进化方法会忽略博弈中间的过程，进而当玩家获胜时，误认为这次游戏中的所有动作都有功劳。而学习价值函数的过程利用了博弈过程中的可用信息。即使不用对手的模型，也不用显示地搜索所有可能的未来状态与动作的序列，简单的强化学习玩家也能针对短视的对手设置多步陷阱。

甚至强化学习理论也适用于连续时间问题。

在一些场景下，神经网络为程序提供了从其经验中进行归纳的能力，因此在新的状态中，它根据保存的过去遇到的相似状态的信息来选择动作，并由神经网络来做出最后决策。在大的状态集中强化学习系统能起到多达作用，与它从过去的经验中进行总结推广的能力密切相关。对于这些问题，神经网络和深度学习并不是唯一的，也不是最好的方法。

可以先学习无模型的方法，再学习如何将他们作为更复杂的有模型方法的组成部分。

关于左右互搏、对称性、贪心策略的，还有试探性学习可以进行更深入的讨论。

强化学习是第一个严格意义上的解决从环境互动中学习以达到长期目标这一计算问题的领域。

DOTO: 阅读强化学习早期历史

[P1] 代表表格型求解方法

[P1] 多臂赌博机

一个 $k$ 臂赌博机问题

考虑如下问题：你要重复地在 $k$ 个选项或动作中进行选择。每次做出选择，你都会得到一定数值的收益，收益由选择的动作决定的平稳概率分布产生。目标是在某一段时间内最大化总收益期望。也可以称之为老虎机。

$k$ 个动作中的每一个在被选择时都有一个期望或者平均收益，称之为动作的价值。记动作 $A_t$ 和收益 $R_t$，对任一动作 $a$ 的价值记作 $q_*(a)$ 是给定动作 $a$ 时收益的期望：

$$ q_*(a):=\mathbb{E}[R_t|A_t=a] $$

我们将对动作 $a$ 在 $t$ 时刻的价值的估计记作 $Q_t(a)$，我们希望它接近 $q_*(a)$。

在 $k$ 臂赌博机问题和相关问题中，有很多复杂方法可以用来平衡开发和试探，但是这些方法中的很多都对平稳情况和先验知识做出了很强的假设。但在实际问题中，这些假设要么难以被满足，要么无法被验证。在这本书中我们更关心的是要不要去平衡它们。

动作-价值方法

一种估算价值的方法是根据计算实际收益的平均值：

$$ Q_t(a) :=\frac{\sum_{i=1}^{t-1}R_i\mathbb{I}_{A_i=a}}{\sum_{i=1}^{t-1}\mathbb{I}_{A_i=a}} $$

称这种方法为平均采样方法，这是最简单的一种估值方法。

接下来我们采用贪心 $A_t:=\argmax _a Q_t(a)$ 来选择动作。如果偶尔采用 $\varepsilon$ 的概率来等概率随机选择，称为 $\varepsilon$-贪心。

10 臂测试平台

对于 10 个选择，每个选择的均值 $q_*(a)$ 从一个 0-1 高斯分布中生成，每个实际收益从 $\mathcal{N}(q_*(a),1)$ 中生成（平稳的情形）。

TODO: 写代码验证。取不同的 $\varepsilon$，甚至变化的 $\varepsilon$，比如可以考虑随着时间递减 $\varepsilon$。

增量式实现

对于上面提到的平均采样方法，为了减少占用的内存，推导递推公式：

$$ \begin{aligned} Q_{n+1} &= \frac{1}{n}\sum_{i\in 1..=n}R_i \\ &=\frac{1}{n}\Big(R_n + (n-1)Q_n \Big) \\ &=Q_n+\frac{1}{n}[R_n-Q_n] \end{aligned} $$

注意到这个形式和我们第一章井字棋更新估值函数的形式是一致的，这里的步长为 $1/n$，更一般地，我们记步长为 $\alpha_t(a)$。

跟踪一个非平稳问题

上面我们讨论的都是平稳的，即收益的概率分布不随着时间变化的赌博机问题。但当我们遇到非平稳的强化学习问题时，给近期的收益赋予比过去很久的收益更高的权值就是一种合理的处理方式。最简单的方法是使用固定步长（如上文所述），展开后是 $Q_{n+1}$ 是关于 $R_i$ 的加权平均和，准确来说是指数近因加权平均。

另外，对于 $\alpha_n(a)=1/n$，大数定律保证它可以收敛到真值。随机逼近理论中的一个著名结果给出了保证收敛概率为 1 的所需条件（Robbins–Monro）

TODO: 补充新的一页来给出 Robbins–Monro 条件的理论与证明。

$$ \sum _{n=1} ^{\infin} \alpha_n(a) = \infin \land \sum _{n=1}^{\infin} \alpha^2_n(a) \lt \infin $$

第一个条件需要保证足够大的步长，克服任何初始条件或随机波动。第二个条件保证最终步长变小，以保证收敛。

尽管在理论中常常用到，但是符合这个条件的步长参数序列往往收敛得很慢，而且或者需要大量调试才能得到一个满意的收敛率。

TODO: 编程证实采用采样平均方法解决非平稳问题的困难。使用 10 臂测试，其中所有 $q_*(a)$ 初始值相等，然后进行随机游走。在每一步，所有的 $q_*(a)$ 加上一个 $\mathcal{N}(0,0.01)$ 生成的增量。对比：(1)采样平均-增量步长计算(2)常数步长($\alpha=0.1$)-动作-价值。$\epsilon=0.1$

乐观初始值

初始值可以设置预期的收益的先验知识。此外，设置一个乐观的初始值也容易让学习器感到“失望”，从而转向其他的动作，进而导致所有动作在估计值收敛之前都被尝试了好几次，系统会进行大量的试探。

乐观初始值在开始可能会表现得很差，但是随着时间的推移，试探的次数逐渐减少，它也会表现得更好。这在平稳问题中非常有效。但它不太适合非平稳问题，因为它试探的驱动力是暂时的。采样平均也是把开始时间当作一个特殊的时间点，用相同权重去平均后续的收益。但是事实上，任何仅仅关注初始条件的方法都不太可能对一般的非平稳情况有帮助，因为开始时刻只出现一次。

无偏恒定步长技巧

平均采样相较于恒定步长的好处在于，它不会像恒定步长那样产生偏差。然而平均采样在非平稳问题上表现得很差。一种可行的，利用了恒定步长在非平稳过程中的优势并且避免了它的偏差的方法是：针对某个特定动作的第 $n$ 个收益

$$ \begin{aligned} \beta _n &:= \alpha / \bar{o} _n \\ \bar{o}_n &:= \bar{o}_{n-1} +\alpha (1-\bar{o}_{n-1}) \end{aligned} $$

基于置信度上界的动作选择

upper confidence bound 置信上界

$$ A_t:= \argmax _a \Big [ Q_t(a) + c\sqrt{\frac{\ln t}{N_t(a)}} \Big] $$

其中 $N_t(a)$ 表示在时刻 $t$ 之前 $a$ 动作被选择的次数。

TODO: 解释尖峰及其出现时刻

梯度赌博机算法

考虑对每一个动作 $a$ 学习一个数值化的偏好函数 $H_t(a)$。利用这个 $H_t(a)$ 和玻尔兹曼分布确定动作概率：

$$ \Pr\{A_t=a\} := \frac{e^H_t(a)}{\sum_{i=1}^ke^{H_t(i)}} := \pi_t(a) $$

$\pi_t(a)$ 表示被选择的概率。进而提出一种自然学习算法：当选择动作 $A_t$ 并获得收益 $R_t$ 后，偏好函数的更新方式为

$$ \begin{aligned} H_{t+1}(A_t) &:= H_t(A_t) + \alpha (R_t - \bar{R} _t)(1-\pi_t(A_t)), \\ H_{t+1}(a) &:=H_t(a) -\alpha (R_t - \bar{R} _t)\pi_t(a), \quad a\neq A_t \end{aligned} $$

其中 $\alpha$ 是步长，$\bar{R}_t$ 表示在时刻 $t$ 内所有收益的平均值，作为比较收益的基准项。

通过随机梯度上升实现梯度赌博机算法

在精确的梯度随机上升算法中，每一个动作的偏好函数 $H_t(a)$ 与增量对性能的影响成正比。

$$ \begin{aligned} H_{t+1}(a)-H_t(a) &= \alpha \frac{\partial \mathbb{E}[R_t]}{\partial H_t(a)} \\ \mathbb{E}[R_t] :&= \sum_x \pi_t(x)q_*(x) \end{aligned} $$

当然，因为 $q_*(x)$ 未知，因此不可能实现真正精确的随机梯度上升算法。注意到 $\sum_x\pi_t(x) = 1$，因而 $\sum _x \partial \pi_t(x)/\partial H_t(a) = 0$，所以：

$$ \begin{aligned} \frac{\partial \mathbb{E}[R_t]}{\partial H_t(a)} &= \sum_x q_*(x) \frac{\partial\pi_t(x)}{\partial H_t(a)} \\ &=\sum_x (q_*(x)-B_t) \frac{\partial\pi_t(x)}{\partial H_t(a)} \\ &=\sum_x \pi_t(x) \frac{(q_*(x)-B_t) \frac{\partial\pi_t(x)}{\partial H_t(a)}}{\pi_t(x)}\\ &=\mathbb{E}\Big [(q_*(A_t)-B_t)\frac{\partial\pi_t(A_t)}{\partial H_t(a)}/{\pi_t(A_t)} \Big]\\ &=\mathbb{E}\Big [(R_t-\bar{R}_t)\frac{\partial\pi_t(A_t)}{\partial H_t(a)}/{\pi_t(A_t)} \Big] \end{aligned} $$

关于最后一步的解释：

质数筛

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

两种筛的分析

感谢 @LS-Hower 的勘误

埃拉托斯特尼筛

对于每一个质数 $p$，标记其倍数 $p^2,p(p+1),p(p+2)\cdots$，对于足够大的 $n$ 和固定的 $p$，标记次数约为

$$T(n)\sim \sum_{p\le n} \frac{n}{p} = n\sum _{p\le n}\frac{1}{p}$$

利用质数调和级数的渐近式

$$\sum _{p\le n} \frac{1}{p} = \log\log n+B+o(1)$$

从而 $T(n)=n\log\log(n)$。有一个 $\log\log n$ 的因子，说明重复访问。

欧拉筛

记 $\text{lp}(n)$ 为 $n$ 的最小质因子（least prime factor）。由最小质因数引入划分 $\mathcal{L}_p=\{n\ge 2;\text{lp}(n)=p\}$。

由二元对 $(n,p)$ 双射地标记一个合数 $x=n\times p$，满足性质 $\text{lp}(x)=p$。

为了给出遍历算法，我们让 $n$ 自然生长，而限制 $p\in \mathcal{P}$ 的范围 $p\le \text{lp}(n)$，以保持 $\text{lp}(x)=p$ 的性质。每个合数仅被其最小质因子筛去一次，因此算法时间复杂度为 $O(n)$。

$p\le \text{lp}(n)$ 的证明: 设 $p_n:=\text{lp}(n)$，那么 $\text{lp}(n\times p)=\min\{p,p_n\} = p$，说明当 $p \leq \text{lp}(n)$ 时，性质得到延续。; 若 $p\gt p_n$，$\text{lp}(n\times p)=\min\{p,p_n\} = p_n\neq p$，性质被破坏。此时得到的合数 $n\times p$ 应该隶属于 $\mathcal{L}_{p_n}$ 而非 $\mathcal{L}_p$，因此不应继续用更大的质数去枚举这个 $n$ 的后继标记。

积性函数的自然分解

基本概念

$f:\mathbb{N}\to \mathbb{C}$ 称积性的，如果对于互质的 $m,n$，$f(mn) = f(m)f(n)$。
如果对所有 $m,n$ 都满足，则称为完全积性的。

定义狄利克雷卷积

$$ (f*g)(n):= \sum_{d \mid n}f(d)g \Big(\frac{n}{d} \Big ) $$

狄利克雷卷积可以保持积性。

定义 $\varepsilon := \llbracket n=1\rrbracket, 1(n) = 1, \text{id}(n)=n$，那么 $1*\mu=\varepsilon, 1*1=\tau, \text{id}*1=\sigma, 1*\varphi=\text{id}$

一点代码

fn linear_sieve(n: usize) -> (Vec<usize>, Vec<usize>) {
 let mut lp = vec![0usize; n + 1]; // least prime factor
 let mut primes = Vec::new();

 for i in 2..=n {
 if lp[i] == 0 {
 lp[i] = i;
 primes.push(i);
 }

 for &p in &primes {
 let x = i * p;
 if x > n {
 break;
 }

 lp[x] = p;

 if p == lp[i] {
 break;
 }
 }
 }

 (lp, primes)
}

import Control.Monad
import Control.Monad.ST
import Data.Array.ST
import Data.Array.Unboxed

linearSieve :: Int -> (UArray Int Int, [Int])
linearSieve n = runST $ do
 lp <- newArray (0, n) 0 :: ST s (STUArray s Int Int)
 primesRef <- newSTRef []

 forM_ [2..n] $ \i -> do
 v <- readArray lp i
 when (v == 0) $ do
 writeArray lp i i
 modifySTRef primesRef (i:)

 primes <- readSTRef primesRef
 lpi <- readArray lp i

 forM_ primes $ \p -> do
 when (p <= lpi && i * p <= n) $ do
 writeArray lp (i*p) p

 lp' <- freeze lp
 primes <- fmap reverse (readSTRef primesRef)
 return (lp', primes)

随机分析笔记

Sat, 03 Jan 2026 00:00:00 +0000

概率论基础

$\Omega$ 是非空集合，$\mathcal{F}$ 是 $\Omega$ 的子集族。

$\sigma$ 代数: 称 $\mathcal{F}$ 是一个 $\sigma$ 代数，如果：; (1) $\varnothing\in\mathcal{F}$; (2) $A \in \mathcal{F} \implies A^c \in \mathcal{F}$; (3) $A_1, A_2 \cdots \in \mathcal{F} \implies \bigcup _{n=1}^{\infin} A_n\in \mathcal{F} $

概率: 概率测度 $\mathbb{P} :\mathcal F \to [0,1],A\mapsto \mathbb{P} (A)$。称 $\mathbb{P} (A)$ 为 $A$ 的概率，三元组 $(\Omega,\mathcal{F} ,\mathbb{P})$ 为一个概率空间。要求：; (1) $\mathbb{P} (\Omega) = 1$; (2) $A_i \in \mathcal{F}, A_i \cap A_j = \varnothing \implies \mathbb{P} \Big(\bigcup _{n=1}^{\infin} A_n\Big) = \sum _{n=1} ^{\infin} \mathbb{P} (A_n)$

均匀测度: 也称勒贝格测度 $\mathcal{L}$。; 由全体闭区间出发而生成的 $\sigma$ 代数称为 [0,1] 的子集的 Borel $\sigma$ 代数，记为 $\mathcal{B}([0,1])$。; $\mathbb{P}([a,b]) = b-a, 0\le a\le b\le 1$

几乎必然: 设 $(\Omega,\mathcal{F} ,\mathbb{P})$ 是一个概率空间。如果 $A\in \mathcal{F} \land \mathbb{P}(A) = 1$，称事件 $A$ 几乎必然发生。

随机变量: 设 $(\Omega,\mathcal{F} ,\mathbb{P})$ 是一个概率空间。称 $X: \Omega\to \mathbb{R}$ 是一个随机变量，如果：; (1) $B\in \mathbb{B}(\mathbb{R}) \implies \{X\in B\} := \{\omega \in \Omega; X(\omega)\in B \}\in \mathcal{F} $

分布测度: 设 $X$ 是概率空间 $(\Omega,\mathcal{F} ,\mathbb{P})$ 上的一个随机变量。$X$ 的分布测度是一个概率测度; $\mu_X: \mathbb{B}(\mathbb{R}) \to [0,1], \mu_X(B) \mapsto \mathbb{P} \{X\in B\} $

指示函数: 当 $\omega\in A$ 时 $\mathbb{I}_A(\omega) = 1$ 否则 $\mathbb{I}_A(\omega)=0$。随机变量 $\mathbb{I}_A$ 称为集合 $A$ 的指示函数。对于 $A\sub \Omega$，定义 $$\int _A X(\omega) d \mathbb{P}(\omega) = \int _\Omega \mathbb{I}_A(\omega) X(\omega) d \mathbb{P}(\omega)$$

期望: $X$ 是在 $(\Omega,\mathcal{F} ,\mathbb{P})$ 上的随机变量。$X$ 的期望定义为：; $$\mathbb{E}(X) = \int _\Omega X(\omega)d\mathbb{P}(\omega)$$; 有詹森不等式：$\varphi$ 是 $\mathbb{R}$ 上的实值凸函数且 $\mathbb{E}(X)\le \infin$，则 $\varphi(\mathbb{E}X)\le \mathbb{E}\varphi(X)$

信息和条件期望

L3 cache mapping on Sandy Bridge CPUs, Mark Seaborn

Tue, 14 Jan 2025 00:00:00 +0000

前言

出自这篇博客, by Mark Seaborn, on Monday, 27 April 2015

简介

Sandy Bridge 处理器的 L3 缓存（三级缓存）是多个核心共享的，通常位于每个处理器模块内。每个模块包含两个核心，多个模块构成一个处理器。L3 缓存的大小通常为 3MB、6MB 或 8MB，根据处理器型号的不同而有所不同。
在一些测试中，Sandy Bridge 的 L3 缓存使用的是分布式环形结构（NUCA, Non-Uniform Cache Architecture），不同核心之间可以共享缓存。由于这种架构，缓存访问的延迟会根据物理地址的映射和访问的核心而有所不同。

L3 缓存映射：Sandy Bridge 的 L3 缓存被划分为多个缓存切片，每个核心对应一个缓存切片，处理器通过物理地址哈希算法决定每个地址映射到哪个缓存切片。这一机制是对内存访问的优化，减少了不同核心之间访问共享缓存的延迟。
行锤攻击：Sandy Bridge 的缓存架构和内存控制器特性可能被用于行锤攻击（Row Hammering）。在这种攻击中，攻击者可以通过频繁访问内存中的某些行，诱使 DRAM 出现位翻转，这可能导致数据损坏或安全漏洞。

然而我的老电脑 Intel Core i5-7200U 不属于这个结构，而是 Kaby Lake

原文概述

2013 年，一些研究人员逆向工程了 Intel Sandy Bridge CPU 如何将物理地址映射到 L3 缓存（最后一级缓存）中的缓存集合¹。他们对缓存映射感兴趣，因为它可以用来绕过内核的 ASLR²。博客作者感兴趣的原因是，the cache mapping can be used to test whether cached memory accesses can do row hammering.

Some background

在 Sandy Bridge CPU 上，L3 缓存被划分为多个切片。物理地址通过哈希函数决定它们将存储在哪个 L3 缓存切片中。

L3 缓存是分布式的，并且基于环形结构。每个核心有一个切片，但 CPU 中的所有核心都可以通过环形总线访问所有的缓存切片，环形总线将所有核心及其缓存连接在一起。

当一个核心访问内存位置时，如果该位置映射到另一个核心的缓存切片上，访问速度会稍微变慢，因为需要绕过环形总线进行一到两次跳跃才能访问该位置。环形总线上使用的协议基于 QPI³⁴

每个缓存切片包含 2048 个缓存集合。在低端 CPU 上，缓存集合是 12 路关联的，因此一个缓存切片的大小为 1.5MB（2048 个集合，12 路每个缓存行 64 字节 = 1.5MB）；在高端 CPU 上，缓存集合是 16 路关联的，因此一个缓存切片的大小为 2MB。

Cache mapping

研究人员（Hund 等人）发现，L3 缓存使用物理地址的位如下：

位 0-5：这 6 位表示在 64 字节缓存行内的字节偏移。
位 6-16：这 11 位表示缓存切片内的缓存集编号。
位 17-31：这些位经过哈希运算，决定使用哪个缓存切片。
位 32 及以后：未使用。

选择缓存切片的哈希函数如下：

在 4 核 CPU 上，有 4 个缓存切片，因此切片号是 2 位。切片号的两个位分别是 h1 和 h2，其中：
- h1 是物理地址位 18、19、21、23、25、27、29、30、31 的 XOR。
- h2 是物理地址位 17、19、20、21、22、23、24、26、28、29、31 的 XOR。
在 2 核 CPU 上，有 2 个缓存切片，因此切片号是 1 位。切片号是物理地址位 17、18、20、22、24、25、26、27、28、30 的 XOR。这等同于 h1 和 h2 的 XOR。（位 19、21、23、29 和 31 在 XOR 计算时会相互抵消，这部分是博客作者发现的内容）

Verifying the cache mapping

步骤如下：

选择 N 个物理内存地址，这些地址根据我们猜测的缓存映射应该映射到同一个缓存集。
使用 Linux 的 /proc/PID/pagemap 接口来确定我们可以访问哪些物理地址。
测量访问这些 N 个地址所需的时间。具体来说，程序首先访问前 N-1 个地址，然后测量访问第 N 个地址的时间。
程序针对多个 N 值进行测试。

如果正确猜测了缓存映射，那么，在具有 12 路缓存的 CPU 上，我们应该会看到在 N=13 时，内存访问时间大幅上升。这是因为，在 N=13 时，我们访问的内存位置已经不再适合 12 路缓存集，导致 L3 cache miss。内存访问时间将从 L3 缓存的延迟增加到 DRAM 的延迟。

注意：这也假设缓存使用 LRU or Pseudo-LRU eviction policy（Sandy Bridge 使用的策略）。然而，Ivy Bridge 的 cache eviction policy 发生了变化。

如果我们猜错了缓存映射，内存访问时间将以 N 的较高值逐渐上升。在一个 2 缓存片 CPU 上，如果我们得到的地址到片散列函数错误，我们将看到访问时间达到 DRAM 延迟 N = 13 * 2，平均，因为 N 个物理地址将分布在 2 个片上，所以在片上的 2 个缓存集溢出并产生缓存丢失之前，平均需要 13 * 2 个地址。

Ivy Bridge

这种 L3 缓存映射似乎同样适用于 Ivy Bridge 系列的 CPU。作者在配有 Ivy Bridge CPU 的机器上运行了相同的测试（2-core, 4-hyperthread），最初得到了相同的图形结果。然而，这些结果在该机器上并没有稳定复现。后续的测试显示，在 N<=12 时，内存访问时间更高。

这与报告一致，说明 Ivy Bridge 的 L3 缓存使用了 DIP (Dynamic Insertion Policy)⁵ 作为其 cache eviction policy，以避免 cache thrashing。DIP 会在 LRU 和 BIP 之间动态切换：LRU 更适用于较小的工作集（可以完全装入缓存），而 BIP 更适用于较大的工作集（无法完全装入缓存）。对于 N>12，作者的测试可能会产生足够的缓存未命中，从而导致缓存切换到 BIP 模式。这意味着测试 N 值的顺序可能会影响最终结果。

Thanks

Thanks to Yossef Oren for pointing me to the paper by Hund et al, which is referenced by the paper he coauthored, “The Spy in the Sandbox – Practical Cache Attacks in Javascript” (Yossef Oren, Vasileios P. Kemerlis, Simha Sethumadhavan, Angelos D. Keromytis).

附原作者致谢

源码阅读

frame_number_from_pagemap, init_pagemap, get_physical_addr

// Extract the physical page number from a Linux /proc/PID/pagemap entry.
uint64_t frame_number_from_pagemap(uint64_t value) {
 return value & ((1ULL << 54) - 1); // 保留低 54 位
}

void init_pagemap() {
 g_pagemap_fd = open("/proc/self/pagemap", O_RDONLY);
 assert(g_pagemap_fd >= 0);
}

uint64_t get_physical_addr(uintptr_t virtual_addr) {
 uint64_t value;
 off_t offset = (virtual_addr / page_size) * sizeof(value); // 页表偏移
 int got = pread(g_pagemap_fd, &value, sizeof(value), offset); // 读 8 个字节
 assert(got == 8);

 // Check the "page present" flag.
 assert(value & (1ULL << 63));

 uint64_t frame_num = frame_number_from_pagemap(value);
 return (frame_num * page_size) | (virtual_addr & (page_size - 1)); // 物理页号，偏移量
}

get_cache_slice, in_same_cache_set

哈希相关缓存位，计算物理地址对应的 cache slice

int get_cache_slice(uint64_t phys_addr, int bad_bit) {
 static const int bits[] = { 17, 18, 20, 22, 24, 25, 26, 27, 28, 30 };

 int count = sizeof(bits) / sizeof(bits[0]);
 int hash = 0;
 for (int i = 0; i < count; i++) {
 hash ^= (phys_addr >> bits[i]) & 1;
 }
 if (bad_bit != -1) {
 hash ^= (phys_addr >> bad_bit) & 1;
 }
 return hash;
}

检查两个物理地址是否属于相同的 cache set，对比低 17 位是否相等 && 所处的 cache slice 是否一样

bool in_same_cache_set(uint64_t phys1, uint64_t phys2, int bad_bit) {
 uint64_t mask = ((uint64_t) 1 << 17) - 1;
 return ((phys1 & mask) == (phys2 & mask) && get_cache_slice(phys1, bad_bit) == get_cache_slice(phys2, bad_bit));
}

time_access, timing

// Execute a CPU memory barrier. This is an attempt to prevent memory
// accesses from being reordered, in case reordering affects what gets
// evicted from the cache. It's also an attempt to ensure we're
// measuring the time for a single memory access.
//
// However, this appears to be unnecessary on Sandy Bridge CPUs, since
// we get the same shape graph without this. （这是为什么呢？）
inline void mfence() {
 asm volatile("mfence");
}

// Measure the time taken to access the given address, in nanoseconds.
int time_access(uintptr_t ptr) {
 struct timespec ts0;
 int rc = clock_gettime(CLOCK_MONOTONIC, &ts0);
 assert(rc == 0);

 g_dummy += *(volatile int *) ptr;
 mfence();

 struct timespec ts;
 rc = clock_gettime(CLOCK_MONOTONIC, &ts);
 assert(rc == 0);
 return (ts.tv_sec - ts0.tv_sec) * 1000000000 + (ts.tv_nsec - ts0.tv_nsec); // 合成秒&纳秒差
}

关于单调时钟 CLOCK_MONOTONIC：A nonsettable system-wide clock that represents monotonic time since—as described by POSIX—“some unspecified point in the past”. On Linux, that point corresponds to the number of seconds that the system has been running since it was booted.

测量多个内存地址的访问时间。通过在给定地址集上进行多次内存访问，测量缓存是否被命中，以及时间的变化。
取到第一个物理地址之后，筛选所有和他在同一个 cache set 的物理地址。做 10 次测量，取中位数时间。

int timing(int addr_count, int bad_bit) {
 size_t size = 16 << 20; // 分配 16MB 内存
 uintptr_t buf = (uintptr_t) mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_POPULATE, -1, 0);
 assert(buf);

 uintptr_t addrs[addr_count];
 addrs[0] = buf;
 uintptr_t phys1 = get_physical_addr(addrs[0]);

 uintptr_t next_addr = buf + page_size;
 uintptr_t end_addr = buf + size;
 int found = 1;
 while (found < addr_count) {
 uintptr_t addr = next_addr;
 next_addr += page_size;
 uint64_t phys2 = get_physical_addr(addr);
 if (in_same_cache_set(phys1, phys2, bad_bit)) {
 addrs[found] = addr;
 found++;
 }
 }

 int runs = 10;
 int times[runs];
 for (int run = 0; run < runs; run++) {
 g_dummy += *(volatile int *) addrs[0];
 mfence();
 for (int i = 1; i < addr_count; i++) { // 访问一轮
 g_dummy += *(volatile int *) addrs[i];
 }
 mfence();
 times[run] = time_access(addrs[0]); // 重新访问 addrs[0]
 }
 std::sort(times, &times[runs]);
 int median_time = times[runs / 2];

 int rc = munmap((void *) buf, size);
 assert(rc == 0);

 return median_time;
}

TODO

添加本机测试
下一篇相关博客

https://ieeexplore.ieee.org/document/6547110?reload=true&arnumber=6547110 ↩︎
Address_space_layout_randomization ↩︎
Intel 的 QuickPath Interconnect，其设计目标是替代之前的“前端总线”技术，以实现快速路径互连。QPI 是一种用于在高端多插槽系统中连接多个 CPU 的协议。后于 2017 年，在 Skylake-SP Xeon 平台上，QPI 被 Intel Ultra Path Interconnect（UPI）替代。 ↩︎
非常遗憾的是，我并没有找到 Intel Core i5-7200U 的相关说明。只找到了 i7 某些型号采用了 QPI 的文档 Performance Analysis Guide for Intel® Core™ i7 Processor and Intel® Xeon™ 5500 processors，pg5 有配图，说明了不同 LLC 通过 QPI 的联系。（还找到一篇相关博客，待阅读） ↩︎
找到了一篇有关于 DIP 的论文以及 PPT，还有博客 ↩︎

vim basic

Thu, 27 Jun 2024 00:00:00 +0000

| 命令 | 含义 |
| ------ | --------------------- |
| x | 删除当前光标所在字符 |
| A | 直接在行末添加 |
| d | 删除命令，后跟对象 |
| dd | 删除整行 |
| ndd | 删除 n 行 |
| U | 恢复改行状态/撤销恢复 |
| CTRL-R | 重做撤销 |
| p | 粘贴（从上方） |
| r | 替换单个字符 |

| 对象/光标移动 | 含义 |
| ------------- | ------------------------------------------------- |
| nw | 向前移动 n 个单词，不包括它的第一个字母 |
| ne | 光标到当前计起的第 n 个单词末尾，包括最后一个字母 |
| $ | 光标到行末 |
| 0 | 光标到行首 |

zfs: couldn't save system state

Thu, 27 Jun 2024 00:00:00 +0000

bpool 空间不够了。

在 reddit 上找到了解决方案，用 GitHub 上的脚本成功解决。以下引用自这个 reddit。

尽管 zfs 只是 storing the differences，但是每个 state 都需要大约 100MB 的新存储空间。由于 zsys 的默认策略是保持至少 20 个状态，这将需要 20 * 100MB = 2GB 的存储空间。这意味着我们要使用整个 boot 分区来进行快照。还有一个解决方案是参考这篇博客，方法是手动编辑 zsys.conf 减少快照存储数量。