AIGC 基本功|扩散模型的跨步缓存复用-DiffCache

同样走完采样器的每一步，能不能少算几次昂贵的去噪网络？跨步缓存把这个问题拆成两件事：复用什么，以及什么时候必须刷新。本文用残差缓存的最小实验解释机制，再对照 DeepCache 和 TeaCache 的真实实现。实验是人工构造的数值系统，不是视频模型的质量或速度复现。

本文承接 DDIM 与高阶采样器、DiT 和 性能建模与 Profiling。默认读者知道采样器会反复调用网络，不要求先读缓存论文。论文版本与官方代码核对日期为 2026-10-05。

01. 为什么需要它

一次视频生成中，潜变量在逐步变化，文本条件通常固定，网络却要一遍遍穿过相同的模块。假如两次调用的深层特征几乎一样，重新计算这部分就可能浪费时间。但“几乎一样”只是观测，不能推出“任意一次都可以省”。运动切换、条件变化和采样末期的细节修整，都可能让陈旧特征的误差显现。

这里最具体的失败场景是固定间隔缓存：先完整算一次，之后连续复用，直到计数器要求刷新。如果变化突然出现在间隔中间，策略不会因为内容变了而提前刷新。反过来，如果某段变化很慢，固定间隔也会做多余的完整计算。问题在于日历式排期没有感知当前输入，周期短会损失收益，周期长会增加近似误差。

本文实验保留全部 40 次状态更新。精确版本执行 40 次完整残差计算；自适应阈值为 0.16 时，只执行 11 次，复用 29 次。终点相对误差为 0.008222。它证明了在这个特定数值系统中确实可以减少计算次数，同时也证明输出发生了变化。它不证明视频质量达标，更不证明真实 GPU 上能得到相同的提速。

缓存适合回答“这个步骤里，哪些计算可以暂时沿用”。减少采样步数则改变采样器的离散路径。两种方法可以组合，但组合后的误差要重新评估：单独用缓存通过了一组样例，不意味着换成少步采样器后仍然通过。

02. 最小可用理解

第一，把网络拆成每步仍要计算的部分，以及准备复用的昂贵部分。第二，保存上次完整计算得到的特征或残差，用便宜的变化指标决定是否刷新。第三，即使命中缓存，当前输入仍然要参与输出，采样器仍然继续更新状态。

以残差形式为例，设当前嵌入是 $h_i$，完整模块输出为 $G(h_i,t_i,c)$。缓存保存的是 $R_i=G(h_i,t_i,c)-h_i$。如果上次刷新发生在 $r$，当前近似模块输出是 $h_i+R_r$。符号 $i$ 表示第几次网络调用，$t_i$ 是这次调用的时间条件，$c$ 是固定的文本等条件；$r$ 是缓存的生成时刻，通常小于当前 $i$。

这三句话的重点是“当前输入加旧残差”。如果直接把整个旧输出拿回来，连当前输入的变化也被抹掉了。残差复用仍然有误差，只是保留了输入的直通更新。DeepCache 的 U-Net 高层特征缓存并不等于这个残差写法，不能把所有缓存方法都称为同一个算法。

03. 数学推导

先定义缓存误差发生在哪里

设 $E$ 是便宜的输入嵌入，$G$ 是昂贵模块，$H$ 是输出头。完整调用写为：

$$h_i=E(x_i,t_i,c),\quad R_i=G(h_i,t_i,c)-h_i,\quad y_i=H(h_i+R_i,t_i,c)$$

$x_i$ 是采样器当前的潜变量；$h_i$ 是网络内部的嵌入，不必与 $x_i$ 形状相同；$R_i$ 是昂贵模块对嵌入的修正；$y_i$ 是送回采样器的网络预测。这里的预测可以按模型定义代表噪声或速度，缓存逻辑本身不替模型选择参数化。等式只是代数分解，不要求模型专门训练一个名叫“残差缓存”的层。

命中缓存后，输入嵌入和输出头仍按当前条件计算：

$$\widehat{y}_i=H(h_i+R_r,t_i,c),\quad r<i$$

帽子表示近似计算。比较精确与近似时，先固定当前同一个 $h_i$：误差来自 $R_r$ 替代了 $R_i$，而不是来自状态已经分叉。若输出头在所讨论的局部区域满足 Lipschitz 条件，常数记作 $L_H$，那么：

$$\|\widehat{y}_i-y_i\|\leq L_H\|R_r-R_i\|$$

