🔥 News

• 2026/04/29 🎉 L2P is accepted by CVPR 2026! Paper is available on arXiv.
• 2026/07/13 🚀 L2P-FLUX code is released — FLUX.1-dev inference, weight training, and evaluation scripts.
• Coming soon 🔜 L2P for Qwen-Image and HunyuanVideo, along with full experiment reproduction.

📋 Table of Contents

• Abstract
• Highlights
• Method
• Main Results
• Roadmap
• Installation
• Quick Start
• Usage
• Project Structure
• Acknowledgements
• Citation

📖 Abstract

To address the high sampling cost of Diffusion Transformers (DiTs), feature caching offers a training-free acceleration method. However, existing methods rely on hand-crafted forecasting formulas that fail under aggressive skipping.

We propose L2P (Learnable Linear Predictor), a simple data-driven caching framework that replaces fixed coefficients with learnable per-timestep weights. Rapidly trained in ~20 seconds on a single GPU, L2P accurately reconstructs current features from past trajectories.

L2P significantly outperforms existing baselines: it achieves a 4.55× FLOPs reduction and 4.15× latency speedup on FLUX.1-dev, and maintains high visual fidelity under up to 7.18× acceleration on Qwen-Image models, where prior methods show noticeable quality degradation.

✨ Highlights

🔬 Method

At each denoising step, L2P maintains a history of past output features. On cache steps, instead of running the full transformer, L2P predicts the current feature as a causal linear combination of history — weights are per-timestep and learned from data.

flowchart LR
    A[Past Features<br/>x₀, x₁, …, xₜ₋₁] --> B[Learnable Weights<br/>Wₜ · lower-triangular]
    B --> C[Predicted Feature x̂ₜ]
    C --> D[Skip Transformer]

    E[Full Step] --> F[Run Transformer]
    F --> G[Update History]
    G --> A

Training objective: minimize MSE between predicted and ground-truth features over denoising trajectories. The weight matrix is lower-triangular (causal) and shared across spatial tokens after FFT decomposition.

📊 Main Results

FLUX.1-dev (this repo)

Qwen-Image (coming soon)

Full benchmark tables, Geneval / ImageReward / DrawBench numbers, and comparison with TaylorSeer, ToCa, FORA will be released with the complete experiment suite.

🗺️ Roadmap

🛠️ Installation

Requirements

Python >= 3.10
CUDA >= 11.8
PyTorch >= 2.5

Setup

git clone https://github.com/Aredstone/L2P-Cache.git
cd L2P-Cache

python3.10 -m venv .venv
source .venv/bin/activate
pip install -e .

# Optional: PSNR / SSIM / LPIPS evaluation
pip install -e ".[eval]"

Model Weights

Download FLUX.1-dev and set environment variables:

export FLUX_DEV=/path/to/FLUX.1-dev/flux1-dev.safetensors
export AE=/path/to/FLUX.1-dev/ae.safetensors
export FLUX_MODEL_DIR=/path/to/FLUX.1-dev   # optional: local diffusers layout
export HF_HOME=/path/to/huggingface/cache   # optional

Tip: If FLUX_MODEL_DIR points to a diffusers-style folder, T5 (text_encoder_2/) and CLIP (text_encoder/) are loaded locally with their tokenizers. Otherwise they are fetched from HuggingFace.

⚡ Quick Start

Generate images with L2P acceleration on DrawBench200:

export PYTHONPATH=src

python src/sample.py \
  --prompt_file predictor/DrawBench200.txt \
  --output_dir outputs/samples \
  --interval 7 \
  --width 1024 --height 1024 \
  --num_steps 50 \
  --device 0

Compare against full-compute baseline (--interval 1) and evaluate with evaluate.py.

📖 Usage

Inference

export PYTHONPATH=src

python src/sample.py \
  --prompt_file predictor/DrawBench200.txt \
  --output_dir outputs/samples \
  --interval 7 \
  --width 1024 \
  --height 1024 \
  --num_steps 50 \
  --seed 0 \
  --device 0

Supported intervals with tuned step schedules: 5, 6, 7, 8, 10, 16 — see FULL_STEP_SCHEDULES in src/flux/model.py.

python src/geneval_flux.py \
  /path/to/evaluation_metadata.jsonl \
  --model_name flux-dev \
  --steps 50 --width 1024 --height 1024 \
  --output_dir outputs/geneval
``$

</\text{details}>

### \text{Train} \text{Predictor} \text{Weights}

\text{L2P} \text{learns} \text{a} **50 \times 50 \text{lower}-\text{triangular}** \text{weight} \text{matrix} \text{via} \text{MSE} \text{on} \text{feature} \text{trajectories}:

$``bash
python predictor/train.py \
  --weight_path predictor/weight.txt \
  --device cuda:0

# 1. Generate L2P samples
python src/sample.py --interval 7 --output_dir outputs/l2p ...

# 2. Generate baseline samples
python src/sample.py --interval 1 --output_dir outputs/baseline ...

# 3. Compute metrics
python evaluate.py \
  --test_folder outputs/l2p \
  --reference_folder outputs/baseline \
  --prompt_file predictor/DrawBench200.txt

L2P-Cache/
├── src/
│   ├── sample.py                  # Batch inference entry point
│   ├── geneval_flux.py            # GenEval benchmark
│   └── flux/
│       ├── model.py               # L2P integration in FLUX forward
│       ├── learnable_utils/       # Linear predictor (FFT + weight apply)
│       ├── l2p_cache.py           # Step scheduling & cache state
│       └── ideas/cache_denoise.py # Cache-aware denoising loop
├── predictor/
│   ├── train.py                   # Weight training (~20s)
│   ├── weight.txt                 # Pre-trained FLUX weights
│   └── DrawBench200.txt           # Benchmark prompts
├── evaluate.py                    # Quality & alignment metrics
└── README.md

@inproceedings{shen2026l2p,
  title     = {Beyond Fixed Formulas: Data-Driven Linear Predictor for Efficient Diffusion Models},
  author    = {Shen, Zhirong and Huang, Rui and Liu, Jiacheng and Zou, Chang and Cai, Peiliang and Zheng, Shikang and Shi, Zhengyi and Feng, Liang and Zhang, Linfeng},
  booktitle = {Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
  year      = {2026}
}