LeMiCa: Efficient Diffusion Video Caching

• LeMiCa is a training-free and globally optimized cache scheduler that accelerates diffusion-based video generation by formulating cache reuse as a lexicographic minimax path selection problem.
• It uses a static, outcome-aware error graph to globally optimize cache scheduling, thereby minimizing worst-case cache segment errors across the full denoising trajectory.
• LeMiCa distinctively outperforms local heuristic methods by balancing speed and fidelity through systematic cache refreshing, as demonstrated in multiple diffusion models.

Searching arXiv for LeMiCa and closely related diffusion caching papers to ground the article and disambiguate terminology. Searching for "LeMiCa diffusion video generation". LeMiCa is a training-free acceleration framework for diffusion-based video generation that formulates cache scheduling as a path-selection problem in an error-weighted directed acyclic graph and solves it with a lexicographic minimax criterion to bound worst-case cache-segment error while preserving global content and style consistency (Gao et al., 30 Oct 2025). In the supplied literature, the name also requires terminological disambiguation: a separate paper on parameter-efficient fine-tuning uses only the term MiCA, not LeMiCa, and explicitly states that “LeMiCa” likely refers to MiCA only in that specific contextual misunderstanding (Rüdiger et al., 2 Apr 2026). In the strict sense established by the paper titled "LeMiCa: Lexicographic Minimax Path Caching for Efficient Diffusion-Based Video Generation," LeMiCa denotes a globally optimized cache scheduler for diffusion trajectories in text-to-video and related generative settings (Gao et al., 30 Oct 2025).

1. Terminology and problem setting

LeMiCa is defined as a training-free and efficient acceleration framework for diffusion-based video generation (Gao et al., 30 Oct 2025). It operates in the context of text-to-video diffusion models such as Open-Sora, Latte, and CogVideoX, where generation proceeds by iterative denoising from $x_T$ to $x_0$, and each denoising step requires a heavy UNet or DiT forward pass with attention and MLP blocks over all space-time tokens (Gao et al., 30 Oct 2025). Within this setting, caching refers to the reuse of intermediate computations between nearby timesteps in order to avoid redundant forward passes when successive hidden states remain similar (Gao et al., 30 Oct 2025).

The paper positions LeMiCa against prior caching strategies that make stepwise decisions using local heuristics, including approaches such as TeaCache and PAB (Gao et al., 30 Oct 2025). The stated concern is that such local triggers focus on reducing local heuristic errors while overlooking the accumulation of global errors, which can produce content degradation between accelerated and original videos (Gao et al., 30 Oct 2025). The central premise of LeMiCa is therefore that cache scheduling should be optimized over the entire denoising trajectory rather than selected greedily at individual steps (Gao et al., 30 Oct 2025).

A separate nomenclature issue arises because the supplied corpus also includes "MiCA Learns More Knowledge Than LoRA and Full Fine-Tuning," which concerns Minor Component Adaptation for LLMs and explicitly clarifies that the paper uses only the term MiCA, not LeMiCa (Rüdiger et al., 2 Apr 2026). This suggests that references to “LeMiCa” should ordinarily be interpreted as the diffusion-video caching method unless context clearly indicates the unrelated MiCA fine-tuning method.

2. Cache reuse in diffusion video generation

In diffusion-based video generation, each denoising step processes all frames jointly, so step-level acceleration affects the full video trajectory (Gao et al., 30 Oct 2025). The paper identifies several practical forms of caching: attention KV reuse, caching DiT or UNet block outputs or intermediate feature maps, and periodic recomputation or “refreshing” to prevent excessive drift (Gao et al., 30 Oct 2025). LeMiCa is model-agnostic in this sense: for DiT-based video models it can cache per-block outputs and attention KV tensors across space-time tokens, and for UNet-based backbones it can cache feature maps at selected blocks and attention KV (Gao et al., 30 Oct 2025).