Lipschitz 条件的意思是输入变化不能被这个局部映射无限放大；$L_H$ 是放大上限。本文没有测出真实模型的 $L_H$，这个式子是带假设的分析工具，不是线上质量保证。它告诉我们，缓存内部误差小仍然需要考虑输出头的敏感性。

为什么使用便宜的变化代理

直接计算 $\|R_i-R_r\|$ 能判断缓存是否陈旧，但得到 $R_i$ 就已经做了昂贵计算。为了节省计算，需要先观察一个便宜的量 $m_i$。它可以由当前嵌入与时间条件构造。相邻调用的相对 L1 变化写为：

$$d_i=\frac{\operatorname{mean}|m_i-m_{i-1}|}{\max(\operatorname{mean}|m_{i-1}|,\varepsilon)}$$

$\operatorname{mean}$ 对张量所有元素取平均，绝对值逐元素计算，$\varepsilon$ 是防止除零的小正数。两次张量形状一致时，均值之比等于 L1 范数之比。这个值没有单位，反映变化相对之前幅度有多大。分母很小时，它也可能变得敏感，不能把这种数值问题误判成内容剧烈变化。

本文教学实现取 $\varepsilon=10^{-12}$。该保护和后面非负累计属于教学实现的防御性处理；不能据此声称官方代码逐字采用相同逻辑。

最直觉的想法是：如果每一步变化都很小，就一直复用。但缓存对应的是刷新时刻 $r$，不是上一时刻。利用三角不等式：

$$\|m_i-m_r\|\leq\sum_{j=r+1}^{i}\|m_j-m_{j-1}\|$$

这里 $j$ 遍历刷新之后的调用。即使单步变化很小，连续多步也会积累成明显差异，因此策略应保留“自上次刷新以来的变化预算”。这个式子约束绝对变化；把每项分别除以不同的幅度后，不能直接称相对变化之和为严格误差界。

实际决策可以采用累计代理：

$$A_i=A_{i-1}+g(d_i),\quad \text{refresh if } A_i\geq\delta$$

$A_i$ 是累计预算，$g$ 将输入变化映射到预估的输出变化，$\delta$ 是刷新阈值。完整计算后把预算归零并保存新残差。TeaCache 使用多项式重标定来改善这种代理；拟合关系是经验估计，不会把统计相关性变成对所有样本成立的数学上界。TeaCache 原文第 3.2–3.3 节 给出了指标与累计决策。

本文取 $g(d)=d$，以便只观察状态机。阈值 0.16 因而只属于本实验的代理尺度，不能迁移成真实模型的推荐阈值。换掉嵌入幅度、时间调制或采样路径，同一个阈值对应的刷新频率就会改变。

一次局部近似如何影响后续轨迹

现在让两条轨迹分别使用精确和近似输出。为便于推导，考虑显式 Euler 更新：

$$x_{i+1}=x_i+\Delta s_i v(x_i,s_i),\quad \widehat{x }_{i+1}=\widehat{x }_i+\Delta s_i\widehat{v}(\widehat{x }_i,s_i)$$

$s_i$ 是积分坐标，$\Delta s_i>0$ 是步长，$v$ 是精确向量场，$\widehat{v}$ 使用缓存近似。令 $e_i=\|\widehat{x }_i-x_i\|$ 表示轨迹差异，令 $\eta_i=\|\widehat{v}(\widehat{x }_i,s_i)-v(\widehat{x }_i,s_i)\|$ 表示在近似轨迹当前状态上的局部缓存误差。

先在更新差值中加减 $v(\widehat{x }_i,s_i)$，把“缓存误差”和“输入状态不同”分开。再使用三角不等式，并假设 $v$ 对状态的 Lipschitz 常数为 $L$，得到：

$$e_{i+1}\leq(1+\Delta s_iL)e_i+\Delta s_i\eta_i$$

若初始状态相同，则 $e_0=0$。重复代入可得：

$$e_N\leq\sum_{i=0}^{N-1}\Delta s_i\eta_i\prod_{j=i+1}^{N-1}(1+\Delta s_jL)$$

空乘积取 1。这个展开说明早期误差会通过后续更新传播；最后一次强制刷新只能去掉最后一次局部缓存误差，不能恢复此前已经走偏的轨迹。真实系统可能局部收缩，实际误差小于这个上界；高阶求解器还涉及历史预测，不能把 Euler 的式子直接冒充所有采样器的误差定理。

