perf: optional First-Block-Cache "Faster" toggle (~1.4x, A/B-verified near-clean); default off

app.py

@@ -55,6 +55,10 @@ REWRITER_MODEL = os.environ.get("REWRITER_MODEL", "Qwen/Qwen3.6-27B:deepinfra")
 # forward per step on the low-noise tail (~15% fewer transformer forwards).
 # 1.0 disables the optimization (standard CFG on every step).
 CFG_STOP = float(os.environ.get("LINGBOT_CFG_STOP", "0.7"))
+# "Faster" mode: First-Block-Cache (reuse the block-loop residual on steps whose
+# first-block residual barely changes). (threshold, warmup, max_consecutive).
+# A/B-verified at ~1.4x with near-identical quality and no temporal flicker.
+FAST_CACHE = (0.03, 4, 1)
 
 # (height, width), multiples of 16 — official 480p buckets.
 VIDEO_SIZES = {
@@ -292,9 +296,10 @@ def _run_pipe(target, **call_kwargs):
 
 @spaces.GPU(duration=_video_gpu_duration, size="xlarge")
 def _gpu_generate_video(caption, height, width, num_frames, steps, guidance_scale, shift,
-                        negative_prompt, seed, image=None):
+                        negative_prompt, seed, cache=None, image=None):
     target = pipe_i2v if image is not None else pipe
     kwargs = {"image": image} if image is not None else {}