The motivating critique is that naive or local caching assumes uniform temporal sensitivity across denoising steps, whereas diffusion trajectories are temporally heterogeneous: early steps establish structure, later steps refine details (Gao et al., 30 Oct 2025). Under this view, even many individually small reuse decisions can compound into perceptible global deviations such as object drift and texture loss (Gao et al., 30 Oct 2025). LeMiCa responds by treating cache scheduling as a globally constrained optimization problem whose objective is tied to final reconstruction quality rather than adjacent-step smoothness (Gao et al., 30 Oct 2025).

The method is also explicitly training-free: it requires no finetuning and no model modification beyond exposing hooks for cache recording and replay (Gao et al., 30 Oct 2025). A single offline DAG is built for each model configuration, meaning architecture, scheduler, resolution, and step schedule (Gao et al., 30 Oct 2025). This places LeMiCa in the class of static policy methods rather than runtime policy-learning systems.

3. Error modeling and graph construction

A central distinction in LeMiCa is the difference between local and global error modeling. The paper describes a common local trigger used by prior work as

$$L1_{\text{rel}}(O,t)=\frac{\|O_t-O_{t+1}\|_1}{\|O_{t+1}\|_1},$$

where high values favor recomputation and low values favor reuse (Gao et al., 30 Oct 2025). This local criterion treats all timesteps alike and does not account for the downstream amplification of errors (Gao et al., 30 Oct 2025).

LeMiCa instead defines a Global Outcome-Aware metric for a cache segment $(i,j)$ by performing full inference at the segment endpoints while reusing cached states for intermediate steps and measuring the final reconstruction error:

$$L1_{\text{glob}}(i \to j)=\frac{1}{N}\|x_0^{\text{cache}(i\to j)}-x_0^{\text{original}}\|_1.$$

Here, $x_0^{\text{original}}$ is produced without caching, $x_0^{\text{cache}(i\to j)}$ is produced when the segment is cached, and $N$ normalizes by the number of pixels or tokens (Gao et al., 30 Oct 2025). The paper reports that errors depend strongly on position, with early segments amplifying errors and later segments being safer, which supports the use of global outcome-aware weighting (Gao et al., 30 Oct 2025).

This segment-level error becomes the edge weight in a directed acyclic graph $G=(V,E)$ defined over denoising timesteps (Gao et al., 30 Oct 2025). The nodes are $V=\{0,1,\dots,T\}$, and an edge $x_0$0 with $x_0$1 represents one full refresh at $x_0$2 followed by cache reuse for timesteps in $x_0$3 (Gao et al., 30 Oct 2025). To keep the graph sparse and avoid pathological long-range reuse, only jumps satisfying $x_0$4 are typically included (Gao et al., 30 Oct 2025). Each edge weight is defined as

$x_0$5

estimated offline by running full sampling, replaying segments under cache reuse, and averaging per-segment error over diverse prompts and seeds to produce a static, model-specific DAG (Gao et al., 30 Oct 2025).

A complete source-to-sink path uses exactly $x_0$6 full computes, where $x_0$7 is the refresh budget controlling the speed–fidelity trade-off (Gao et al., 30 Oct 2025). Edges of unit span correspond to no-reuse transitions, whereas edges of span at least $x_0$8 correspond to cached segments (Gao et al., 30 Oct 2025).

4. Lexicographic minimax path optimization

The paper argues that cache errors are non-additive across segments: denoising dynamics amplify early errors and often saturate later errors, so minimizing an additive path cost such as $x_0$9 is suboptimal (Gao et al., 30 Oct 2025). Instead of treating the schedule as a shortest-path problem, LeMiCa defines for each path $$L1_{\text{rel}}(O,t)=\frac{\|O_t-O_{t+1}\|_1}{\|O_{t+1}\|_1},$$0 the multiset of cache-segment errors

$$L1_{\text{rel}}(O,t)=\frac{\|O_t-O_{t+1}\|_1}{\|O_{t+1}\|_1},$$1

