Upload app.py with huggingface_hub

app.py

@@ -1,20 +1,26 @@
-"""LTX-2.3 Cinemagraph LoRA — image-to-video demo.
-
-Turns a still image into a looping cinemagraph: only the element you describe moves
-while the rest of the frame stays frozen (locked-off static camera). Built on the native
-LTX-2.3 `TI2VidTwoStagesPipeline` (dev/base stage 1 with CFG/STG guidance, distilled-LoRA
-stage 2 + x2 spatial upsampler) with the Cinemagraph LoRA fused into stage 1.
-
-Text encoding (positive + negative, for CFG) is offloaded to the Gemma encoder Space
-(TEXT_ENCODER_SPACE) via gradio_client — `encode_prompts` is monkeypatched with the
-precomputed [ctx_p, ctx_n], so this Space never loads Gemma. Mirrors the working
-`linoyts/ltx23-dev-api` backend pattern.
+"""LTX-2.3 Cinemagraph (image-to-video) demo.
+
+Turns a still image into a looping cinemagraph with selective motion, using the
+`Lightricks/LTX-2.3-22b-LoRA-Cinemagraph` LoRA on top of the full LTX-2.3-22B base
+model. Implementation follows the `linoyts/ltx23-dev-api` pattern:
+
+- Text encoding (positive + negative, needed for CFG) is offloaded to the Gemma
+  encoder Space (`TEXT_ENCODER_SPACE`, default `linoyts/ltx23-gemma-encoder-api`)
+  via gradio_client, so Gemma is never held in-Space. `encode_prompts` is
+  monkeypatched with the precomputed [ctx_p, ctx_n].
+- Unlike the dev-api hero backend, this build uses the **single-stage** full-model
+  pipeline (`TI2VidOneStagePipeline`) which matches the cinemagraph LoRA's
+  recommended CFG/STG single-pass workflow, and loads base + LoRA in **standard
+  bf16 precision** (quantization=None) — NO fp8 quantization and NO fp8 LoRA
+  fusion (maintainer reports fp8+fuse degrades quality). The LoRA fuses cleanly
+  into bf16 weights at load time.
 """
 
 import os
 import subprocess
 import sys
 
+os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
 os.environ["TORCH_COMPILE_DISABLE"] = "1"
 os.environ["TORCHDYNAMO_DISABLE"] = "1"
 
@@ -54,17 +60,14 @@ torch._dynamo.config.disable = True
 import gradio as gr
 import numpy as np
 import spaces
-from gradio_client import Client, handle_file
+from gradio_client import Client
 from huggingface_hub import hf_hub_download
-from PIL import Image, ImageOps
 
-import ltx_pipelines.ti2vid_two_stages as ti2vid_module
+import ltx_pipelines.ti2vid_one_stage as ti2vid_module
 from ltx_core.components.guiders import MultiModalGuiderParams
-from ltx_core.loader import LoraPathStrengthAndSDOps, LTXV_LORA_COMFY_RENAMING_MAP
-from ltx_core.model.video_vae import TilingConfig, get_video_chunks_number
-from ltx_core.quantization import QuantizationPolicy
+from ltx_core.loader import LTXV_LORA_COMFY_RENAMING_MAP, LoraPathStrengthAndSDOps
 from ltx_core.text_encoders.gemma.embeddings_processor import EmbeddingsProcessorOutput
-from ltx_pipelines.ti2vid_two_stages import TI2VidTwoStagesPipeline
+from ltx_pipelines.ti2vid_one_stage import TI2VidOneStagePipeline
 from ltx_pipelines.utils.args import ImageConditioningInput
 from ltx_pipelines.utils.media_io import encode_video
 
@@ -122,78 +125,65 @@ def _patched_load(self, path, sd_ops, device=None):
 
 SafetensorsStateDictLoader.load = _patched_load
 
-# ZeroGPU LoRA-into-fp8 fusion patch:
-# fuse_loras._fuse_delta_with_cast_fp8 upcasts the fp8 base weight + adds the LoRA delta via a
-# Triton CUDA kernel (calculate_weight_float8 -> fused_add_round_kernel). That kernel launches a
-# *real* CUDA op, which cannot be ZeroGPU-virtualised at module scope and dies with
-# "CUDA error: no CUDA-capable device is detected". Replace it with a pure-torch equivalent
-# (upcast to bf16, add delta, re-cast to fp8) that goes through torch.Tensor ops ZeroGPU can
-# virtualise. dev-api avoids this only because it fuses no user LoRA into the fp8 stage-1 base.
-import ltx_core.loader.fuse_loras as _fuse_mod
-
-
-def _fuse_delta_with_cast_fp8_torch(deltas, weight, key, target_dtype, device):
-    fused = (deltas.to(torch.bfloat16) + weight.to(torch.bfloat16)).to(dtype=target_dtype)
-    return {key: fused}
-
-
-_fuse_mod._fuse_delta_with_cast_fp8 = _fuse_delta_with_cast_fp8_torch
-print("[PATCH] fp8 LoRA fusion -> pure-torch (ZeroGPU-virtualisable, no Triton kernel)")
-
 logging.getLogger().setLevel(logging.INFO)
 MAX_SEED = np.iinfo(np.int32).max
 FRAME_RATE = 24.0
 
+# ---- Cinemagraph LoRA recommended settings (from the model card) ----
 TRIGGER = "CINEMAGRAPH_MOTION"
-
 DEFAULT_NEGATIVE = (
     "cars moving, camera movement, pan, tilt, zoom, parallax, whole image moving, "
     "background sliding, person moving, flicker on entire image, noisy texture, "
     "crawling texture, distorted, blurry, low quality"
 )
+# Model card "Recommended Settings":
+#   inference steps 30, guidance (CFG) 4.0, STG stg_v scale 1.0 targeting block 29,
+#   LoRA strength 0.7-3.0 (default 1.0), best at 512x704, 25 frames.
+DEFAULT_STEPS = 30
+DEFAULT_CFG = 4.0
+DEFAULT_STG_SCALE = 1.0
+STG_BLOCKS = [29]
+DEFAULT_RESCALE = 0.7          # LTX_2_3_PARAMS video guider default
+DEFAULT_A2V_SCALE = 3.0        # LTX_2_3_PARAMS video guider default (modality)
+DEFAULT_LORA_STRENGTH = 1.0
+DEFAULT_HEIGHT = 704
+DEFAULT_WIDTH = 512
+DEFAULT_FRAMES = 25            # model card training resolution
 
-# LTX-2.3 guider defaults. Cinemagraph card recommends stg_v scale 1.0 @ block 29, guidance 4.0.
-VIDEO_STG, VIDEO_RESCALE, A2V_SCALE, STG_BLOCKS = 1.0, 0.7, 3.0, [29]
-AUDIO_CFG, AUDIO_STG, AUDIO_RESCALE, V2A_SCALE = 7.0, 1.0, 0.7, 3.0
+# Audio guider defaults (LTX_2_3_PARAMS). We generate video only, but the pipeline
+# still runs the audio branch; keep the shipped defaults.
+AUDIO_CFG, AUDIO_STG, AUDIO_RESCALE, AUDIO_A2V = 7.0, 1.0, 0.7, 3.0
 
 LTX_REPO = os.environ.get("LTX_REPO", "Lightricks/LTX-2.3")
-DEV_FILE = "ltx-2.3-22b-dev.safetensors"
-DISTILLED_LORA_FILE = "ltx-2.3-22b-distilled-lora-384-1.1.safetensors"
-UPSCALER_FILE = "ltx-2.3-spatial-upscaler-x2-1.1.safetensors"
-CINEMAGRAPH_REPO = os.environ.get("CINEMAGRAPH_REPO", "Lightricks/LTX-2.3-22b-LoRA-Cinemagraph")
-CINEMAGRAPH_FILE = "ltx-2.3-22b-lora-cinemagraph-0.9.safetensors"
-DEFAULT_LORA_STRENGTH = 1.0
+DEV_FILE = "ltx-2.3-22b-dev.safetensors"           # full (non-distilled) base model
+LORA_REPO = os.environ.get("LORA_REPO", "Lightricks/LTX-2.3-22b-LoRA-Cinemagraph")
+LORA_FILE = "ltx-2.3-22b-lora-cinemagraph-0.9.safetensors"
 TOKEN = os.environ.get("HF_TOKEN")
 TEXT_ENCODER_SPACE = os.environ.get("TEXT_ENCODER_SPACE", "linoyts/ltx23-gemma-encoder-api")
 
-print("Downloading checkpoints…")
+print("Downloading base checkpoint + cinemagraph LoRA…")
 checkpoint_path = hf_hub_download(LTX_REPO, DEV_FILE, token=TOKEN)
-distilled_lora_path = hf_hub_download(LTX_REPO, DISTILLED_LORA_FILE, token=TOKEN)
-upsampler_path = hf_hub_download(LTX_REPO, UPSCALER_FILE, token=TOKEN)
-cinemagraph_lora_path = hf_hub_download(CINEMAGRAPH_REPO, CINEMAGRAPH_FILE, token=TOKEN)
+lora_path = hf_hub_download(LORA_REPO, LORA_FILE, token=TOKEN)
 
-pipeline = TI2VidTwoStagesPipeline(
+# Standard bf16 precision, LoRA fused into bf16 weights (quantization=None → NO fp8).
+pipeline = TI2VidOneStagePipeline(
     checkpoint_path=checkpoint_path,
-    distilled_lora=[LoraPathStrengthAndSDOps(path=distilled_lora_path, strength=1.0, sd_ops=None)],
-    spatial_upsampler_path=upsampler_path,
     gemma_root=None,  # text encoding happens on TEXT_ENCODER_SPACE
-    # Cinemagraph LoRA fused into stage 1 (ComfyUI-format keys -> comfy renaming map).
     loras=[LoraPathStrengthAndSDOps(
-        path=cinemagraph_lora_path, strength=DEFAULT_LORA_STRENGTH,
-        sd_ops=LTXV_LORA_COMFY_RENAMING_MAP)],
-    quantization=QuantizationPolicy.fp8_cast(),
+        path=lora_path,
+        strength=DEFAULT_LORA_STRENGTH,
+        sd_ops=LTXV_LORA_COMFY_RENAMING_MAP,  # ComfyUI-format LoRA → native keys
+    )],
+    quantization=None,
 )
 
 print("Preloading models (ZeroGPU tensor packing)…")
-s1, s2 = pipeline.stage_1_model_ledger, pipeline.stage_2_model_ledger
-_cached_s1 = {n: getattr(s1, n)() for n in ("transformer", "video_encoder")}
-_cached_s2 = {n: getattr(s2, n)() for n in (
-    "transformer", "video_decoder", "audio_decoder", "vocoder", "spatial_upsampler")}
-for name, model in _cached_s1.items():
-    setattr(s1, name, (lambda m: (lambda: m))(model))
-for name, model in _cached_s2.items():
-    setattr(s2, name, (lambda m: (lambda: m))(model))
-print("Pipeline ready.")
+_ledger = pipeline.model_ledger
+_cached = {n: getattr(_ledger, n)() for n in (
+    "transformer", "video_encoder", "video_decoder", "audio_decoder", "vocoder")}
+for name, model in _cached.items():
+    setattr(_ledger, name, (lambda m: (lambda: m))(model))
+print("Pipeline ready (bf16, cinemagraph LoRA fused, no fp8).")
 
 
 # ---- remote text encoding (positive + negative, needed for CFG) ----
@@ -201,19 +191,16 @@ print("Pipeline ready.")
 _emb_cache = {}
 
 
-def fetch_embeddings(prompt, negative_prompt, seed):
-    """Call the Gemma encoder Space; returns {'positive', 'negative', 'final_prompt'}.
-
-    enhance_prompt is disabled: cinemagraph prompting relies on an explicit
-    'only X moves, everything else frozen' structure that prompt-enhancement can dilute.
-    """
-    key = (prompt, negative_prompt)
+def fetch_embeddings(prompt, negative_prompt, enhance_prompt, image_path, seed):
+    """Call the Gemma encoder Space; returns {'positive', 'negative', 'final_prompt'}."""
+    key = (prompt, negative_prompt, bool(enhance_prompt),
+           image_path or "", int(seed) if enhance_prompt else 0)
     if key in _emb_cache:
         return _emb_cache[key]
-    client = Client(TEXT_ENCODER_SPACE, token=TOKEN, httpx_kwargs={"timeout": 300})
+    client = Client(TEXT_ENCODER_SPACE, token=TOKEN)
     emb_file, final_prompt, status = client.predict(
         prompt=prompt, negative_prompt=negative_prompt or "", encode_negative=True,
-        enhance_prompt=False, seed=int(seed), api_name="/encode",
+        enhance_prompt=enhance_prompt, seed=int(seed), api_name="/encode",
     )
     print(f"[encoder] {status} | final prompt: {final_prompt[:80]}…")
     data = torch.load(emb_file, map_location="cpu", weights_only=True)
@@ -231,30 +218,20 @@ def _to_output(pack, device):
     )
 
 
-def _prep_image(image_path, width, height):
-    """Aspect-fit/crop the still to WxH and save a temp file the VAE encoder can read."""
-    im = Image.open(image_path).convert("RGB")
-    im = ImageOps.fit(im, (width, height), Image.LANCZOS)
-    tmp = tempfile.mktemp(suffix=".png")
-    im.save(tmp)
-    return tmp
-
-
-def gpu_duration(embeddings, image_path, prompt, negative_prompt="", duration=3.0, *args, **kwargs):
-    return min(600, 150 + int(duration) * 40)
+def gpu_duration(embeddings, image_path, prompt, negative_prompt="", num_frames=25,
+                 num_inference_steps=30, *args, **kwargs):
+    # ~ linear in steps and frames; generous ceiling for the full bf16 22B model.
+    return min(660, 200 + int(num_inference_steps) * 6 + int(num_frames) * 4)
 
 
-@spaces.GPU(duration=gpu_duration)
+@spaces.GPU(duration=gpu_duration, size="xlarge")
 @torch.inference_mode()
-def _generate_gpu(embeddings, image_path, prompt, negative_prompt, duration, used_seed,
-                  num_inference_steps, video_cfg_scale, lora_strength, width, height,
+def _generate_gpu(embeddings, image_path, prompt, negative_prompt, num_frames, used_seed,
+                  num_inference_steps, video_cfg_scale, video_stg_scale,
+                  width, height, image_strength,
                   progress=gr.Progress(track_tqdm=True)):
-    num_frames = ((int(duration * FRAME_RATE) + 1 - 1 + 7) // 8) * 8 + 1
-    tiling_config = TilingConfig.default()
-    video_chunks_number = get_video_chunks_number(num_frames, tiling_config)
-
-    cond_img = _prep_image(image_path, int(width), int(height))
-    images = [ImageConditioningInput(path=cond_img, frame_idx=0, strength=1.0)]
+    images = [ImageConditioningInput(path=image_path, frame_idx=0,
+                                     strength=float(image_strength))]
 
     precomputed = [_to_output(embeddings["positive"], "cuda"),
                    _to_output(embeddings["negative"], "cuda")]
@@ -267,153 +244,170 @@ def _generate_gpu(embeddings, image_path, prompt, negative_prompt, duration, use
             seed=used_seed,
             height=int(height),
             width=int(width),
-            num_frames=num_frames,
+            num_frames=int(num_frames),
             frame_rate=FRAME_RATE,
             num_inference_steps=int(num_inference_steps),
             video_guider_params=MultiModalGuiderParams(
-                cfg_scale=video_cfg_scale, stg_scale=VIDEO_STG, rescale_scale=VIDEO_RESCALE,
-                modality_scale=A2V_SCALE, skip_step=0, stg_blocks=STG_BLOCKS),
+                cfg_scale=video_cfg_scale, stg_scale=video_stg_scale,
+                rescale_scale=DEFAULT_RESCALE, modality_scale=DEFAULT_A2V_SCALE,
+                skip_step=0, stg_blocks=STG_BLOCKS),
             audio_guider_params=MultiModalGuiderParams(
                 cfg_scale=AUDIO_CFG, stg_scale=AUDIO_STG, rescale_scale=AUDIO_RESCALE,
-                modality_scale=V2A_SCALE, skip_step=0, stg_blocks=STG_BLOCKS),
+                modality_scale=AUDIO_A2V, skip_step=0, stg_blocks=STG_BLOCKS),
             images=images,
-            tiling_config=tiling_config,
-            enhance_prompt=False,  # already handled remotely; cinemagraph wants literal prompts
+            enhance_prompt=False,  # already enhanced on the encoder Space
         )
     finally:
         ti2vid_module.encode_prompts = original
 
     output_path = tempfile.mktemp(suffix=".mp4")
-    encode_video(video=video, fps=FRAME_RATE, audio=audio, output_path=output_path,
-                 video_chunks_number=video_chunks_number)
+    encode_video(video=video, fps=FRAME_RATE, audio=audio,
+                 output_path=output_path, video_chunks_number=1)
     return output_path
 
 
-def _build_prompt(user_prompt: str) -> str:
-    p = (user_prompt or "").strip()
-    if TRIGGER.lower() in p.lower():
-        return p
-    return f"{TRIGGER}, tripod locked-off static camera, zero camera movement, {p}"
+def _ensure_frames(n: int) -> int:
+    """Round num_frames to the pipeline requirement num_frames = 8*K + 1."""
+    n = max(9, int(n))
+    return ((n - 1 + 7) // 8) * 8 + 1
+
+
+def _prep_prompt(prompt: str) -> str:
+    """Ensure the cinemagraph trigger word leads the prompt."""
+    p = (prompt or "").strip()
+    if TRIGGER.lower() not in p.lower():
+        p = f"{TRIGGER}, {p}" if p else TRIGGER
+    return p
 
 
 def generate(
-    image: str,
+    image_path: str,
     prompt: str,
     negative_prompt: str = DEFAULT_NEGATIVE,
-    duration: float = 4.0,
+    num_frames: int = DEFAULT_FRAMES,
     seed: int = 42,
     randomize_seed: bool = True,
-    num_inference_steps: int = 30,
-    video_cfg_scale: float = 4.0,
-    lora_strength: float = DEFAULT_LORA_STRENGTH,
-    width: int = 704,
-    height: int = 512,
+    num_inference_steps: int = DEFAULT_STEPS,
+    video_cfg_scale: float = DEFAULT_CFG,
+    video_stg_scale: float = DEFAULT_STG_SCALE,
+    width: int = DEFAULT_WIDTH,
+    height: int = DEFAULT_HEIGHT,
+    image_strength: float = 1.0,
+    enhance_prompt: bool = True,
     progress=gr.Progress(track_tqdm=True),
 ):
-    """Turn a still image into a looping cinemagraph (selective motion, everything else frozen).
+    """Generate a cinemagraph (looping video with selective motion) from a still image.
 
     Args:
-        image: path to the still input image (i2v conditioning at frame 0).
-        prompt: what should move (e.g. "only the ocean waves shimmer in his sunglasses").
-            The CINEMAGRAPH_MOTION trigger + static-camera framing are added automatically.
-        negative_prompt: things to suppress (camera motion, whole-image movement, artifacts).
-        duration: clip length in seconds.
+        image_path: path to the input still image to animate.
+        prompt: describe what should move; everything else stays frozen. The
+            trigger word CINEMAGRAPH_MOTION is prepended automatically if absent.
+        negative_prompt: things to avoid (camera motion, whole-image movement, …).
+        num_frames: number of frames (rounded to 8*K+1); ~25 recommended.
         seed: RNG seed.
-        randomize_seed: draw a fresh random seed instead of `seed`.
-        num_inference_steps: stage-1 diffusion steps.
-        video_cfg_scale: classifier-free guidance scale (cinemagraph default 4.0).
-        lora_strength: Cinemagraph LoRA strength note (fixed at load; shown for reference).
-        width: output width (multiple of 64).
-        height: output height (multiple of 64).
+        randomize_seed: draw a fresh random seed each run.
+        num_inference_steps: diffusion steps (model card default 30).
+        video_cfg_scale: classifier-free guidance scale (model card default 4.0).
+        video_stg_scale: spatio-temporal guidance scale (model card default 1.0).
+        width: output width in px (multiple of 32).
+        height: output height in px (multiple of 32).
+        image_strength: image conditioning strength.
+        enhance_prompt: run Gemma prompt enhancement on the encoder Space.
 
     Returns:
-        (video_path, used_seed): the generated .mp4 and the seed actually used.
+        (video_path, used_seed)
     """