+    thr, warmup, maxc = cache if cache else (None, 4, 1)
     t0 = time.perf_counter()
     output, cfg_mode = _run_pipe(
         target,
@@ -307,6 +312,9 @@ def _gpu_generate_video(caption, height, width, num_frames, steps, guidance_scal
         guidance_scale=float(guidance_scale),
         shift=float(shift),
         guidance_stop=CFG_STOP,
+        fbcache_threshold=thr,
+        fbcache_warmup=warmup,
+        fbcache_max_consecutive=maxc,
         generator=torch.Generator().manual_seed(seed),
         **kwargs,
     )
@@ -325,7 +333,9 @@ def _image_gpu_duration(caption, height, width, steps, *args, **kwargs) -> int:
 
 
 @spaces.GPU(duration=_image_gpu_duration, size="xlarge")
-def _gpu_generate_image(caption, height, width, steps, guidance_scale, shift, negative_prompt, seed):
+def _gpu_generate_image(caption, height, width, steps, guidance_scale, shift, negative_prompt,
+                        seed, cache=None):
+    thr, warmup, maxc = cache if cache else (None, 4, 1)
     t0 = time.perf_counter()
     output, cfg_mode = _run_pipe(
         pipe,
@@ -338,6 +348,9 @@ def _gpu_generate_image(caption, height, width, steps, guidance_scale, shift, ne
         guidance_scale=float(guidance_scale),
         shift=float(shift),
         guidance_stop=CFG_STOP,
+        fbcache_threshold=thr,
+        fbcache_warmup=warmup,
+        fbcache_max_consecutive=maxc,
         generator=torch.Generator().manual_seed(seed),
     )
     torch.cuda.synchronize()
@@ -354,6 +367,7 @@ def generate_t2v(
     steps,
     guidance_scale,
     shift,
+    fast,
     negative_prompt,
     seed,
     randomize_seed,
@@ -367,7 +381,8 @@ def generate_t2v(
     seed = _resolve_seed(seed, randomize_seed)
     caption = _prepare_caption(prompt, "t2v", duration_s, enhance)
     video = _gpu_generate_video(
-        caption, height, width, num_frames, steps, guidance_scale, shift, negative_prompt, seed
+        caption, height, width, num_frames, steps, guidance_scale, shift, negative_prompt, seed,
+        cache=FAST_CACHE if fast else None,
     )
     return video, seed, caption
 
@@ -380,6 +395,7 @@ def generate_i2v(
     steps,
     guidance_scale,
     shift,
+    fast,
     negative_prompt,
     seed,
     randomize_seed,
@@ -396,7 +412,7 @@ def generate_i2v(
     caption = _prepare_caption(prompt, "ti2v", duration_s, enhance, image=image)
     video = _gpu_generate_video(
         caption, height, width, num_frames, steps, guidance_scale, shift, negative_prompt, seed,
-        image=image,
+        cache=FAST_CACHE if fast else None, image=image,
     )
     return video, seed, caption
 
@@ -407,6 +423,7 @@ def generate_t2i(
     steps,
     guidance_scale,
     shift,
+    fast,
     negative_prompt,
     seed,
     randomize_seed,
@@ -417,7 +434,8 @@ def generate_t2i(
     seed = _resolve_seed(seed, randomize_seed)
     caption = _prepare_caption(prompt, "t2i", None, enhance)
     image = _gpu_generate_image(
-        caption, height, width, steps, guidance_scale, shift, negative_prompt, seed
+        caption, height, width, steps, guidance_scale, shift, negative_prompt, seed,
+        cache=FAST_CACHE if fast else None,
     )
     return image, seed, caption
 
@@ -535,26 +553,30 @@ def _advanced(negative_default: str, steps_value: int):
         steps = gr.Slider(label="Inference steps", minimum=4, maximum=40, step=1, value=steps_value)
         guidance = gr.Slider(label="Guidance scale", minimum=1.0, maximum=10.0, step=0.5, value=3.0)
         shift = gr.Slider(label="Flow shift", minimum=1.0, maximum=9.0, step=0.5, value=3.0)
+        fast = gr.Checkbox(
+            label="⚡ Faster generation (feature caching, ~1.4× — slightly softer detail)",
+            value=False,
+        )
         negative = gr.Textbox(label="Negative prompt", value=negative_default, lines=3)
         seed, randomize = _seed_row()
-    return steps, guidance, shift, negative, seed, randomize
+    return steps, guidance, shift, fast, negative, seed, randomize
 
 
 # Example runners: examples carry only the natural-language prompt (and first
 # frame for I2V) — enhancement is on and every other control keeps its default,
 # so the examples table stays to one or two clean columns instead of ten.
 def _example_t2v(prompt):
-    return generate_t2v(prompt, "832 × 480 (16:9)", 2.0, 24, 3.0, 3.0,
+    return generate_t2v(prompt, "832 × 480 (16:9)", 2.0, 24, 3.0, 3.0, False,
                         DEFAULT_NEGATIVE_PROMPT, 42, False, True)
 
 
 def _example_i2v(image, prompt):
-    return generate_i2v(image, prompt, "832 × 480 (16:9)", 2.0, 24, 3.0, 3.0,
+    return generate_i2v(image, prompt, "832 × 480 (16:9)", 2.0, 24, 3.0, 3.0, False,
                         DEFAULT_NEGATIVE_PROMPT, 42, False, True)
 
 
 def _example_t2i(prompt):
-    return generate_t2i(prompt, "1280 × 736 (16:9, 720p)", 30, 3.0, 3.0,
+    return generate_t2i(prompt, "1280 × 736 (16:9, 720p)", 30, 3.0, 3.0, False,
                         DEFAULT_NEGATIVE_PROMPT_IMAGE, 42, False, True)
 
 
@@ -609,7 +631,7 @@ with gr.Blocks(title="LingBot-Video MoE 30B-A3B") as demo:
                 t2v_enhance = gr.Checkbox(
                     label="Enhance prompt (official rewriter — required for plain prompts)", value=True
                 )
-                t2v_steps, t2v_guidance, t2v_shift, t2v_negative, t2v_seed, t2v_rand = _advanced(
+                t2v_steps, t2v_guidance, t2v_shift, t2v_fast, t2v_negative, t2v_seed, t2v_rand = _advanced(
                     DEFAULT_NEGATIVE_PROMPT, 24
                 )
                 t2v_btn = gr.Button("Generate video", variant="primary")
@@ -620,7 +642,7 @@ with gr.Blocks(title="LingBot-Video MoE 30B-A3B") as demo:
                     t2v_caption_out = gr.Textbox(label="Caption", lines=4)
 
         t2v_inputs = [
-            t2v_prompt, t2v_size, t2v_dur, t2v_steps, t2v_guidance, t2v_shift,
+            t2v_prompt, t2v_size, t2v_dur, t2v_steps, t2v_guidance, t2v_shift, t2v_fast,
             t2v_negative, t2v_seed, t2v_rand, t2v_enhance,
         ]
         t2v_outputs = [t2v_out, t2v_seed_out, t2v_caption_out]
@@ -657,7 +679,7 @@ with gr.Blocks(title="LingBot-Video MoE 30B-A3B") as demo:
                 i2v_enhance = gr.Checkbox(
                     label="Enhance prompt (official rewriter — required for plain prompts)", value=True
                 )
-                i2v_steps, i2v_guidance, i2v_shift, i2v_negative, i2v_seed, i2v_rand = _advanced(
+                i2v_steps, i2v_guidance, i2v_shift, i2v_fast, i2v_negative, i2v_seed, i2v_rand = _advanced(
                     DEFAULT_NEGATIVE_PROMPT, 24
                 )
                 i2v_btn = gr.Button("Generate video", variant="primary")
@@ -668,7 +690,7 @@ with gr.Blocks(title="LingBot-Video MoE 30B-A3B") as demo:
                     i2v_caption_out = gr.Textbox(label="Caption", lines=4)
 
         i2v_inputs = [
-            i2v_image, i2v_prompt, i2v_size, i2v_dur, i2v_steps, i2v_guidance, i2v_shift,
+            i2v_image, i2v_prompt, i2v_size, i2v_dur, i2v_steps, i2v_guidance, i2v_shift, i2v_fast,
             i2v_negative, i2v_seed, i2v_rand, i2v_enhance,
         ]
         i2v_outputs = [i2v_out, i2v_seed_out, i2v_caption_out]
@@ -700,7 +722,7 @@ with gr.Blocks(title="LingBot-Video MoE 30B-A3B") as demo:
                 t2i_enhance = gr.Checkbox(
                     label="Enhance prompt (official rewriter — required for plain prompts)", value=True
                 )
-                t2i_steps, t2i_guidance, t2i_shift, t2i_negative, t2i_seed, t2i_rand = _advanced(
+                t2i_steps, t2i_guidance, t2i_shift, t2i_fast, t2i_negative, t2i_seed, t2i_rand = _advanced(
                     DEFAULT_NEGATIVE_PROMPT_IMAGE, 30
                 )
                 t2i_btn = gr.Button("Generate image", variant="primary")
@@ -711,7 +733,7 @@ with gr.Blocks(title="LingBot-Video MoE 30B-A3B") as demo:
                     t2i_caption_out = gr.Textbox(label="Caption", lines=4)
 
         t2i_inputs = [
-            t2i_prompt, t2i_size, t2i_steps, t2i_guidance, t2i_shift,
+            t2i_prompt, t2i_size, t2i_steps, t2i_guidance, t2i_shift, t2i_fast,
             t2i_negative, t2i_seed, t2i_rand, t2i_enhance,
         ]
         t2i_outputs = [t2i_out, t2i_seed_out, t2i_caption_out]

lingbot_video/pipeline_lingbot_video.py

@@ -375,6 +375,9 @@ class LingBotVideoPipeline(DiffusionPipeline):
         batch_cfg: bool = False,
         null_cond_clone_zero: bool = False,
         guidance_stop: float = 1.0,
+        fbcache_threshold: Optional[float] = None,
+        fbcache_warmup: int = 3,
+        fbcache_max_consecutive: int = 3,
         t_thresh: Optional[float] = None,
         refiner_sigma_tail_steps: int = LOW_NOISE_TAIL_V1_DEFAULT_STEPS,
         offload_vae_during_denoise: bool = False,
@@ -487,6 +490,10 @@ class LingBotVideoPipeline(DiffusionPipeline):
             total_steps if guidance_stop >= 1.0
             else max(1, int(round(float(guidance_stop) * total_steps)))
         )
+        if hasattr(self.transformer, "reset_fbcache"):
+            self.transformer.reset_fbcache(
+                fbcache_threshold, fbcache_warmup, fbcache_max_consecutive
+            )
         for i, timestep in enumerate(self.progress_bar(self.scheduler.timesteps)):
             if cfg_parallel:
                 dist.broadcast(latents, src=cfg_latent_src, group=cfg_parallel_group)
@@ -552,6 +559,7 @@ class LingBotVideoPipeline(DiffusionPipeline):
                             timestep_batch,
                             prompt_model_input,
                             encoder_attention_mask=prompt_mask,
+                            fb_cache_branch="cond",
                             return_dict=False,
                         )[0].float()
 
@@ -563,6 +571,7 @@ class LingBotVideoPipeline(DiffusionPipeline):
                             timestep_batch,
                             negative_model_input,
                             encoder_attention_mask=negative_mask,
+                            fb_cache_branch="uncond",
                             return_dict=False,
                         )[0].float()
                     noise_pred = noise_pred_uncond + guidance_scale * (noise_pred - noise_pred_uncond)

lingbot_video/pipeline_lingbot_video_i2v.py

@@ -162,6 +162,9 @@ class LingBotVideoImageToVideoPipeline(LingBotVideoPipeline):
         batch_cfg: bool = False,
         null_cond_clone_zero: bool = False,
         guidance_stop: float = 1.0,
+        fbcache_threshold: Optional[float] = None,
+        fbcache_warmup: int = 3,
+        fbcache_max_consecutive: int = 3,
         return_dict: bool = True,
     ) -> Union[LingBotVideoPipelineOutput, Tuple[Union[list, torch.Tensor]]]:
         self.check_inputs(height, width, num_frames)
@@ -249,6 +252,10 @@ class LingBotVideoImageToVideoPipeline(LingBotVideoPipeline):
             total_steps if guidance_stop >= 1.0
             else max(1, int(round(float(guidance_stop) * total_steps)))
         )
+        if hasattr(self.transformer, "reset_fbcache"):
+            self.transformer.reset_fbcache(
+                fbcache_threshold, fbcache_warmup, fbcache_max_consecutive
+            )
 
         for i, timestep in enumerate(self.progress_bar(self.scheduler.timesteps)):
             if cfg_parallel:
@@ -313,6 +320,7 @@ class LingBotVideoImageToVideoPipeline(LingBotVideoPipeline):
                             timestep_batch,
                             prompt_model_input,
                             encoder_attention_mask=prompt_mask,
+                            fb_cache_branch="cond",
                             return_dict=False,
                         )[0].float()
 
@@ -324,6 +332,7 @@ class LingBotVideoImageToVideoPipeline(LingBotVideoPipeline):
                                 timestep_batch,
                                 negative_model_input,
                                 encoder_attention_mask=negative_mask,
+                                fb_cache_branch="uncond",
                                 return_dict=False,
                             )[0].float()
                         noise_pred = noise_pred_uncond + guidance_scale * (

lingbot_video/transformer_lingbot_video.py

@@ -965,11 +965,58 @@ class LingBotVideoBlock(nn.Module):
         return x
 
 
+class _FBCacheState:
+    """First-Block-Cache state for a single CFG branch.
+
+    Reuses the accumulated residual of blocks 1..N-1 on denoising steps whose
+    first-block residual barely changes relative to the previous step (the
+    signal is the first transformer block's output delta, not the timestep
+    embedding). `warmup` forces full compute early; `max_consecutive` bounds
+    error drift by refreshing the cache after a run of skips.
+    """
+
+    __slots__ = ("threshold", "warmup", "max_consecutive", "step", "consecutive",
+                 "prev_first", "rest_residual", "skips")
+
+    def __init__(self, threshold: float, warmup: int, max_consecutive: int):
+        self.threshold = float(threshold)
+        self.warmup = int(warmup)
+        self.max_consecutive = int(max_consecutive)
+        self.step = 0
+        self.consecutive = 0
+        self.skips = 0
+        self.prev_first = None
+        self.rest_residual = None
+
+    def decide(self, first_residual: torch.Tensor) -> bool:
+        if (
+            self.step < self.warmup
+            or self.rest_residual is None
+            or self.prev_first is None
+            or self.consecutive >= self.max_consecutive
+        ):
+            return False
+        diff = (first_residual - self.prev_first).abs().mean()
+        base = self.prev_first.abs().mean() + 1e-8
+        return bool((diff / base) < self.threshold)
+
+
 class LingBotVideoTransformer3DModel(ModelMixin, ConfigMixin):
     _supports_gradient_checkpointing = False
     _no_split_modules = ["LingBotVideoBlock"]
     _keep_in_fp32_modules = list(LINGBOT_VIDEO_FP32_MODULES)
 
+    def reset_fbcache(self, threshold=None, warmup: int = 3, max_consecutive: int = 3) -> None:
+        """(Re)initialize First-Block-Cache for a generation. threshold=None/<=0
+        disables caching (standard full-block compute)."""
+        if threshold is None or float(threshold) <= 0.0:
+            self._fbcache = None
+        else:
+            self._fbcache = {
+                "cond": _FBCacheState(threshold, warmup, max_consecutive),
+                "uncond": _FBCacheState(threshold, warmup, max_consecutive),
+            }
+
     def to(self, *args, **kwargs):
         device, dtype, non_blocking, _ = torch._C._nn._parse_to(*args, **kwargs)
         if dtype is None or dtype == torch.float32:
@@ -1100,6 +1147,7 @@ class LingBotVideoTransformer3DModel(ModelMixin, ConfigMixin):
         timestep: torch.Tensor,                  # (B,) ∈ [0, 1000](= sigma*1000)
         encoder_hidden_states: torch.Tensor,     # (B, L, text_dim)
         encoder_attention_mask: Optional[torch.Tensor] = None,  # (B, L) 1=valid
+        fb_cache_branch: Optional[str] = None,   # "cond"/"uncond" enables First-Block-Cache
         return_dict: bool = True,
     ):
         B, C, T, H, W = hidden_states.shape
@@ -1272,16 +1320,47 @@ class LingBotVideoTransformer3DModel(ModelMixin, ConfigMixin):
         temb6 = self.cp_temb6(temb6)
         temb6 = temb6.reshape(temb6.shape[0] * temb6.shape[1], -1)
 
-        for block in self.blocks:
-            joint = block(
-                joint,
-                temb6,
-                rotary,
-                attention_mask,
-                moe_padding_mask,
-                packed_indices=packed_indices,
-                parallel_config=parallel_config,
+        cache = None
+        if fb_cache_branch is not None:
+            caches = getattr(self, "_fbcache", None)
+            if caches is not None:
+                cache = caches.get(fb_cache_branch)
+
+        if cache is None:
+            for block in self.blocks:
+                joint = block(
+                    joint,
+                    temb6,
+                    rotary,
+                    attention_mask,
+                    moe_padding_mask,
+                    packed_indices=packed_indices,
+                    parallel_config=parallel_config,
+                )
+        else:
+            # First-Block-Cache: run block 0, then either reuse the cached
+            # residual of blocks 1..N-1 or recompute it.
+            original = joint
+            joint = self.blocks[0](
+                original, temb6, rotary, attention_mask, moe_padding_mask,
+                packed_indices=packed_indices, parallel_config=parallel_config,
             )
+            first_residual = joint - original
+            if cache.decide(first_residual):
+                joint = joint + cache.rest_residual
+                cache.consecutive += 1
+                cache.skips += 1
+            else:
+                h0 = joint
+                for block in self.blocks[1:]:
+                    joint = block(
+                        joint, temb6, rotary, attention_mask, moe_padding_mask,
+                        packed_indices=packed_indices, parallel_config=parallel_config,
+                    )
+                cache.rest_residual = joint - h0
+                cache.consecutive = 0
+            cache.prev_first = first_residual
+            cache.step += 1
         if not packed_cp:
             joint = self.cp_out(joint)