where $$L1_{\text{rel}}(O,t)=\frac{\|O_t-O_{t+1}\|_1}{\|O_{t+1}\|_1},$$2 is the subset of edges in $$L1_{\text{rel}}(O,t)=\frac{\|O_t-O_{t+1}\|_1}{\|O_{t+1}\|_1},$$3 with span at least $$L1_{\text{rel}}(O,t)=\frac{\|O_t-O_{t+1}\|_1}{\|O_{t+1}\|_1},$$4 (Gao et al., 30 Oct 2025). The optimization then sorts these errors in nonincreasing order and minimizes them lexicographically over all source-to-sink paths with exactly $$L1_{\text{rel}}(O,t)=\frac{\|O_t-O_{t+1}\|_1}{\|O_{t+1}\|_1},$$5 edges (Gao et al., 30 Oct 2025):

$$L1_{\text{rel}}(O,t)=\frac{\|O_t-O_{t+1}\|_1}{\|O_{t+1}\|_1},$$6

The first coordinate of this sorted vector is the worst cache-segment error, so the first stage is a bottleneck or minimax path problem (Gao et al., 30 Oct 2025). The paper gives the equivalent two-level interpretation: first minimize the maximum cache-edge error, yielding $$L1_{\text{rel}}(O,t)=\frac{\|O_t-O_{t+1}\|_1}{\|O_{t+1}\|_1},$$7; then, among all paths achieving that bottleneck, minimize the second-largest error, then the third-largest, and so on (Gao et al., 30 Oct 2025). This lexicographic refinement is intended to avoid schedules with one catastrophic segment or with multiple moderately large segments that would still degrade global consistency (Gao et al., 30 Oct 2025).

The method therefore differs from local thresholding and from additive shortest-path formulations in two ways. First, it optimizes against end-to-end impact on $$L1_{\text{rel}}(O,t)=\frac{\|O_t-O_{t+1}\|_1}{\|O_{t+1}\|_1},$$8 rather than adjacent-step deltas (Gao et al., 30 Oct 2025). Second, it explicitly controls the worst cache segment first, then refines uniformity among the remaining segments (Gao et al., 30 Oct 2025). The paper states that the shortest-path alternative underperforms the minimax formulation in ablations, which it interprets as evidence that worst-case segment control is a better surrogate for perceived degradation than additive accumulation (Gao et al., 30 Oct 2025).

5. Algorithmic procedure and runtime schedule

The LeMiCa algorithm takes as input the DAG $$L1_{\text{rel}}(O,t)=\frac{\|O_t-O_{t+1}\|_1}{\|O_{t+1}\|_1},$$9, a source $(i,j)$0, a sink $(i,j)$1, edge weights $(i,j)$2, and a step budget $(i,j)$3 (Gao et al., 30 Oct 2025). The first stage is dynamic programming for the bottleneck objective. The state

$(i,j)$4

stores the minimal achievable bottleneck to reach node $(i,j)$5 using exactly $(i,j)$6 edges, and transitions along an edge $(i,j)$7 update

$(i,j)$8

for $(i,j)$9 (Gao et al., 30 Oct 2025). The stated complexity of this stage is $$L1_{\text{glob}}(i \to j)=\frac{1}{N}\|x_0^{\text{cache}(i\to j)}-x_0^{\text{original}}\|_1.$$0 (Gao et al., 30 Oct 2025).

The second stage handles lexicographic tie-breaking. For nodes with identical bottleneck values, the method maintains backpointers, reconstructs all tied paths or a pruned subset, computes the sorted error vector for each path, and selects the lexicographically minimal one (Gao et al., 30 Oct 2025). The paper notes that this remains efficient in practice because the candidate set of tied paths is small in a sparse DAG with $$L1_{\text{glob}}(i \to j)=\frac{1}{N}\|x_0^{\text{cache}(i\to j)}-x_0^{\text{original}}\|_1.$$1 constraints (Gao et al., 30 Oct 2025).

