Barebone interactive ABot-World on Modular Diffusers: one pipe.stream(action_source=...) loop

.gitattributes

@@ -33,3 +33,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+examples/desert_valley.png filter=lfs diff=lfs merge=lfs -text
+examples/example.png filter=lfs diff=lfs merge=lfs -text
+examples/forest_stream.png filter=lfs diff=lfs merge=lfs -text
+examples/mountain_meadow.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,13 +1,18 @@
 ---
-title: Abot World Interactive
-emoji: 🌍
-colorFrom: red
-colorTo: indigo
+title: ABot World Interactive
+emoji: 🕹️
+colorFrom: yellow
+colorTo: green
 sdk: gradio
-sdk_version: 6.25.0
-python_version: '3.13'
+sdk_version: 6.5.1
+python_version: '3.12'
 app_file: app.py
 pinned: false
+short_description: Drive a live world model with Modular Diffusers
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Interactive [ABot-World](https://huggingface.co/YiYiXu/ABot-World-0-5B-LF-Diffusers) (a real-time,
+action-conditioned world model, Wan2.2-TI2V-5B) running natively on Modular Diffusers: the whole app is a
+`pipe.stream(action_source=...)` consumer — the pipeline polls the held control once per generated block.
+
+Needs a persistent GPU (the rollout keeps a K/V cache alive across blocks); ~20 GB VRAM in bf16.

app.py

@@ -0,0 +1,109 @@
+import threading
+
+import gradio as gr
+import numpy as np
+import torch
+
+from diffusers.modular_pipelines import ABotWorldStreamingBlocks
+from diffusers.utils import load_image
+
+
+REPO = "YiYiXu/ABot-World-0-5B-LF-Diffusers"
+
+pipe = ABotWorldStreamingBlocks().init_pipeline(REPO)
+pipe.load_components(dtype=torch.bfloat16)
+pipe.to("cuda")
+
+DEFAULT_PROMPT = (
+    "A realistic outdoor world scene with a navigable path, natural lighting, "
+    "detailed ground texture, and stable forward motion."
+)
+
+CONTROLS = {
+    "▲ forward (W)": [1, 0, 0, 0, 0, 0, 0, 0],
+    "◀ left (A)": [0, 1, 0, 0, 0, 0, 0, 0],
+    "▼ back (S)": [0, 0, 1, 0, 0, 0, 0, 0],
+    "▶ right (D)": [0, 0, 0, 1, 0, 0, 0, 0],
+    "cam ↑ (I)": [0, 0, 0, 0, 1, 0, 0, 0],
+    "cam ◀ (J)": [0, 0, 0, 0, 0, 1, 0, 0],
+    "cam ↓ (K)": [0, 0, 0, 0, 0, 0, 1, 0],
+    "cam ▶ (L)": [0, 0, 0, 0, 0, 0, 0, 1],
+    "· idle": [0] * 8,
+}
+
+# one live world at a time: buttons write the held control here, the rollout polls it per block
+session = {"action": [0] * 8, "stop": False}
+run_lock = threading.Lock()
+
+
+def hold(control):
+    session["action"] = CONTROLS[control]
+    return f"holding: {control}"
+
+
+def stop():
+    session["stop"] = True
+    return "stopping after this block…"
+
+
+def play(image, prompt, max_blocks):
+    if not run_lock.acquire(blocking=False):
+        raise gr.Error("A session is already running — stop it first.")
+    try:
+        if image is None:
+            image = load_image("examples/desert_valley.png")
+        session["stop"] = False
+        session["action"] = CONTROLS["▲ forward (W)"]
+
+        def action_source(block_index):
+            if session["stop"] or block_index >= max_blocks:
+                return None
+            return session["action"]
+
+        for event in pipe.stream(
+            prompt=(prompt or DEFAULT_PROMPT).strip() or DEFAULT_PROMPT,
+            image=image,
+            action_source=action_source,
+            generator=torch.Generator("cpu").manual_seed(42),
+        ):
+            if event.path != "denoise.rollout":
+                continue
+            frames = event.state.get("frames")
+            yield (frames[-1] * 255).clip(0, 255).astype(np.uint8)
+    finally:
+        run_lock.release()
+
+
+with gr.Blocks(title="ABot-World Interactive") as demo:
+    gr.Markdown(
+        """# ABot-World — interactive world, Modular Diffusers
+Upload a scene, press Start, then hold a control: each ~1 s block is generated live by
+[ABot-World](https://huggingface.co/YiYiXu/ABot-World-0-5B-LF-Diffusers) conditioned on the held action.
+The whole app is one `pipe.stream(action_source=...)` loop — the pipeline polls your current input once
+per block ([huggingface/diffusers#14159](https://github.com/huggingface/diffusers/pull/14159))."""
+    )
+    with gr.Row():
+        with gr.Column(scale=1):
+            image = gr.Image(label="starting scene", type="pil", height=220)
+            prompt = gr.Textbox(label="scene prompt", value=DEFAULT_PROMPT, lines=2)
+            max_blocks = gr.Slider(label="max blocks (~seconds)", minimum=4, maximum=120, step=1, value=60)
+            with gr.Row():
+                start_button = gr.Button("Start", variant="primary")
+                stop_button = gr.Button("Stop")
+            gr.Examples(
+                examples=[["examples/desert_valley.png"], ["examples/forest_stream.png"],
+                          ["examples/mountain_meadow.png"], ["examples/example.png"]],
+                inputs=[image],
+            )
+        with gr.Column(scale=2):
+            view = gr.Image(label="world", show_label=False, interactive=False)
+            status = gr.Textbox(value="holding: ▲ forward (W)", show_label=False, container=False)
+            with gr.Row():
+                buttons = [gr.Button(name, size="sm") for name in CONTROLS]
+
+    for button in buttons:
+        button.click(hold, inputs=gr.State(button.value), outputs=status, api_name="hold")
+    start_button.click(play, inputs=[image, prompt, max_blocks], outputs=view, api_name="play")
+    stop_button.click(stop, outputs=status, api_name="stop")
+
+demo.launch(show_error=True)

requirements.txt

@@ -0,0 +1,5 @@
+accelerate
+git+https://github.com/huggingface/diffusers.git@abot-world-modular
+torch
+transformers
+ftfy