为什么命中率不能直接当加速比

令 $N$ 是总调用数，$K$ 是完整计算数，$C_f$ 是完整调用成本，$C_h$ 是缓存命中调用成本，$C_o$ 是其他固定开销。则一个简单的成本模型是：

$$S=\frac{NC_f+C_o}{KC_f+(N-K)C_h+C_o}$$

命中调用仍要嵌入、判定、读缓存、运行输出头和更新采样器，$C_h$ 不会自动等于零。缓存张量跨设备读取甚至可能很贵。端到端还包括文本编码、VAE 解码和输出处理，跳过 Transformer 并不会同时省掉这些部分。

本文把 $C_f=1$、$C_h=0.08$、$C_o=0$ 当成教学假设。按实跑统计的 $K$ 代入可以算成本比，但没有用这些假设伪装 GPU 计时。部署时需要测出真实成本，再决定缓存是否值得加入。

04. 代码实现

完整脚本是文末的 cache_demo.py，依赖 NumPy 与 matplotlib，无需模型权重。它构造一个四层非线性残差函数，用固定随机种子产生输入和矩阵。输入形状是 $(B,L,D)=(1,4,16)$：一个批次、四个位置、十六个通道。张量使用 float64，目的是让读者稳定复核误差，不模拟混合精度推理。

脚本里的 cheap_input 对应 $E$，residual 对应 $R$，proxy 对应 $m$，budget 对应 $A$，threshold 对应 $\delta$。输出头取恒等映射。每次用当前 $h$ 加缓存残差得到预测，然后执行状态更新。时间标签从 1 递减到 0，而状态更新的步长固定为 $1/N$；这只是合成系统的定义，没有冒充 DDIM 或真实扩散调度器。

决策的核心代码如下；变量准备、精确对照、绘图及断言都在完整附录中：

budget += max(change, 0.0)
boundary = i in (0, STEPS - 1)
calculate = boundary or budget >= threshold
if calculate:
    saved_residual = residual(h, t)
    budget = 0.0
output = h + saved_residual

首次调用没有缓存，所以必须完整算。最后一次强制刷新属于本实现的策略。previous_proxy 每一步都更新，saved_residual 只有刷新时更新：把这两件事混淆，就会把“相邻变化累计”写成另一种算法。simulate 每次创建新的状态，避免后一条请求接着用前一条请求的残差。

为了画误差曲线，脚本还在每个步骤额外执行一次精确函数作为离线诊断。这些额外执行没有算进策略的 full_calls；因此实际运行这个带诊断的脚本并不是加速测速。计数回答的是策略本来会执行多少次昂贵计算，图回答的是当前近似轨迹上的局部输出误差有多大。

真实运行环境为 Python 3.11.9、NumPy 2.4.3。基线终点的元素范围为 [-0.791508, 0.614856]。输出如下：

shape=(1, 4, 16), steps=40, seed=7
baseline_range=[-0.791508, 0.614856]
name full_calls hits endpoint_relative_error assumed_speed_ratio
exact 40 0 0.000000 1.000
adaptive_0.08 18 22 0.004939 2.024
adaptive_0.16 11 29 0.008222 3.003
adaptive_0.32 7 33 0.026326 4.149
uniform_4 11 29 0.008672 3.003
All assertions passed; figure=figures/cache_schedule.png

终点相对误差的定义是近似终点与精确终点之差的 L2 范数，除以精确终点的 L2 范数。因此 0.008222 是这个定义下约 0.8222% 的差异，不是 VBench 下降，也不是图像中有 0.8222% 的像素出错。最后一列来自前节假设的成本模型，没有真实延迟单位。

图上半部分每个方块表示一次完整残差计算，空缺表示复用；下半部分是离线诊断得到的局部输出 L2 误差。请先观察刷新是否集中在同一段，再看复用之间误差如何变化。曲线没有用感知质量指标，纵轴不能解读成画面可接受程度。配图由附录脚本生成，数据与上述输出来自同一次实验。

阈值 0.16 与固定间隔 4 都执行了 11 次完整计算，但终点误差略有差异。这是“同样预算也会因刷新位置不同而得到不同结果”的一个实例。它只有一个种子和一个人工系统，不能证明自适应策略在所有输入上优于固定间隔，更不能作为统计显著性结论。

05. 工业级实现对照