At runtime, each edge $$L1_{\text{glob}}(i \to j)=\frac{1}{N}\|x_0^{\text{cache}(i\to j)}-x_0^{\text{original}}\|_1.$$2 on the chosen path specifies a concrete cache schedule: fully recompute at timestep $$L1_{\text{glob}}(i \to j)=\frac{1}{N}\|x_0^{\text{cache}(i\to j)}-x_0^{\text{original}}\|_1.$$3, invalidate previous caches, reuse cached states for timesteps $$L1_{\text{glob}}(i \to j)=\frac{1}{N}\|x_0^{\text{cache}(i\to j)}-x_0^{\text{original}}\|_1.$$4, and then perform the next full refresh at $$L1_{\text{glob}}(i \to j)=\frac{1}{N}\|x_0^{\text{cache}(i\to j)}-x_0^{\text{original}}\|_1.$$5 as determined by the following path edge (Gao et al., 30 Oct 2025). Larger $$L1_{\text{glob}}(i \to j)=\frac{1}{N}\|x_0^{\text{cache}(i\to j)}-x_0^{\text{original}}\|_1.$$6 implies more refreshes, higher fidelity, and lower acceleration; smaller $$L1_{\text{glob}}(i \to j)=\frac{1}{N}\|x_0^{\text{cache}(i\to j)}-x_0^{\text{original}}\|_1.$$7 implies fewer refreshes, higher speed, and greater approximation (Gao et al., 30 Oct 2025).

The implementation guidance provided in the paper organizes deployment into offline edge-weight estimation, DAG construction and optimization, and runtime execution (Gao et al., 30 Oct 2025). Integration requires hooks to record intermediate states and to bypass recomputation by injecting recorded states during cached steps (Gao et al., 30 Oct 2025). The offline estimation phase selects candidate edges with bounded jump length, runs full denoising for a small prompt-and-seed set, replays candidate segments with cache reuse, computes $$L1_{\text{glob}}(i \to j)=\frac{1}{N}\|x_0^{\text{cache}(i\to j)}-x_0^{\text{original}}\|_1.$$8 for each segment, and averages these values into a static DAG (Gao et al., 30 Oct 2025). The paper states that performance saturates around 10–20 samples for DAG construction (Gao et al., 30 Oct 2025).

6. Empirical results, ablations, and operating regimes

The reported evaluation covers Open-Sora 1.2 with 51 frames at 480p, Latte with 16 frames at $$L1_{\text{glob}}(i \to j)=\frac{1}{N}\|x_0^{\text{cache}(i\to j)}-x_0^{\text{original}}\|_1.$$9, and CogVideoX with 49 frames at 480p, using NVIDIA H100 hardware and PyTorch (Gao et al., 30 Oct 2025). Quality metrics include VBench human preference, LPIPS, SSIM, and PSNR; efficiency metrics include FLOPs, latency, and speedup (Gao et al., 30 Oct 2025).

The paper reports two default budgets per model, labeled “slow” and “fast.” For Open-Sora 1.2 with an original 30-step schedule, LeMiCa-slow uses $x_0^{\text{original}}$0 and LeMiCa-fast uses $x_0^{\text{original}}$1; for Latte with original 50 steps, LeMiCa-slow uses $x_0^{\text{original}}$2 and LeMiCa-fast uses $x_0^{\text{original}}$3; for CogVideoX with original 50 steps, LeMiCa-slow uses $x_0^{\text{original}}$4 and LeMiCa-fast uses $x_0^{\text{original}}$5 (Gao et al., 30 Oct 2025).

The principal numerical results are summarized below.

Model	Setting	Reported result
Open-Sora 1.2	LeMiCa-slow	1.52× speedup; LPIPS 0.050; SSIM 0.923; PSNR 31.32
Open-Sora 1.2	LeMiCa-fast	2.44× speedup; LPIPS 0.187; SSIM 0.798; PSNR 21.76
Latte	LeMiCa-fast	2.93× speedup
Latte	LeMiCa-slow	LPIPS 0.091; SSIM 0.865; PSNR 27.65
CogVideoX	LeMiCa-fast	2.61× speedup
CogVideoX	LeMiCa-slow	LPIPS 0.023; SSIM 0.958; PSNR 35.93