-    if image is None:
-        raise gr.Error("Please upload a still image to animate.")
-    if not (prompt or "").strip():
-        raise gr.Error("Describe what should move (e.g. 'only the neon sign flickers').")
+    if not image_path:
+        raise gr.Error("Please provide an input image.")
     used_seed = random.randint(0, MAX_SEED) if randomize_seed else int(seed)
-    full_prompt = _build_prompt(prompt)
-    if TRIGGER.lower() not in full_prompt.lower():
-        full_prompt = f"{TRIGGER}, {full_prompt}"
-    if "seamless natural loop" not in full_prompt.lower():
-        full_prompt = f"{full_prompt}, seamless natural loop"
+    n_frames = _ensure_frames(num_frames)
+    full_prompt = _prep_prompt(prompt)
     progress(0.05, desc="encoding prompts (Gemma Space)…")
-    embeddings = fetch_embeddings(full_prompt, negative_prompt, used_seed)
+    embeddings = fetch_embeddings(full_prompt, negative_prompt, enhance_prompt,
+                                  image_path, used_seed)
     output_path = _generate_gpu(
-        embeddings, image, full_prompt, negative_prompt, duration, used_seed,
-        num_inference_steps, video_cfg_scale, lora_strength, width, height)
+        embeddings, image_path, full_prompt, negative_prompt, n_frames, used_seed,
+        num_inference_steps, video_cfg_scale, video_stg_scale,
+        int(width), int(height), image_strength,
+    )
     return output_path, used_seed
 
 
 CSS = """
-#col-container { max-width: 1200px; margin: 0 auto; }
+#col-container { max-width: 1180px; margin: 0 auto; }
 .dark .gradio-container { color: var(--body-text-color); }
 """
 