DeepCache 原文第 3.3 节 利用 U-Net 的分支结构：当前浅层特征继续更新，较深分支的高层特征从缓存取回并拼接。它缓存的是特定网络位置的特征，并非本文抽象的整段残差。官方 horseee/DeepCache 的 deepcache.py 提供 forward 包装与状态复位；对照时应先找缓存边界，再判断到底省掉了哪些模块。

TeaCache 的 HunyuanVideo 示例 中，teacache_forward 用时间调制后的输入计算变化代理，累计重标定后的变化，并保存 Transformer 主体的输入输出残差。首尾调用完整计算，命中后把旧残差加到当前图像嵌入上；输出层仍然运行。这里对应的是 2026-10-05 实际取回的源码，后续上游重构需要重新核对。

教学版与上述示例的差异很明确：教学版没有文本分支、真实 patchify、注意力或权重，也没有拟合官方多项式；它只验证预算与残差状态机。真实代码还可能把张量变化转成 CPU 标量，这种同步的代价不能从“指标计算量很小”中自动排除。需要把判定开销也纳入测量。

工程上，缓存状态应属于一次请求，而不是一个可被并发请求共享的随意全局变量。prompt、负向条件、guidance、分辨率、帧数、模型权重或调度器变化时，复用旧状态没有语义依据。只检查张量形状远远不够；两个请求可以形状相同、内容完全不同。失败中断后重新开始生成，也要建立新的缓存生命周期。

若模型采用双分支 CFG，必须考虑条件与无条件分支的缓存分别有效。按 $y=y_u+w(y_c-y_u)$ 写，$y_u$ 与 $y_c$ 分别是无条件和条件预测，$w$ 是 guidance 系数。预测误差满足：

$$\|\Delta y\|\leq |w|\|\Delta y_c\|+|1-w|\|\Delta y_u\|$$

因此较大的 guidance 可能放大分支近似误差。这个式子是代数上的工程分析，不声称所有视频模型都执行双分支 CFG；有些采用蒸馏后的 guidance 条件。接入前要先确认实际预测路径，再决定状态如何隔离。

还要区分采样步和网络调用。调度器可能在一个名义步里求值多次，或重访相同的时间标签。缓存的计数器应跟随真实调用语义。如果只拿界面上显示的步数当数组长度，很容易在错误的位置刷新，或者提前把状态清零。应记录每次实际调用的时间标签、是否刷新和缓存来源，再与调度器对齐。

06. 代价与边界

省的是昂贵模块重复计算，增加的是缓存内存、生命周期管理、判定开销和近似误差。保存一个形状为 $(B,L,D)$ 的残差张量，最低存储量为 $BLDb$ 字节，其中 $b$ 是每个元素的字节数；克隆的输入、多个分支及其他缓存还会额外占空间。长视频中 token 数很大，省算力并不自动省显存。

阈值没有通用刻度。代理的归一化方式、拟合数据、模型层、时间条件与采样器都影响其意义。在某模型上有效的多项式可能在另一个模型或调度器上失配。应在目标分布上先记录输入代理与真实残差变化的对应关系，再评估误判，不能只沿用别人仓库里的常数。

端点刷新是一种保守策略，不是一种证明。即使最后一次完整计算，网络读到的潜变量也已经经过缓存轨迹；它不能把积累误差自动洗掉。判断质量时要看整段生成结果，尤其是动作连续性、物体身份、细节与提示词对应关系，而不是只看最后一个调用的缓存误差归零。

已有很少采样步的蒸馏模型可能没有多少安全的复用空间。短轨迹上每次预测都更重要，进一步减少完整网络调用可能迅速损害质量。动态改变条件的交互式生成、频繁切换控制信号的任务，也不应默认共享同一段缓存。先建立可靠基线，才能判断具体组合是否值得部署。

评测时固定权重、prompt、种子、分辨率、帧数、采样器和 guidance，分别测完整网络计算时间与端到端延迟。预热、设备同步、重复测量和尾延迟都要说明；不要把首次编译的基线与已预热的缓存版放在一起比较。质量样例应包含快速运动、镜头切换、文字、遮挡和多主体交互等容易暴露近似问题的内容。

本文给出的误差曲线只能帮助理解缓存的数值行为。没有真实模型权重，没有样本集，也没有测量硬件延迟。因此本文不提供生产阈值，不给出“无损”的结论，也不声称这些 toy 误差能预测真实视频的主观质量。