The abstract highlights a 2.9× speedup on Latte and an LPIPS score of 0.05 on Open-Sora, with minimal perceptual quality degradation (Gao et al., 30 Oct 2025). In the detailed results, Open-Sora 1.2 achieves up to 2.44× speedup in the fast setting, while Latte reaches 2.93× speedup and CogVideoX reaches 2.61× speedup in the fast setting (Gao et al., 30 Oct 2025). The paper further states that LeMiCa outperforms TeaCache at matched speed–fidelity trade-offs and delivers better quality than shortest-path scheduling in ablations, for example reporting PSNR 24.67 versus 22.90 for minimax versus shortest path (Gao et al., 30 Oct 2025).

Several additional ablations are reported. Sample efficiency for DAG construction converges rapidly, with metrics nearly saturated by 10–20 prompts and only slight gains from a full 350-sample DAG (Gao et al., 30 Oct 2025). The method remains favorable under scheduler trajectory scale variations from 0.5 to 1.5 and maintains stable speedups on longer or higher-resolution videos when combined with Dynamic Sequence Parallelism (Gao et al., 30 Oct 2025). The offline cost is reported as approximately 3.18 minutes per prompt for edge-weight estimation, with DAG construction taking less than 1 second and lexicographic minimax search taking less than 1 second; these steps are parallelizable and incur no online overhead beyond executing the chosen schedule (Gao et al., 30 Oct 2025).

The paper also reports extension beyond video: on Qwen-Image, LeMiCa achieves 2.45×–3.37× speedups with strong perceptual metrics and is competitive with or better than Cache-DiT at matched speeds (Gao et al., 30 Oct 2025). This suggests that the path-optimization formulation is not inherently restricted to video generation, although the principal development is framed around diffusion-based video models.

7. Significance, limitations, and disambiguation from MiCA

The methodological significance of LeMiCa lies in replacing local heuristic cache triggers with a global optimization objective defined over a static, outcome-aware error graph (Gao et al., 30 Oct 2025). The paper’s theoretical statement is that if $x_0^{\text{original}}$6 is the chosen path and $x_0^{\text{original}}$7, then $x_0^{\text{original}}$8; accordingly, no other budget-$x_0^{\text{original}}$9 schedule can guarantee a smaller worst-segment error (Gao et al., 30 Oct 2025). This does not imply elimination of degradation under aggressive acceleration, but it does provide an explicit worst-segment bound and a structured refinement of error uniformity (Gao et al., 30 Oct 2025).

The limitations are also clearly stated. LeMiCa depends on the quality of the base model: if the underlying model struggles with complex motion or weak temporal priors, high acceleration will still degrade quality (Gao et al., 30 Oct 2025). Extremely aggressive budgets with very small $x_0^{\text{cache}(i\to j)}$0 can produce visible artifacts despite lexicographic control (Gao et al., 30 Oct 2025). The DAG is configuration-specific, tied to architecture, scheduler, resolution, and other generation settings, so lightweight transfer or meta-DAG constructions are left as possible improvements (Gao et al., 30 Oct 2025).

LeMiCa is also described as compatible with quantization, pruning, distillation, and parallelism because it determines when to compute, whereas those techniques reduce the cost of each compute (Gao et al., 30 Oct 2025). This suggests a modular role within broader acceleration stacks rather than a replacement for other efficiency methods.

Finally, the term should be carefully distinguished from MiCA. MiCA, in "MiCA Learns More Knowledge Than LoRA and Full Fine-Tuning," is a parameter-efficient fine-tuning method for LLMs that constrains adaptation to minor singular directions identified by SVD and is unrelated to diffusion cache scheduling (Rüdiger et al., 2 Apr 2026). The supplied material explicitly notes that the paper uses only the term MiCA and that “LeMiCa” likely refers to MiCA only in a contextual mislabeling (Rüdiger et al., 2 Apr 2026). In contemporary usage grounded in the cited paper, LeMiCa properly denotes Lexicographic Minimax Path Caching for efficient diffusion-based video generation (Gao et al., 30 Oct 2025).