-EX_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "examples")
 EXAMPLES = [
-    [os.path.join(EX_DIR, "Glasses.jpeg"),
-     "the man, face, hair, clothing, beach, sky, and background remain completely frozen, only the beach reflection inside his sunglasses moves, reflected time-lapse of ocean waves roll and shimmer in the lenses, everything outside the glasses stays still"],
-    [os.path.join(EX_DIR, "Jump.jpeg"),
-     "the man and cow remain completely frozen, only the clouds in the sky move in fast time-lapse, clouds drift and roll across the sky, grass and foreground remain still"],
-    [os.path.join(EX_DIR, "Motel.jpeg"),
-     "only the neon sign flickers, the starburst, Desert, MOTEL, and NO VACANCY neon tubes subtly pulse and flicker like a real vintage neon sign, everything else stays perfectly still"],
-    [os.path.join(EX_DIR, "Tears.jpeg"),
-     "the woman is frozen, her face, eyes, hair, clothing, seat, and airplane interior remain completely frozen, only the illustrated tear drops move downward along her cheeks like a cutout collage animation"],
+    ["examples/Glasses.jpeg",
+     "CINEMAGRAPH_MOTION, tripod locked-off static camera, zero camera movement, the man, "
+     "face, hair, clothing, beach, sky, and background remain completely frozen, only the "
+     "beach reflection inside his sunglasses moves, reflected time-lapse of ocean waves roll "
+     "and shimmer in the lenses, everything outside the glasses stays still, seamless natural loop"],
+    ["examples/Jump.jpeg",
+     "CINEMAGRAPH_MOTION, tripod locked-off static camera, zero camera movement, the man and "
+     "cow remain completely frozen, only the clouds in the sky move in fast time-lapse, clouds "
+     "drift and roll across the sky, grass and foreground remain still, seamless natural loop."],
+    ["examples/Motel.jpeg",
+     "CINEMAGRAPH_MOTION, tripod locked-off static camera, zero camera movement, only the neon "
+     "sign flickers, the starburst, Desert, MOTEL, and NO VACANCY neon tubes subtly pulse and "
+     "flicker like a real vintage neon sign, everything else stays perfectly still, seamless natural loop"],
+    ["examples/Tears.jpeg",
+     "CINEMAGRAPH_MOTION, tripod locked-off static camera, zero camera movement, the woman is "
+     "frozen, her face, eyes, hair, clothing, seat, and airplane interior remain completely frozen, "
+     "only the illustrated tear drops move downward along her cheeks like a cutout collage "
+     "animation, seamless natural loop."],
 ]
 