还要分别检查代理误判的两种代价。代理高估变化会增加完整计算，主要损失效率；代理低估变化会继续使用陈旧残差，主要增加质量风险。这两种错误不能只用一个平均相关系数概括。即使整体相关性很高，少数快速变化的步骤被漏掉，也可能成为最明显的失败样例。应保留逐步记录，把异常视频定位到具体刷新区间，再判断是代理不敏感、阈值过大还是缓存位置选错。

为避免测试集上的阈值被过度优化，可以先用一组提示词选择阈值，再在另一组提示词上固定参数评估。报告平均质量以外，还要记录最差样例以及变化最大的场景。缓存有时能带来某项评分的小幅上升，但近似轨迹改变本身并不保证改进；应通过更多独立样本判断这是随机波动还是稳定效果。不能挑出一段更好看的视频，就把整条路线称作质量提升技术。

缓存决策在不同请求中可能产生不同的完整计算次数，所以服务端延迟也会随内容变化。只报告平均命中率，会遮蔽慢请求的行为；应同时关注完整计算次数的分布和尾延迟。如果业务要求固定延迟，可以限制最长复用间隔或最低刷新次数，但这些额外约束需要重新纳入成本账本与质量验证。

07. 经典论文脉络

• DDIM：Denoising Diffusion Implicit Models，2010.02502。它提供理解不同采样路径的基础；跨步缓存要先说明是否保留原有离散调用，再比较误差，不能把省模块与改步长混为一谈。
• DeepCache，2312.00858。它把 U-Net 高层特征的跨步复用转成免训练加速方案，主要启发是选择合适的结构边界，而不是对所有中间张量一概缓存。
• Pyramid Attention Broadcast，2408.12588。它把视频生成中的注意力复用纳入设计，提示我们不同模块可以有不同刷新节奏。本文只把它作为技术脉络，不复现其性能结果。
• TeaCache，2411.19108。它用时间调制输入的变化代理和重标定来选择刷新时刻，把问题从固定周期推进到输入感知的缓存决策。

论文数值也要带条件。DeepCache 的摘要报告 SD v1.5 上 2.3 倍加速与 CLIP Score 下降 0.05；这是作者特定设置下的结果，不能泛化成所有扩散模型都同样受益。原始摘要 支持这组数字。

TeaCache v2 的表 1 中，OpenSora-Plan、65 帧、512×512 的基线延迟为 99.65 秒，slow 配置为 22.62 秒，对应 4.41 倍；VBench 从 80.39% 到 80.32%，差值是 0.07 个百分点。fast 配置在同表报告更高加速，但质量也有不同取舍，所以本文引用 slow 配置，避免把不同配置的最优速度与最优质量拼成一个结果。原文表 1 可直接复核。

这些工作属于相关路线，没有一个统一的阈值或通用缓存张量。先检查缓存边界，再看刷新规则，最后检查采样路径是否改变，是比较它们时更稳定的顺序。方法名称相似、都声称免训练，不代表工程实现可以直接互换。

08. 常见误解

“跨步缓存与 KV cache 是同一种精确复用。” 自回归 KV cache 通常复用固定前缀的计算结果，而扩散过程中潜变量和时间条件在变化。这里复用的是可能陈旧的近似特征，必须单独评估误差。是否等价还取决于模型路径，不能仅凭有个 cache 字段就判断。

“相邻特征相似，所以可以一直复用。” 相邻相似不等于相隔很多步仍相似，更不等于输出质量不变。累计预算关注缓存年龄，刷新机制关注何时恢复完整计算。二者缺一不可。

“阈值 0.16 表示允许 16% 的质量损失。” 阈值只是累计代理的比较值。它不是终点误差、FID、VBench 或主观质量的直接比例。本实验阈值与官方多项式的阈值甚至不在相同刻度上。

“缓存命中后跳过了采样器更新。” 本文所有版本都更新状态 40 次。省掉的是一部分网络计算，当前输入与输出头仍然可以变化。如果代码命中后直接跳过调度器，它执行的是另一种算法。

“最后一次完整计算能补回前面所有误差。” 最后一次局部预测变准确，不等于输入轨迹回到基线。误差传播推导和实验都把这两件事区分开。

“调用次数少三倍，就是端到端快三倍。” 命中步骤、其他固定模块、同步与内存操作仍有成本。本文最后一列只是显式假设的成本比，实际脚本还带额外离线诊断，因此不能拿它的运行时间当加速报告。

09. 动手验证

先把附录完整代码保存为 cache_demo.py，准备 Python 3.10 以上环境，执行：

python -m pip install numpy matplotlib
python cache_demo.py

脚本按照所在目录生成实验结果文件和 figures/cache_schedule.png。数值应与第 04 节一致；换 NumPy 或底层数值库时，浮点尾数可能略有不同。比对完整计算次数、刷新时刻和误差到所列精度，比要求截图或图片压缩字节完全一致更合适。

首先把阈值设成 0。每个步骤都会刷新，完整计算次数应等于 40，终点应与精确基线逐元素一致。附录已经用断言验证这个条件；如果失败，要先修缓存状态机，不要调阈值掩盖问题。

其次比较 0.08、0.16 和 0.32。在本次固定实验里，完整计算次数逐步减少，终点误差逐步增加。这是一个具体样本的趋势，不是所有系统的单调性定理：刷新位置改变、误差相互抵消、轨迹分叉，都可能让某个中间阈值的结果反而更接近基线。

再比较 adaptive_0.16 与 uniform_4。两者的成本模型使用相同的 11 次完整计算，但时刻并不相同。观察图中误差峰值，不只盯终点一个数。如果想研究预算分配，固定计算次数，再调整刷新位置，比仅仅换一个阈值更容易把原因看清。

最后修改种子或残差函数中时间变化的频率，重新运行整套对照，并保留新的输出。这一操作没有本文预先承诺的性能结果；它用来观察原先代理是否仍能判断残差变化。若输入代理很平缓、真实残差突然变化，就能构造“指标漏报”的反例。把反例加入测试，比只展示一条顺利的曲线更有价值。

实际接入模型之前，还应验证两次独立请求是否有相同基线行为、错误中断是否清理状态、同形状不同条件是否互相污染。本文实验用每次 simulate 独立初始化来验证复位；真实服务还需要针对并发与重入的检查。

10. 延伸阅读

先从 DDIM 与高阶采样器 理解调用路径，再用 DiT 找嵌入、主体和输出头的边界，最后通过 性能建模与 Profiling 实测哪些部分值得省。

可以对照 KV cache 理解缓存有效性，也可继续读 量化 比较另一种减少推理成本的方法。知识树中的少步蒸馏节点仍为 planned；它是下一条相关学习路线，尚无已发布链接。跨步缓存、量化与蒸馏组合时，应重新建立质量和延迟基线。

附录：完整代码

09 节用到的脚本全文如下（cache_demo.py）。复制到本地存成同名文件，按各脚本开头的依赖说明准备环境后即可运行。

cache_demo.py

"""Deterministic residual-cache toy; Python 3.10+, pip install numpy matplotlib.
Run: python cache_demo.py
No trained diffusion weights; cost ratios below are accounting assumptions.
"""
from pathlib import Path
import json
import platform
import numpy as np
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt

STEPS = 40
SHAPE = (1, 4, 16)
SEED = 7
rng = np.random.default_rng(SEED)
X0 = rng.normal(size=SHAPE).astype(np.float64)
W = rng.normal(size=(16, 16)) / 8.0
V = rng.normal(size=(16, 16)) / 8.0

def cheap_input(x, t):
    return x + 0.05 * np.sin(2 * np.pi * t)

def proxy(h, t):
    return h * (1 + 0.3 * np.sin(2 * np.pi * t)) + 0.1 * np.cos(2 * np.pi * t)

def residual(h, t):
    z = h
    for _ in range(4):
        z = np.tanh(z @ W)
    return 0.15 * h + 0.4 * (z @ V) + 0.08 * np.sin(6 * np.pi * t)

def simulate(threshold=None, period=None):
    x = X0.copy()
    previous_proxy = None
    saved_residual = None
    budget = 0.0
    refreshed, local_errors = [], []
    for i in range(STEPS):
        t = 1.0 - i / (STEPS - 1)
        h = cheap_input(x, t)
        m = proxy(h, t)
        change = 0.0 if previous_proxy is None else float(
            np.mean(np.abs(m - previous_proxy)) / max(np.mean(np.abs(previous_proxy)), 1e-12))
        budget += max(change, 0.0)
        boundary = i in (0, STEPS - 1)
        if threshold is None and period is None:
            calculate = True
        elif period is not None:
            calculate = boundary or i % period == 0
        else:
            calculate = boundary or budget >= threshold
        if calculate:
            saved_residual = residual(h, t)
            budget = 0.0
        output = h + saved_residual
        # Offline diagnostic only; extra evaluation is excluded from work accounting.
        exact = h + residual(h, t)
        local_errors.append(float(np.linalg.norm(output - exact)))
        refreshed.append(bool(calculate))
        previous_proxy = m.copy()
        x = x - output / STEPS
    return {"x": x, "refreshed": refreshed, "local_errors": local_errors}