-with gr.Blocks(title="LTX-2.3 Cinemagraph LoRA", theme=gr.themes.Citrus(), css=CSS) as demo:
-    with gr.Column(elem_id="col-container"):
-        gr.Markdown(
-            "# 🎞️ LTX-2.3 Cinemagraph\n"
-            "Turn a **still image** into a looping **cinemagraph** — only the element you "
-            "describe moves (water, reflections, neon, clouds, rain) while the rest of the "
-            "frame stays frozen. Built on [LTX-2.3](https://huggingface.co/Lightricks/LTX-2.3) "
-            "with the [Cinemagraph LoRA](https://huggingface.co/Lightricks/LTX-2.3-22b-LoRA-Cinemagraph). "
-            "Text encoding is offloaded to a remote Gemma encoder Space.\n\n"
-            "**Tip:** be explicit — *\"only the [element] moves; everything else frozen.\"* "
-            "The `CINEMAGRAPH_MOTION` trigger and static-camera framing are added for you."
-        )
-        with gr.Row():
-            with gr.Column():
-                image = gr.Image(label="Still image", type="filepath")
-                prompt = gr.Textbox(
-                    label="What should move?", lines=3,
-                    placeholder="only the ocean waves reflected in his sunglasses shimmer; everything else stays frozen",
-                )
-                run = gr.Button("Animate", variant="primary")
-                with gr.Accordion("Advanced settings", open=False):
-                    negative_prompt = gr.Textbox(label="Negative prompt", value=DEFAULT_NEGATIVE, lines=2)
-                    duration = gr.Slider(1, 8, value=4, step=0.5, label="Duration (s)")
-                    with gr.Row():
-                        seed = gr.Number(label="Seed", value=42, precision=0)
-                        randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
-                    with gr.Row():
-                        num_inference_steps = gr.Slider(10, 50, value=30, step=1, label="Steps")
-                        video_cfg_scale = gr.Slider(1, 8, value=4.0, step=0.1, label="Guidance (CFG)")
-                    lora_strength = gr.Slider(0.5, 3.0, value=DEFAULT_LORA_STRENGTH, step=0.1,
-                                              label="LoRA strength (set at load)")
-                    with gr.Row():
-                        width = gr.Slider(384, 1024, value=704, step=64, label="Width")
-                        height = gr.Slider(384, 1024, value=512, step=64, label="Height")
-            with gr.Column():
-                video = gr.Video(label="Cinemagraph", autoplay=True, loop=True)
-                used_seed = gr.Number(label="Used seed", precision=0)
-
-        inputs = [image, prompt, negative_prompt, duration, seed, randomize_seed,
-                  num_inference_steps, video_cfg_scale, lora_strength, width, height]
-        run.click(generate, inputs, [video, used_seed], api_name="generate")
-
-        gr.Examples(
-            examples=EXAMPLES,
-            inputs=[image, prompt],
-            outputs=[video, used_seed],
-            fn=generate,
-            cache_examples=True,
-            cache_mode="lazy",
-        )
+with gr.Blocks(theme=gr.themes.Citrus(), css=CSS, title="LTX-2.3 Cinemagraph") as demo:
+    gr.Markdown(
+        "# 🎞️ LTX-2.3 Cinemagraph\n"
+        "Turn a **still image** into a looping cinemagraph — one element moves, the rest stays "
+        "frozen. Powered by the "
+        "[LTX-2.3-22B Cinemagraph LoRA](https://huggingface.co/Lightricks/LTX-2.3-22b-LoRA-Cinemagraph) "
+        "on the full LTX-2.3-22B base model (bf16, no fp8). Describe *what should move*; keep "
+        "the camera static.",
+        elem_id="intro")
+    with gr.Row(elem_id="col-container"):
+        with gr.Column():
+            image = gr.Image(label="Input image", type="filepath")
+            prompt = gr.Textbox(
+                label="Prompt (what should move)", lines=3,
+                placeholder="only the neon sign flickers, everything else stays perfectly still, "
+                            "seamless natural loop")
+            btn = gr.Button("Generate cinemagraph", variant="primary")
+            with gr.Accordion("Advanced settings", open=False):
+                negative_prompt = gr.Textbox(label="Negative prompt", value=DEFAULT_NEGATIVE, lines=2)
+                num_frames = gr.Slider(9, 121, value=DEFAULT_FRAMES, step=8, label="Frames (8·K+1)")
+                with gr.Row():
+                    seed = gr.Number(label="Seed", value=42, precision=0)
+                    randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
+                with gr.Row():
+                    num_inference_steps = gr.Slider(10, 50, value=DEFAULT_STEPS, step=1, label="Steps")
+                    video_cfg_scale = gr.Slider(1.0, 8.0, value=DEFAULT_CFG, step=0.1, label="CFG scale")
+                    video_stg_scale = gr.Slider(0.0, 4.0, value=DEFAULT_STG_SCALE, step=0.1, label="STG scale")
+                with gr.Row():
+                    width = gr.Slider(256, 1024, value=DEFAULT_WIDTH, step=32, label="Width")
+                    height = gr.Slider(256, 1024, value=DEFAULT_HEIGHT, step=32, label="Height")
+                image_strength = gr.Slider(0.5, 1.0, value=1.0, step=0.05, label="Image conditioning strength")
+                enhance_prompt = gr.Checkbox(label="Enhance prompt (Gemma)", value=True)
+        with gr.Column():
+            video = gr.Video(label="Cinemagraph", autoplay=True, loop=True)
+            used_seed = gr.Number(label="Used seed", precision=0)
+
+    inputs = [image, prompt, negative_prompt, num_frames, seed, randomize_seed,
+              num_inference_steps, video_cfg_scale, video_stg_scale, width, height,
+              image_strength, enhance_prompt]
+    btn.click(generate, inputs, [video, used_seed], api_name="generate")
+
+    gr.Examples(
+        examples=EXAMPLES,
+        inputs=[image, prompt],
+        outputs=[video, used_seed],
+        fn=generate,
+        cache_examples=False,
+        run_on_click=True,
+    )
 
 if __name__ == "__main__":
-    demo.launch(mcp_server=True, show_error=True)
+    demo.launch(mcp_server=True)