def experiment():
    baseline = simulate()
    rows = []
    results = []
    settings = [("exact", None, None), ("adaptive_0.08", 0.08, None),
                ("adaptive_0.16", 0.16, None), ("adaptive_0.32", 0.32, None),
                ("uniform_4", None, 4)]
    for name, threshold, period in settings:
        result = simulate(threshold, period)
        calls = sum(result["refreshed"])
        relative_error = float(np.linalg.norm(result["x"] - baseline["x"]) / np.linalg.norm(baseline["x"]))
        # Full call = 1 unit; cache hit = 0.08 unit, solely for illustration.
        assumed_work = calls + (STEPS - calls) * 0.08
        rows.append({"name": name, "full_calls": calls, "hits": STEPS - calls,
                     "relative_endpoint_error": relative_error,
                     "assumed_speed_ratio": STEPS / assumed_work,
                     "refresh_indices": [i for i, flag in enumerate(result["refreshed"]) if flag]})
        results.append(result)
    zero = simulate(threshold=0.0)
    assert np.array_equal(zero["x"], baseline["x"])
    assert sum(zero["refreshed"]) == STEPS
    assert all(r["refreshed"][0] and r["refreshed"][-1] for r in results)
    assert np.array_equal(simulate(threshold=0.16)["x"], results[2]["x"])
    assert all(np.isfinite(r["x"]).all() for r in results)
    return rows, results, baseline

def make_figure(rows, results, destination):
    fig, axes = plt.subplots(2, 1, figsize=(11, 7), constrained_layout=True)
    colors = ["#2563eb", "#ea580c", "#16a34a", "#dc2626", "#9333ea"]
    for y, (row, result) in enumerate(zip(rows, results)):
        idx = np.flatnonzero(result["refreshed"])
        axes[0].scatter(idx, np.full(len(idx), y), marker="s", s=38, color=colors[y])
    axes[0].set_yticks(range(len(rows)), [r["name"] for r in rows])
    axes[0].set_xlim(-1, STEPS)
    axes[0].set_xlabel("Sampling call index (0-based)")
    axes[0].set_title("Squares = full residual computation; gaps = cache reuse")
    for y, (row, result) in enumerate(zip(rows[1:], results[1:]), start=1):
        axes[1].plot(result["local_errors"], label=row["name"], linewidth=1.7, color=colors[y])
    axes[1].set_xlabel("Sampling call index (0-based)")
    axes[1].set_ylabel("Local output L2 error")
    axes[1].set_title("Offline diagnostics on each cached trajectory; no quality metric")
    axes[1].legend(ncol=2, fontsize=9)
    axes[1].grid(alpha=0.25)
    fig.suptitle("Residual caching: refresh decisions and approximation error", fontsize=14)
    fig.savefig(destination, dpi=150)
    plt.close(fig)

if __name__ == "__main__":
    rows, results, baseline = experiment()
    folder = Path(__file__).resolve().parent.parent
    (folder / "figures").mkdir(parents=True, exist_ok=True)
    make_figure(rows, results, folder / "figures" / "cache_schedule.png")
    record = {"seed": SEED, "steps": STEPS, "shape": list(SHAPE),
              "python": platform.python_version(), "numpy": np.__version__,
              "baseline_min": float(baseline["x"].min()),
              "baseline_max": float(baseline["x"].max()), "results": rows,
              "assertions": "zero-threshold exactness, endpoints, request reset, finite outputs passed"}
    (folder / "experiment_results.json").write_text(
        json.dumps(record, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
    print(f"shape={SHAPE}, steps={STEPS}, seed={SEED}")
    print(f"baseline_range=[{record['baseline_min']:.6f}, {record['baseline_max']:.6f}]")
    print("name full_calls hits endpoint_relative_error assumed_speed_ratio")
    for row in rows:
        print(f"{row['name']} {row['full_calls']} {row['hits']} "
              f"{row['relative_endpoint_error']:.6f} {row['assumed_speed_ratio']:.3f}")
    print("All assertions passed; figure=figures/cache_schedule.png")