Add files using upload-large-folder tool

Helios/_DEV/tools/gradio/comparison/gradio_compare_diff-ckpt.py

@@ -0,0 +1,547 @@
+import os
+import re
+
+import gradio as gr
+
+
+def parse_video_name(filename):
+    """Parse video filename to extract step and index"""
+    # Match checkpoint-{step}_{idx}.mp4 format
+    match = re.match(r"checkpoint-(\d+)_(\d+)\.mp4$", filename)
+    if match:
+        step = int(match.group(1))
+        idx = int(match.group(2))
+        return step, idx
+    return None, None
+
+
+def get_video_list(folder_path):
+    """Get all mp4 videos from folder"""
+    if not os.path.exists(folder_path):
+        return []
+
+    videos = []
+    for file in os.listdir(folder_path):
+        if file.endswith(".mp4"):
+            step, idx = parse_video_name(file)
+            if step is not None:
+                videos.append({"filename": file, "step": step, "idx": idx, "path": os.path.join(folder_path, file)})
+
+    # Sort by step and idx
+    videos.sort(key=lambda x: (x["step"], x["idx"]))
+    return videos
+
+
+def create_video_mapping(videos):
+    """Create (step, idx) -> filename mapping"""
+    mapping = {}
+    for video in videos:
+        key = (video["step"], video["idx"])
+        mapping[key] = video["filename"]
+    return mapping
+
+
+def get_step_idx_mapping(common_keys):
+    """Extract step and idx mapping from common (step, idx) keys"""
+    step_idx_map = {}  # {step: [idx1, idx2, ...]}
+    all_steps = set()
+    all_indices = set()
+
+    for step, idx in common_keys:
+        all_steps.add(step)
+        all_indices.add(idx)
+        if step not in step_idx_map:
+            step_idx_map[step] = []
+        step_idx_map[step].append(idx)
+
+    # Sort
+    for step in step_idx_map:
+        step_idx_map[step].sort()
+
+    return sorted(all_steps), sorted(all_indices), step_idx_map
+
+
+def load_videos(folder1, folder2):
+    """Load videos from both folders and match them"""
+    if not folder1 or not folder2:
+        return (
+            None,
+            None,
+            "Please enter both folder paths",
+            gr.update(choices=[], value=None),
+            gr.update(choices=[], value=None),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            "0 / 0",
+            {},
+            {},
+            {},
+        )
+
+    videos1 = get_video_list(folder1)
+    videos2 = get_video_list(folder2)
+
+    if not videos1:
+        return (
+            None,
+            None,
+            f"No video files found in folder 1 (total {len(os.listdir(folder1)) if os.path.exists(folder1) else 0} files)",
+            gr.update(choices=[], value=None),
+            gr.update(choices=[], value=None),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            "0 / 0",
+            {},
+            {},
+            {},
+        )
+    if not videos2:
+        return (
+            None,
+            None,
+            f"No video files found in folder 2 (total {len(os.listdir(folder2)) if os.path.exists(folder2) else 0} files)",
+            gr.update(choices=[], value=None),
+            gr.update(choices=[], value=None),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            "0 / 0",
+            {},
+            {},
+            {},
+        )
+
+    # Create (step, idx) to filename mapping
+    video_map1 = create_video_mapping(videos1)
+    video_map2 = create_video_mapping(videos2)
+
+    # Find common (step, idx) combinations
+    common_keys = sorted(set(video_map1.keys()) & set(video_map2.keys()))
+
+    if not common_keys:
+        # Show detailed information for debugging
+        steps1 = {v["step"] for v in videos1}
+        steps2 = {v["step"] for v in videos2}
+        info = "No matching videos found in both folders\n"
+        info += f"Folder 1: {len(videos1)} videos found\n"
+        info += f"Folder 2: {len(videos2)} videos found\n"
+        info += f"Folder 1 steps: {sorted(steps1)}\n"
+        info += f"Folder 2 steps: {sorted(steps2)}\n"
+        info += f"Common steps: {sorted(steps1 & steps2)}"
+        return (
+            None,
+            None,
+            info,
+            gr.update(choices=[], value=None),
+            gr.update(choices=[], value=None),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            "0 / 0",
+            {},
+            {},
+            {},
+        )
+
+    # Get all steps and indices
+    all_steps, all_indices, step_idx_map = get_step_idx_mapping(common_keys)
+
+    # Load first video
+    first_key = common_keys[0]
+    first_step, first_idx = first_key
+
+    filename1 = video_map1[first_key]
+    filename2 = video_map2[first_key]
+
+    video1_path = os.path.join(folder1, filename1)
+    video2_path = os.path.join(folder2, filename2)
+
+    info = f"Found {len(common_keys)} matching video pairs\n"
+    info += f"Folder 1: {len(videos1)} videos\n"
+    info += f"Folder 2: {len(videos2)} videos\n"
+    info += f"Current: Step {first_step}, Index {first_idx}\n"
+    info += f"File 1: {filename1}\n"
+    info += f"File 2: {filename2}"
+
+    # Get available indices for current step
+    available_indices = step_idx_map.get(first_step, [])
+
+    progress = f"1 / {len(common_keys)}"
+
+    return (
+        video1_path,
+        video2_path,
+        info,
+        gr.update(choices=all_steps, value=first_step),
+        gr.update(choices=available_indices, value=first_idx),
+        gr.update(interactive=first_step > all_steps[0]),
+        gr.update(interactive=first_step < all_steps[-1]),
+        gr.update(interactive=first_idx > available_indices[0] if available_indices else False),
+        gr.update(interactive=first_idx < available_indices[-1] if available_indices else False),
+        progress,
+        video_map1,
+        video_map2,
+        step_idx_map,
+    )
+
+
+def update_available_indices(selected_step, step_idx_map):
+    """Update available index list"""
+    if not step_idx_map or selected_step is None:
+        return gr.update(choices=[], value=None)
+
+    available_indices = step_idx_map.get(selected_step, [])
+    first_idx = available_indices[0] if available_indices else None
+
+    return gr.update(choices=available_indices, value=first_idx)
+
+
+def update_videos_from_selectors(folder1, folder2, selected_step, selected_idx, video_map1, video_map2, step_idx_map):
+    """Update videos based on selected step and idx"""
+    if selected_step is None or selected_idx is None:
+        return None, None, "Please select step and index", gr.update(), gr.update(), gr.update(), gr.update(), ""
+
+    key = (selected_step, selected_idx)
+
+    if key not in video_map1 or key not in video_map2:
+        return (
+            None,
+            None,
+            f"Video not found for Step {selected_step}, Index {selected_idx}",
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            "",
+        )
+
+    filename1 = video_map1[key]
+    filename2 = video_map2[key]
+
+    video1_path = os.path.join(folder1, filename1)
+    video2_path = os.path.join(folder2, filename2)
+
+    info = f"Current: Step {selected_step}, Index {selected_idx}\n"
+    info += f"File 1: {filename1}\n"
+    info += f"File 2: {filename2}"
+
+    # Get all steps and indices for current step
+    all_steps = sorted(step_idx_map.keys())
+    available_indices = step_idx_map.get(selected_step, [])
+
+    # Update button states
+    prev_step_interactive = selected_step > all_steps[0]
+    next_step_interactive = selected_step < all_steps[-1]
+    prev_idx_interactive = selected_idx > available_indices[0] if available_indices else False
+    next_idx_interactive = selected_idx < available_indices[-1] if available_indices else False
+
+    # Calculate current video position
+    all_keys = sorted(set(video_map1.keys()) & set(video_map2.keys()))
+    current_idx = all_keys.index(key) + 1
+    progress = f"{current_idx} / {len(all_keys)}"
+
+    return (
+        video1_path,
+        video2_path,
+        info,
+        gr.update(interactive=prev_step_interactive),
+        gr.update(interactive=next_step_interactive),
+        gr.update(interactive=prev_idx_interactive),
+        gr.update(interactive=next_idx_interactive),
+        progress,
+    )
+
+
+def navigate_step(folder1, folder2, current_step, current_idx, video_map1, video_map2, step_idx_map, direction):
+    """Navigate to previous or next step"""
+    if not step_idx_map or current_step is None:
+        return (
+            None,
+            None,
+            "Please load videos first",
+            current_step,
+            current_idx,
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            "",
+        )
+
+    all_steps = sorted(step_idx_map.keys())
+    current_step_idx = all_steps.index(current_step)
+
+    if direction == "prev":
+        new_step_idx = max(0, current_step_idx - 1)
+    else:  # next
+        new_step_idx = min(len(all_steps) - 1, current_step_idx + 1)
+
+    new_step = all_steps[new_step_idx]
+
+    # Get first available index for new step
+    available_indices = step_idx_map.get(new_step, [])
+    new_idx = available_indices[0] if available_indices else current_idx
+
+    return update_videos_from_selectors(folder1, folder2, new_step, new_idx, video_map1, video_map2, step_idx_map) + (
+        new_step,
+        new_idx,
+    )
+
+
+def navigate_idx(folder1, folder2, current_step, current_idx, video_map1, video_map2, step_idx_map, direction):
+    """Navigate to previous or next index"""
+    if not step_idx_map or current_step is None or current_idx is None:
+        return (
+            None,
+            None,
+            "Please load videos first",
+            current_step,
+            current_idx,
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            "",
+        )
+
+    available_indices = step_idx_map.get(current_step, [])
+    if not available_indices or current_idx not in available_indices:
+        return (
+            None,
+            None,
+            "Index not in list",
+            current_step,
+            current_idx,
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            "",
+        )
+
+    current_idx_pos = available_indices.index(current_idx)
+
+    if direction == "prev":
+        new_idx_pos = max(0, current_idx_pos - 1)
+    else:  # next
+        new_idx_pos = min(len(available_indices) - 1, current_idx_pos + 1)
+
+    new_idx = available_indices[new_idx_pos]
+
+    return update_videos_from_selectors(
+        folder1, folder2, current_step, new_idx, video_map1, video_map2, step_idx_map
+    ) + (current_step, new_idx)
+
+
+# Create Gradio interface
+with gr.Blocks(title="Video Comparison Tool") as demo:
+    gr.Markdown("# Video Comparison Tool")
+    gr.Markdown(
+        "Enter two folder paths to automatically match and compare checkpoint-{step}_{idx}.mp4 format video files"
+    )
+
+    # Store state
+    video_map1_state = gr.State({})
+    video_map2_state = gr.State({})
+    step_idx_map_state = gr.State({})
+
+    with gr.Row():
+        folder1_input = gr.Textbox(label="Folder 1 Path", placeholder="/path/to/folder1", scale=2)
+        folder2_input = gr.Textbox(label="Folder 2 Path", placeholder="/path/to/folder2", scale=2)
+
+    load_btn = gr.Button("Load Videos", variant="primary")
+
+    info_text = gr.Textbox(label="Information", interactive=False, lines=6)
+
+    # Step navigation controls
+    with gr.Row():
+        prev_step_btn = gr.Button("⬅️ Previous Step", interactive=False, scale=1)
+        step_selector = gr.Dropdown(label="Select Step", choices=[], interactive=True, scale=2)
+        next_step_btn = gr.Button("Next Step ➡️", interactive=False, scale=1)
+
+    # Index navigation controls
+    with gr.Row():
+        prev_idx_btn = gr.Button("⬅️ Previous Index", interactive=False, scale=1)
+        idx_selector = gr.Dropdown(label="Select Index", choices=[], interactive=True, scale=2)
+        next_idx_btn = gr.Button("Next Index ➡️", interactive=False, scale=1)
+
+    progress_text = gr.Textbox(label="Progress", value="0 / 0", interactive=False)
+
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### Folder 1")
+            video1 = gr.Video(label="Video 1", autoplay=True, loop=True)
+
+        with gr.Column():
+            gr.Markdown("### Folder 2")
+            video2 = gr.Video(label="Video 2", autoplay=True, loop=True)
+
+    # Event bindings
+    load_btn.click(
+        fn=load_videos,
+        inputs=[folder1_input, folder2_input],
+        outputs=[
+            video1,
+            video2,
+            info_text,
+            step_selector,
+            idx_selector,
+            prev_step_btn,
+            next_step_btn,
+            prev_idx_btn,
+            next_idx_btn,
+            progress_text,
+            video_map1_state,
+            video_map2_state,
+            step_idx_map_state,
+        ],
+    )
+
+    # When step changes, update available indices
+    step_selector.change(
+        fn=update_available_indices, inputs=[step_selector, step_idx_map_state], outputs=[idx_selector]
+    ).then(
+        fn=update_videos_from_selectors,
+        inputs=[
+            folder1_input,
+            folder2_input,
+            step_selector,
+            idx_selector,
+            video_map1_state,
+            video_map2_state,
+            step_idx_map_state,
+        ],
+        outputs=[video1, video2, info_text, prev_step_btn, next_step_btn, prev_idx_btn, next_idx_btn, progress_text],
+    )
+
+    # When index changes, update videos
+    idx_selector.change(
+        fn=update_videos_from_selectors,
+        inputs=[
+            folder1_input,
+            folder2_input,
+            step_selector,
+            idx_selector,
+            video_map1_state,
+            video_map2_state,
+            step_idx_map_state,
+        ],
+        outputs=[video1, video2, info_text, prev_step_btn, next_step_btn, prev_idx_btn, next_idx_btn, progress_text],
+    )
+
+    # Step navigation buttons
+    prev_step_btn.click(
+        fn=lambda f1, f2, s, i, vm1, vm2, sim: navigate_step(f1, f2, s, i, vm1, vm2, sim, "prev"),
+        inputs=[
+            folder1_input,
+            folder2_input,
+            step_selector,
+            idx_selector,
+            video_map1_state,
+            video_map2_state,
+            step_idx_map_state,
+        ],
+        outputs=[
+            video1,
+            video2,
+            info_text,
+            prev_step_btn,
+            next_step_btn,
+            prev_idx_btn,
+            next_idx_btn,
+            progress_text,
+            step_selector,
+            idx_selector,
+        ],
+    )
+
+    next_step_btn.click(
+        fn=lambda f1, f2, s, i, vm1, vm2, sim: navigate_step(f1, f2, s, i, vm1, vm2, sim, "next"),
+        inputs=[
+            folder1_input,
+            folder2_input,
+            step_selector,
+            idx_selector,
+            video_map1_state,
+            video_map2_state,
+            step_idx_map_state,
+        ],
+        outputs=[
+            video1,
+            video2,
+            info_text,
+            prev_step_btn,
+            next_step_btn,
+            prev_idx_btn,
+            next_idx_btn,
+            progress_text,
+            step_selector,
+            idx_selector,
+        ],
+    )
+
+    # Index navigation buttons
+    prev_idx_btn.click(
+        fn=lambda f1, f2, s, i, vm1, vm2, sim: navigate_idx(f1, f2, s, i, vm1, vm2, sim, "prev"),
+        inputs=[
+            folder1_input,
+            folder2_input,
+            step_selector,
+            idx_selector,
+            video_map1_state,
+            video_map2_state,
+            step_idx_map_state,
+        ],
+        outputs=[
+            video1,
+            video2,
+            info_text,
+            prev_step_btn,
+            next_step_btn,
+            prev_idx_btn,
+            next_idx_btn,
+            progress_text,
+            step_selector,
+            idx_selector,
+        ],
+    )
+
+    next_idx_btn.click(
+        fn=lambda f1, f2, s, i, vm1, vm2, sim: navigate_idx(f1, f2, s, i, vm1, vm2, sim, "next"),
+        inputs=[
+            folder1_input,
+            folder2_input,
+            step_selector,
+            idx_selector,
+            video_map1_state,
+            video_map2_state,
+            step_idx_map_state,
+        ],
+        outputs=[
+            video1,
+            video2,
+            info_text,
+            prev_step_btn,
+            next_step_btn,
+            prev_idx_btn,
+            next_idx_btn,
+            progress_text,
+            step_selector,
+            idx_selector,
+        ],
+    )
+
+if __name__ == "__main__":
+    demo.launch(
+        share=True,
+        allowed_paths=[
+            "0_ablation_videos",
+            "ablation_stage3_1_warmup",
+        ],
+    )

Helios/_DEV/tools/gradio/comparison/gradio_compare_diff-video.py

@@ -0,0 +1,450 @@
+import os
+import re
+
+import gradio as gr
+
+
+def parse_video_name(filename):
+    """Parse video filename to extract step and index"""
+    # Match checkpoint-{step}_{idx}.mp4 format
+    match = re.match(r"checkpoint-(\d+)_(\d+)\.mp4$", filename)
+    if match:
+        step = int(match.group(1))
+        idx = int(match.group(2))
+        return step, idx
+    return None, None
+
+
+def get_video_list(folder_path):
+    """Get all mp4 videos from folder"""
+    if not os.path.exists(folder_path):
+        return []
+
+    videos = []
+    for file in os.listdir(folder_path):
+        if file.endswith(".mp4"):
+            step, idx = parse_video_name(file)
+            if step is not None:
+                videos.append({"filename": file, "step": step, "idx": idx, "path": os.path.join(folder_path, file)})
+
+    # Sort by step and idx
+    videos.sort(key=lambda x: (x["step"], x["idx"]))
+    return videos
+
+
+def create_video_mapping(videos):
+    """Create (step, idx) -> filename mapping"""
+    mapping = {}
+    for video in videos:
+        key = (video["step"], video["idx"])
+        mapping[key] = video["filename"]
+    return mapping
+
+
+def get_step_idx_info(video_map):
+    """Extract step and idx information from video mapping"""
+    all_steps = set()
+    all_indices = set()
+    idx_step_map = {}  # {idx: [step1, step2, ...]}
+
+    for step, idx in video_map.keys():
+        all_steps.add(step)
+        all_indices.add(idx)
+        if idx not in idx_step_map:
+            idx_step_map[idx] = []
+        idx_step_map[idx].append(step)
+
+    # Sort
+    for idx in idx_step_map:
+        idx_step_map[idx].sort()
+
+    return sorted(all_steps), sorted(all_indices), idx_step_map
+
+
+def load_videos(folder_path):
+    """Load videos from folder"""
+    if not folder_path:
+        return (
+            None,
+            None,
+            "Please enter folder path",
+            gr.update(choices=[], value=None),
+            gr.update(choices=[], value=None),
+            gr.update(choices=[], value=None),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            "0 / 0",
+            {},
+            {},
+        )
+
+    videos = get_video_list(folder_path)
+
+    if not videos:
+        return (
+            None,
+            None,
+            f"No video files found in folder ({len(os.listdir(folder_path)) if os.path.exists(folder_path) else 0} files total)",
+            gr.update(choices=[], value=None),
+            gr.update(choices=[], value=None),
+            gr.update(choices=[], value=None),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            "0 / 0",
+            {},
+            {},
+        )
+
+    # Create (step, idx) to filename mapping
+    video_map = create_video_mapping(videos)
+
+    # Get all step and index information
+    all_steps, all_indices, idx_step_map = get_step_idx_info(video_map)
+
+    # Filter indices with at least 2 steps
+    valid_indices = [idx for idx in all_indices if len(idx_step_map[idx]) >= 2]
+
+    if not valid_indices:
+        info = (
+            f"Found {len(videos)} videos, but no comparable videos (need at least 2 different steps for same index)\n"
+        )
+        info += f"Steps: {all_steps}\n"
+        info += f"Indices: {all_indices}"
+        return (
+            None,
+            None,
+            info,
+            gr.update(choices=[], value=None),
+            gr.update(choices=[], value=None),
+            gr.update(choices=[], value=None),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            "0 / 0",
+            {},
+            {},
+        )
+
+    # Select first valid index and its first two steps
+    first_idx = valid_indices[0]
+    available_steps = idx_step_map[first_idx]
+    step1 = available_steps[0]
+    step2 = available_steps[1] if len(available_steps) > 1 else available_steps[0]
+
+    # Load videos
+    filename1 = video_map.get((step1, first_idx))
+    filename2 = video_map.get((step2, first_idx))
+
+    video1_path = os.path.join(folder_path, filename1) if filename1 else None
+    video2_path = os.path.join(folder_path, filename2) if filename2 else None
+
+    info = f"Found {len(videos)} videos, {len(valid_indices)} comparable indices\n"
+    info += f"Current Index: {first_idx}\n"
+    info += f"Step1: {step1} - {filename1}\n"
+    info += f"Step2: {step2} - {filename2}"
+
+    progress = f"1 / {len(valid_indices)}"
+
+    return (
+        video1_path,
+        video2_path,
+        info,
+        gr.update(choices=valid_indices, value=first_idx),
+        gr.update(choices=available_steps, value=step1),
+        gr.update(choices=available_steps, value=step2),
+        gr.update(interactive=first_idx > valid_indices[0]),
+        gr.update(interactive=first_idx < valid_indices[-1]),
+        gr.update(interactive=True),
+        gr.update(interactive=True),
+        progress,
+        video_map,
+        idx_step_map,
+    )
+
+
+def update_videos(folder_path, selected_idx, selected_step1, selected_step2, video_map, idx_step_map):
+    """Update videos based on selected idx and two steps"""
+    if selected_idx is None or selected_step1 is None or selected_step2 is None:
+        return None, None, "Please select index and steps", gr.update(), gr.update(), gr.update(), gr.update(), ""
+
+    key1 = (selected_step1, selected_idx)
+    key2 = (selected_step2, selected_idx)
+
+    filename1 = video_map.get(key1)
+    filename2 = video_map.get(key2)
+
+    if not filename1 or not filename2:
+        return (
+            None,
+            None,
+            f"Complete video pair not found: Index {selected_idx}, Step1 {selected_step1}, Step2 {selected_step2}",
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            "",
+        )
+
+    video1_path = os.path.join(folder_path, filename1)
+    video2_path = os.path.join(folder_path, filename2)
+
+    info = f"Current Index: {selected_idx}\n"
+    info += f"Step1: {selected_step1} - {filename1}\n"
+    info += f"Step2: {selected_step2} - {filename2}"
+
+    # Get all valid indices
+    all_indices = [idx for idx in idx_step_map.keys() if len(idx_step_map[idx]) >= 2]
+    all_indices.sort()
+
+    # Update button states
+    prev_idx_interactive = selected_idx > all_indices[0] if all_indices else False
+    next_idx_interactive = selected_idx < all_indices[-1] if all_indices else False
+
+    # Calculate progress
+    current_pos = all_indices.index(selected_idx) + 1 if selected_idx in all_indices else 0
+    progress = f"{current_pos} / {len(all_indices)}"
+
+    return (
+        video1_path,
+        video2_path,
+        info,
+        gr.update(interactive=prev_idx_interactive),
+        gr.update(interactive=next_idx_interactive),
+        gr.update(),
+        gr.update(),
+        progress,
+    )
+
+
+def update_available_steps(selected_idx, idx_step_map):
+    """Update available steps list for current index"""
+    if not idx_step_map or selected_idx is None:
+        return gr.update(choices=[], value=None), gr.update(choices=[], value=None)
+
+    available_steps = idx_step_map.get(selected_idx, [])
+    first_step = available_steps[0] if available_steps else None
+    second_step = available_steps[1] if len(available_steps) > 1 else first_step
+
+    return (
+        gr.update(choices=available_steps, value=first_step),
+        gr.update(choices=available_steps, value=second_step),
+    )
+
+
+def navigate_idx(folder_path, current_idx, step1, step2, video_map, idx_step_map, direction):
+    """Navigate to previous or next index"""
+    if not idx_step_map or current_idx is None:
+        return (
+            None,
+            None,
+            "Please load videos first",
+            current_idx,
+            step1,
+            step2,
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            "",
+        )
+
+    # Get all valid indices
+    all_indices = [idx for idx in idx_step_map.keys() if len(idx_step_map[idx]) >= 2]
+    all_indices.sort()
+
+    if current_idx not in all_indices:
+        return (
+            None,
+            None,
+            "Current Index invalid",
+            current_idx,
+            step1,
+            step2,
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            "",
+        )
+
+    current_idx_pos = all_indices.index(current_idx)
+
+    if direction == "prev":
+        new_idx_pos = max(0, current_idx_pos - 1)
+    else:  # next
+        new_idx_pos = min(len(all_indices) - 1, current_idx_pos + 1)
+
+    new_idx = all_indices[new_idx_pos]
+
+    # Get available steps for new index
+    available_steps = idx_step_map.get(new_idx, [])
+    new_step1 = available_steps[0] if available_steps else step1
+    new_step2 = available_steps[1] if len(available_steps) > 1 else available_steps[0]
+
+    result = update_videos(folder_path, new_idx, new_step1, new_step2, video_map, idx_step_map)
+    return result + (new_idx, new_step1, new_step2)
+
+
+# Create Gradio interface
+with gr.Blocks(title="Video Comparison Tool - Different Step Comparison") as demo:
+    gr.Markdown("# Video Comparison Tool - Different Step Comparison")
+    gr.Markdown(
+        "Enter folder path to compare videos of same index at different steps (checkpoint-{step}_{idx}.mp4 format)"
+    )
+
+    # Store state
+    video_map_state = gr.State({})
+    idx_step_map_state = gr.State({})
+
+    folder_input = gr.Textbox(label="Folder Path", placeholder="/path/to/folder", scale=2)
+
+    load_btn = gr.Button("Load Videos", variant="primary")
+
+    info_text = gr.Textbox(label="Information", interactive=False, lines=5)
+
+    # Index navigation controls
+    with gr.Row():
+        prev_idx_btn = gr.Button("⬅️ Previous Index", interactive=False, scale=1)
+        idx_selector = gr.Dropdown(label="Select Index", choices=[], interactive=True, scale=2)
+        next_idx_btn = gr.Button("Next Index ➡️", interactive=False, scale=1)
+
+    # Step selectors
+    with gr.Row():
+        step1_selector = gr.Dropdown(label="Select Step1 (Left)", choices=[], interactive=True, scale=1)
+        step2_selector = gr.Dropdown(label="Select Step2 (Right)", choices=[], interactive=True, scale=1)
+
+    progress_text = gr.Textbox(label="Progress", value="0 / 0", interactive=False)
+
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### Step 1")
+            video1 = gr.Video(label="Video 1", autoplay=True, loop=True)
+
+        with gr.Column():
+            gr.Markdown("### Step 2")
+            video2 = gr.Video(label="Video 2", autoplay=True, loop=True)
+
+    # Event binding
+    load_btn.click(
+        fn=load_videos,
+        inputs=[folder_input],
+        outputs=[
+            video1,
+            video2,
+            info_text,
+            idx_selector,
+            step1_selector,
+            step2_selector,
+            prev_idx_btn,
+            next_idx_btn,
+            gr.State(),
+            gr.State(),
+            progress_text,
+            video_map_state,
+            idx_step_map_state,
+        ],
+    )
+
+    # When index changes, update available steps and videos
+    def handle_idx_change(folder_path, selected_idx, video_map, idx_step_map):
+        """Handle index change - update steps and videos together"""
+        if not idx_step_map or selected_idx is None:
+            return (
+                None,
+                None,
+                "Please select index",
+                gr.update(choices=[], value=None),
+                gr.update(choices=[], value=None),
+                gr.update(),
+                gr.update(),
+                "",
+            )
+
+        # Get available steps for new index
+        available_steps = idx_step_map.get(selected_idx, [])
+        new_step1 = available_steps[0] if available_steps else None
+        new_step2 = available_steps[1] if len(available_steps) > 1 else available_steps[0]
+
+        # Update videos with new steps
+        result = update_videos(folder_path, selected_idx, new_step1, new_step2, video_map, idx_step_map)
+
+        return (
+            result[0],  # video1
+            result[1],  # video2
+            result[2],  # info
+            gr.update(choices=available_steps, value=new_step1),  # step1_selector
+            gr.update(choices=available_steps, value=new_step2),  # step2_selector
+            result[3],  # prev_idx_btn
+            result[4],  # next_idx_btn
+            result[7],  # progress
+        )
+
+    idx_selector.change(
+        fn=handle_idx_change,
+        inputs=[folder_input, idx_selector, video_map_state, idx_step_map_state],
+        outputs=[video1, video2, info_text, step1_selector, step2_selector, prev_idx_btn, next_idx_btn, progress_text],
+    )
+
+    step1_selector.select(
+        fn=update_videos,
+        inputs=[folder_input, idx_selector, step1_selector, step2_selector, video_map_state, idx_step_map_state],
+        outputs=[video1, video2, info_text, prev_idx_btn, next_idx_btn, gr.State(), gr.State(), progress_text],
+    )
+
+    step2_selector.select(
+        fn=update_videos,
+        inputs=[folder_input, idx_selector, step1_selector, step2_selector, video_map_state, idx_step_map_state],
+        outputs=[video1, video2, info_text, prev_idx_btn, next_idx_btn, gr.State(), gr.State(), progress_text],
+    )
+
+    # Index navigation buttons
+    prev_idx_btn.click(
+        fn=lambda f, i, s1, s2, vm, ism: navigate_idx(f, i, s1, s2, vm, ism, "prev"),
+        inputs=[folder_input, idx_selector, step1_selector, step2_selector, video_map_state, idx_step_map_state],
+        outputs=[
+            video1,
+            video2,
+            info_text,
+            prev_idx_btn,
+            next_idx_btn,
+            gr.State(),
+            gr.State(),
+            progress_text,
+            idx_selector,
+            step1_selector,
+            step2_selector,
+        ],
+    )
+
+    next_idx_btn.click(
+        fn=lambda f, i, s1, s2, vm, ism: navigate_idx(f, i, s1, s2, vm, ism, "next"),
+        inputs=[folder_input, idx_selector, step1_selector, step2_selector, video_map_state, idx_step_map_state],
+        outputs=[
+            video1,
+            video2,
+            info_text,
+            prev_idx_btn,
+            next_idx_btn,
+            gr.State(),
+            gr.State(),
+            progress_text,
+            idx_selector,
+            step1_selector,
+            step2_selector,
+        ],
+    )
+
+
+if __name__ == "__main__":
+    demo.launch(
+        share=True,
+        allowed_paths=[
+            "0_ablation_videos",
+            "ablation_stage3_1_warmup",
+        ],
+    )

Helios/_DEV/tools/others/benchmark/benchmark_compile_performance.py

@@ -0,0 +1,234 @@
+import os
+import sys
+import time
+from datetime import datetime
+
+import torch
+
+
+os.environ["HF_ENABLE_PARALLEL_LOADING"] = "yes"
+os.environ["DIFFUSERS_ENABLE_HUB_KERNELS"] = "yes"
+
+from helios.modules.kernels import (
+    replace_all_norms_with_flash_norms,
+    replace_rmsnorm_with_fp32,
+    replace_rope_with_flash_rope,
+)
+from helios.modules.transformer_helios import HeliosTransformer3DModel
+from helios.pipelines.pipeline_wan import WanPipeline
+
+from diffusers import AutoencoderKLWan
+
+
+class DualLogger:
+    """同时输出到控制台和文件的日志器"""
+
+    def __init__(self, filename):
+        self.file = open(filename, "w", encoding="utf-8")
+        self.stdout = sys.stdout
+
+    def write(self, message):
+        self.stdout.write(message)  # 输出到控制台
+        self.file.write(message)  # 写入文件
+        self.file.flush()  # 实时刷新
+
+    def flush(self):
+        self.stdout.flush()
+        self.file.flush()
+
+    def close(self):
+        self.file.close()
+
+
+def setup_pipeline(model_id, compile_config=None):
+    """设置pipeline"""
+    print(f"\n{'=' * 60}")
+    print(f"设置 Pipeline: {compile_config['name'] if compile_config else 'No Compile'}")
+    print(f"{'=' * 60}")
+
+    # 加载模型
+    transformer = HeliosTransformer3DModel.from_pretrained(
+        model_id, subfolder="transformer", torch_dtype=torch.bfloat16, use_default_loader=True
+    )
+    transformer = replace_rmsnorm_with_fp32(transformer)
+    transformer = replace_all_norms_with_flash_norms(transformer)
+    replace_rope_with_flash_rope()
+
+    vae = AutoencoderKLWan.from_pretrained(model_id, subfolder="vae", torch_dtype=torch.float32)
+    pipe = WanPipeline.from_pretrained(model_id, vae=vae, transformer=transformer, torch_dtype=torch.bfloat16)
+
+    pipe.transformer.set_attention_backend("_flash_3_hub")
+    pipe.to("cuda")
+
+    # 应用compile配置
+    if compile_config:
+        print(f"应用编译配置: {compile_config['kwargs']}")
+        pipe.transformer.compile(**compile_config["kwargs"])
+
+    return pipe
+
+
+def run_benchmark(pipe, prompt, negative_prompt, num_runs=3, warmup=1):
+    """运行基准测试"""
+    times = []
+
+    # Warmup
+    print(f"\n预热运行 {warmup} 次...")
+    for i in range(warmup):
+        print(f"  预热 {i + 1}/{warmup}")
+        _ = pipe(
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            height=384,
+            width=640,
+            num_frames=45,
+            guidance_scale=5.0,
+            num_inference_steps=50,
+            generator=torch.Generator(device="cuda").manual_seed(42),
+        ).frames[0]
+        torch.cuda.empty_cache()
+
+    # 实际测试
+    print(f"\n开始基准测试 {num_runs} 次...")
+    for i in range(num_runs):
+        print(f"  运行 {i + 1}/{num_runs}")
+        start = time.time()
+        torch.cuda.synchronize()
+
+        _ = pipe(
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            height=384,
+            width=640,
+            num_frames=45,
+            guidance_scale=5.0,
+            num_inference_steps=50,
+            generator=torch.Generator(device="cuda").manual_seed(42),
+        ).frames[0]
+
+        torch.cuda.synchronize()
+        elapsed = time.time() - start
+        times.append(elapsed)
+        print(f"    耗时: {elapsed:.2f}秒")
+        torch.cuda.empty_cache()
+
+    return times
+
+
+def main():
+    # 创建日志文件
+    # timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    log_filename = "benchmark_compile_results.txt"
+
+    # 创建双输出日志器
+    logger = DualLogger(log_filename)
+    original_stdout = sys.stdout
+    sys.stdout = logger
+
+    try:
+        # 打印测试信息
+        print("=" * 80)
+        print("PyTorch Compile 模式基准测试")
+        print(f"测试时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        print(f"PyTorch 版本: {torch.__version__}")
+        print(f"CUDA 版本: {torch.version.cuda}")
+        print(f"GPU: {torch.cuda.get_device_name(0)}")
+        print("=" * 80)
+
+        model_id = "Wan-AI/Wan2.1-T2V-1.3B-Diffusers"
+
+        prompt = "A stylish woman walks down a Tokyo street filled with warm glowing neon and animated city signage. She wears a black leather jacket, a long red dress, and black boots, and carries a black purse. She wears sunglasses and red lipstick. She walks confidently and casually. The street is damp and reflective, creating a mirror effect of the colorful lights. Many pedestrians walk about."
+        negative_prompt = "Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality, low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards"
+
+        # 定义不同的compile配置
+        compile_configs = [
+            {"name": "No Compile (Baseline)", "kwargs": None},
+            {"name": "Default Compile", "kwargs": {}},
+            {"name": "Fullgraph Only", "kwargs": {"fullgraph": True}},
+            {
+                "name": "Max-Autotune-No-Cudagraphs + Dynamic",
+                "kwargs": {"mode": "max-autotune-no-cudagraphs", "dynamic": True},
+            },
+            {"name": "Max-Autotune + Fullgraph", "kwargs": {"mode": "max-autotune", "fullgraph": True}},
+            {"name": "Max-Autotune", "kwargs": {"mode": "max-autotune"}},
+            {"name": "Reduce-Overhead", "kwargs": {"mode": "reduce-overhead"}},
+            {"name": "Default Mode", "kwargs": {"mode": "default"}},
+        ]
+
+        results = {}
+
+        # 测试每个配置
+        for config in compile_configs:
+            try:
+                # 清理GPU内存
+                torch.cuda.empty_cache()
+
+                # 设置pipeline
+                if config["kwargs"] is None:
+                    pipe = setup_pipeline(model_id, None)
+                else:
+                    pipe = setup_pipeline(model_id, config)
+
+                # 运行基准测试
+                times = run_benchmark(pipe, prompt, negative_prompt, num_runs=3, warmup=1)
+                results[config["name"]] = times
+
+                # 删除pipeline释放内存
+                del pipe
+                torch.cuda.empty_cache()
+
+            except Exception as e:
+                print(f"\n❌ 配置 '{config['name']}' 失败: {str(e)}")
+                results[config["name"]] = None
+
+        # 打印结果摘要
+        print("\n" + "=" * 80)
+        print("基准测试结果摘要")
+        print("=" * 80)
+        print(f"{'配置':<45} {'平均时间(秒)':<15} {'最小时间(秒)':<15} {'最大时间(秒)':<15}")
+        print("-" * 80)
+
+        sorted_results = []
+        for name, times in results.items():
+            if times:
+                avg_time = sum(times) / len(times)
+                min_time = min(times)
+                max_time = max(times)
+                sorted_results.append((name, avg_time, min_time, max_time, times))
+                print(f"{name:<45} {avg_time:<15.2f} {min_time:<15.2f} {max_time:<15.2f}")
+            else:
+                print(f"{name:<45} {'FAILED':<15} {'FAILED':<15} {'FAILED':<15}")
+
+        # 按平均时间排序
+        if sorted_results:
+            sorted_results.sort(key=lambda x: x[1])
+            print("\n" + "=" * 80)
+            print("速度排名 (从快到慢)")
+            print("=" * 80)
+            baseline_time = sorted_results[-1][1]
+            for rank, (name, avg_time, min_time, max_time, times) in enumerate(sorted_results, 1):
+                speedup = baseline_time / avg_time if avg_time > 0 else 0
+                print(f"\n{rank}. {name}")
+                print(f"   平均时间: {avg_time:.2f}秒")
+                print(f"   相对最慢提速: {speedup:.2f}x")
+                print(f"   详细时间: {[f'{t:.2f}s' for t in times]}")
+
+        print("\n" + "=" * 80)
+        print(f"测试完成! 结果已保存到: {log_filename}")
+        print("=" * 80)
+
+    except Exception as e:
+        print(f"\n❌ 测试过程出错: {str(e)}")
+        import traceback
+
+        traceback.print_exc()
+
+    finally:
+        # 恢复标准输出并关闭文件
+        sys.stdout = original_stdout
+        logger.close()
+        print(f"\n✅ 测试完成! 结果已保存到: {log_filename}")
+
+
+if __name__ == "__main__":
+    main()

Helios/_DEV/tools/others/benchmark/benchmark_compile_results.txt

@@ -0,0 +1,269 @@
+================================================================================
+PyTorch Compile 模式基准测试
+测试时间: 2026-01-25 16:09:44
+PyTorch 版本: 2.7.1+cu126
+CUDA 版本: 12.6
+GPU: NVIDIA H100 80GB HBM3
+================================================================================
+
+============================================================
+设置 Pipeline: No Compile
+============================================================
+Patched 120 FP32_RMSNorm modules
+
+Patched 30 Flash_LayerNorm modules
+
+Patched 120 Flash_RMSNorm modules
+
+Patched Flash_RoPE globally
+
+
+预热运行 1 次...
+  预热 1/1
+
+开始基准测试 3 次...
+  运行 1/3
+    耗时: 17.15秒
+  运行 2/3
+    耗时: 17.14秒
+  运行 3/3
+    耗时: 17.19秒
+
+============================================================
+设置 Pipeline: Default Compile
+============================================================
+Patched 120 FP32_RMSNorm modules
+
+Patched 30 Flash_LayerNorm modules
+
+Patched 120 Flash_RMSNorm modules
+
+Patched Flash_RoPE globally
+
+应用编译配置: {}
+
+预热运行 1 次...
+  预热 1/1
+
+开始基准测试 3 次...
+  运行 1/3
+    耗时: 12.80秒
+  运行 2/3
+    耗时: 12.79秒
+  运行 3/3
+    耗时: 12.79秒
+
+============================================================
+设置 Pipeline: Fullgraph Only
+============================================================
+Patched 120 FP32_RMSNorm modules
+
+Patched 30 Flash_LayerNorm modules
+
+Patched 120 Flash_RMSNorm modules
+
+Patched Flash_RoPE globally
+
+应用编译配置: {'fullgraph': True}
+
+预热运行 1 次...
+  预热 1/1
+
+开始基准测试 3 次...
+  运行 1/3
+    耗时: 12.79秒
+  运行 2/3
+    耗时: 12.80秒
+  运行 3/3
+    耗时: 12.80秒
+
+============================================================
+设置 Pipeline: Max-Autotune-No-Cudagraphs + Dynamic
+============================================================
+Patched 120 FP32_RMSNorm modules
+
+Patched 30 Flash_LayerNorm modules
+
+Patched 120 Flash_RMSNorm modules
+
+Patched Flash_RoPE globally
+
+应用编译配置: {'mode': 'max-autotune-no-cudagraphs', 'dynamic': True}
+
+预热运行 1 次...
+  预热 1/1
+
+开始基准测试 3 次...
+  运行 1/3
+    耗时: 12.61秒
+  运行 2/3
+    耗时: 12.63秒
+  运行 3/3
+    耗时: 12.63秒
+
+============================================================
+设置 Pipeline: Max-Autotune + Fullgraph
+============================================================
+Patched 120 FP32_RMSNorm modules
+
+Patched 30 Flash_LayerNorm modules
+
+Patched 120 Flash_RMSNorm modules
+
+Patched Flash_RoPE globally
+
+应用编译配置: {'mode': 'max-autotune', 'fullgraph': True}
+
+预热运行 1 次...
+  预热 1/1
+
+❌ 配置 'Max-Autotune + Fullgraph' 失败: Skip calling `torch.compiler.disable()`d function
+  Explanation: Skip calling function `<function flash_rms_layernorm at 0x7fe108a128e0>` since it was wrapped with `torch.compiler.disable`
+  Hint: Remove the `torch.compiler.disable` call
+
+  Developer debug context: <function flash_rms_layernorm at 0x7fe108a128e0>
+
+
+from user code:
+   File "transformer_helios.py", line 999, in forward
+    attn_output = self.attn1(
+  File "transformer_helios.py", line 737, in forward
+    return self.processor(
+  File "transformer_helios.py", line 360, in __call__
+    query = attn.norm_q(query)
+  File "/usr/local/lib/python3.11/dist-packages/torch/nn/modules/module.py", line 1762, in _call_impl
+    return forward_call(*args, **kwargs)
+  File "kernels/triton_norm.py", line 29, in <lambda>
+    module.forward = (lambda self, x: flash_rms_layernorm(self, x)).__get__(module, module.__class__)
+
+Set TORCHDYNAMO_VERBOSE=1 for the internal stack trace (please do this especially if you're reporting a bug to PyTorch). For even more developer context, set TORCH_LOGS="+dynamo"
+
+
+============================================================
+设置 Pipeline: Max-Autotune
+============================================================
+Patched 120 FP32_RMSNorm modules
+
+Patched 30 Flash_LayerNorm modules
+
+Patched 120 Flash_RMSNorm modules
+
+Patched Flash_RoPE globally
+
+应用编译配置: {'mode': 'max-autotune'}
+
+预热运行 1 次...
+  预热 1/1
+
+开始基准测试 3 次...
+  运行 1/3
+    耗时: 13.02秒
+  运行 2/3
+    耗时: 13.02秒
+  运行 3/3
+    耗时: 13.03秒
+
+============================================================
+设置 Pipeline: Reduce-Overhead
+============================================================
+Patched 120 FP32_RMSNorm modules
+
+Patched 30 Flash_LayerNorm modules
+
+Patched 120 Flash_RMSNorm modules
+
+Patched Flash_RoPE globally
+
+应用编译配置: {'mode': 'reduce-overhead'}
+
+预热运行 1 次...
+  预热 1/1
+
+开始基准测试 3 次...
+  运行 1/3
+    耗时: 13.24秒
+  运行 2/3
+    耗时: 13.24秒
+  运行 3/3
+    耗时: 13.26秒
+
+============================================================
+设置 Pipeline: Default Mode
+============================================================
+Patched 120 FP32_RMSNorm modules
+
+Patched 30 Flash_LayerNorm modules
+
+Patched 120 Flash_RMSNorm modules
+
+Patched Flash_RoPE globally
+
+应用编译配置: {'mode': 'default'}
+
+预热运行 1 次...
+  预热 1/1
+
+开始基准测试 3 次...
+  运行 1/3
+    耗时: 12.74秒
+  运行 2/3
+    耗时: 12.68秒
+  运行 3/3
+    耗时: 12.75秒
+
+================================================================================
+基准测试结果摘要
+================================================================================
+配置                                            平均时间(秒)         最小时间(秒)         最大时间(秒)        
+--------------------------------------------------------------------------------
+No Compile (Baseline)                         17.16           17.14           17.19          
+Default Compile                               12.79           12.79           12.80          
+Fullgraph Only                                12.80           12.79           12.80          
+Max-Autotune-No-Cudagraphs + Dynamic          12.62           12.61           12.63          
+Max-Autotune + Fullgraph                      FAILED          FAILED          FAILED         
+Max-Autotune                                  13.02           13.02           13.03          
+Reduce-Overhead                               13.25           13.24           13.26          
+Default Mode                                  12.72           12.68           12.75          
+
+================================================================================
+速度排名 (从快到慢)
+================================================================================
+
+1. Max-Autotune-No-Cudagraphs + Dynamic
+   平均时间: 12.62秒
+   相对最慢提速: 1.36x
+   详细时间: ['12.61s', '12.63s', '12.63s']
+
+2. Default Mode
+   平均时间: 12.72秒
+   相对最慢提速: 1.35x
+   详细时间: ['12.74s', '12.68s', '12.75s']
+
+3. Default Compile
+   平均时间: 12.79秒
+   相对最慢提速: 1.34x
+   详细时间: ['12.80s', '12.79s', '12.79s']
+
+4. Fullgraph Only
+   平均时间: 12.80秒
+   相对最慢提速: 1.34x
+   详细时间: ['12.79s', '12.80s', '12.80s']
+
+5. Max-Autotune
+   平均时间: 13.02秒
+   相对最慢提速: 1.32x
+   详细时间: ['13.02s', '13.02s', '13.03s']
+
+6. Reduce-Overhead
+   平均时间: 13.25秒
+   相对最慢提速: 1.30x
+   详细时间: ['13.24s', '13.24s', '13.26s']
+
+7. No Compile (Baseline)
+   平均时间: 17.16秒
+   相对最慢提速: 1.00x
+   详细时间: ['17.15s', '17.14s', '17.19s']
+
+================================================================================
+测试完成! 结果已保存到: compile_benchmark_results_20260125_160944.txt
+================================================================================

Helios/_DEV/tools/others/benchmark/benchmark_patchification_performance.py

@@ -0,0 +1,381 @@
+import os
+
+
+os.environ["DIFFUSERS_ENABLE_HUB_KERNELS"] = "yes"
+
+import json
+import time
+from datetime import datetime
+
+import torch
+
+from diffusers import WanTransformer3DModel
+
+
+# 加载transformer
+model_id = "Wan-AI/Wan2.1-T2V-14B-Diffusers"
+transformer = WanTransformer3DModel.from_pretrained(model_id, subfolder="transformer", torch_dtype=torch.bfloat16)
+transformer.enable_gradient_checkpointing()
+transformer.set_attention_backend("_flash_3_hub")
+transformer.to("cuda")
+
+noise_per_token = 960
+noise_total_token = noise_per_token * 9
+
+his_tokens = [960, 1920, 3840, 5760, 7680, 9600, 11520, 13440, 15360, 17280]
+his_tokens_naive = [960, 1920, 2160, 2190, 2220, 2250, 2280, 2310, 2340, 2370]
+
+benchmark_results = {
+    "timestamp": datetime.now().isoformat(),
+    "noise_total_token": noise_total_token,
+    "experiments": [],
+}
+
+
+def create_dummy_inputs(transformer, num_frames, height=384, width=640, requires_grad=False):
+    """创建transformer的dummy输入"""
+    batch_size = 1
+    device = transformer.device
+    dtype = transformer.dtype
+
+    # hidden_states: [B, C, F, H, W]
+    in_channels = transformer.config.in_channels
+    latent_h = height // 8
+    latent_w = width // 8
+    latent_f = num_frames
+
+    hidden_states = torch.randn(
+        batch_size, in_channels, latent_f, latent_h, latent_w, device=device, dtype=dtype, requires_grad=requires_grad
+    )
+
+    # timestep
+    timestep = torch.tensor([999], device=device, dtype=torch.long)
+    timestep = timestep.expand(batch_size)
+
+    # encoder_hidden_states
+    seq_len = 512
+    hidden_dim = 4096
+    encoder_hidden_states = torch.randn(batch_size, seq_len, hidden_dim, device=device, dtype=dtype)
+
+    return hidden_states, timestep, encoder_hidden_states
+
+
+def measure_inference_speed(transformer, hidden_states, timestep, encoder_hidden_states, num_runs=10):
+    """测量推理速度(单步)"""
+    try:
+        # 预热
+        for _ in range(3):
+            with torch.no_grad():
+                _ = transformer(
+                    hidden_states=hidden_states,
+                    timestep=timestep,
+                    encoder_hidden_states=encoder_hidden_states,
+                    return_dict=True,
+                )
+        torch.cuda.synchronize()
+
+        # 正式测速
+        times = []
+        for _ in range(num_runs):
+            torch.cuda.synchronize()
+            start_time = time.time()
+
+            with torch.no_grad():
+                _ = transformer(
+                    hidden_states=hidden_states,
+                    timestep=timestep,
+                    encoder_hidden_states=encoder_hidden_states,
+                    return_dict=True,
+                )
+
+            torch.cuda.synchronize()
+            end_time = time.time()
+            times.append(end_time - start_time)
+
+        return {
+            "avg_time_s": round(sum(times) / len(times), 4),
+            "min_time_s": round(min(times), 4),
+            "max_time_s": round(max(times), 4),
+            "std_time_s": round(torch.std(torch.tensor(times)).item(), 4),
+            "status": "success",
+        }
+    except RuntimeError as e:
+        if "out of memory" in str(e).lower():
+            torch.cuda.empty_cache()
+            return {"status": "OOM", "error": str(e)}
+        else:
+            raise
+
+
+def measure_inference_memory(transformer, hidden_states, timestep, encoder_hidden_states):
+    """测量推理显存"""
+    try:
+        torch.cuda.reset_peak_memory_stats()
+        torch.cuda.empty_cache()
+        torch.cuda.synchronize()
+        mem_before = torch.cuda.memory_allocated() / 1024**3
+
+        # Forward (推理模式)
+        torch.cuda.reset_peak_memory_stats()
+        with torch.no_grad():
+            _ = transformer(
+                hidden_states=hidden_states,
+                timestep=timestep,
+                encoder_hidden_states=encoder_hidden_states,
+                return_dict=True,
+                attention_kwargs=None,
+            )
+        torch.cuda.synchronize()
+
+        inference_peak = torch.cuda.max_memory_allocated() / 1024**3
+        inference_mem_diff = inference_peak - mem_before
+
+        return {
+            "mem_before_gb": round(mem_before, 3),
+            "inference_peak_gb": round(inference_peak, 3),
+            "inference_mem_diff_gb": round(inference_mem_diff, 3),
+            "status": "success",
+        }
+    except RuntimeError as e:
+        if "out of memory" in str(e).lower():
+            torch.cuda.empty_cache()
+            return {"status": "OOM", "error": str(e)}
+        else:
+            raise
+
+
+def measure_training_memory(transformer, hidden_states, timestep, encoder_hidden_states):
+    """测量训练显存(包含backward)"""
+    try:
+        torch.cuda.reset_peak_memory_stats()
+        torch.cuda.empty_cache()
+        torch.cuda.synchronize()
+        mem_before = torch.cuda.memory_allocated() / 1024**3
+
+        # Forward + Backward (训练模式)
+        torch.cuda.reset_peak_memory_stats()
+
+        # Forward
+        output = transformer(
+            hidden_states=hidden_states,
+            timestep=timestep,
+            encoder_hidden_states=encoder_hidden_states,
+            return_dict=True,
+            attention_kwargs=None,
+        )
+
+        # 创建一个简单的loss并backward
+        loss = output.sample.sum()
+        loss.backward()
+
+        torch.cuda.synchronize()
+
+        training_peak = torch.cuda.max_memory_allocated() / 1024**3
+        training_mem_diff = training_peak - mem_before
+
+        # 清理梯度
+        transformer.zero_grad(set_to_none=True)
+
+        return {
+            "mem_before_gb": round(mem_before, 3),
+            "training_peak_gb": round(training_peak, 3),
+            "training_mem_diff_gb": round(training_mem_diff, 3),
+            "status": "success",
+        }
+    except RuntimeError as e:
+        if "out of memory" in str(e).lower():
+            torch.cuda.empty_cache()
+            transformer.zero_grad(set_to_none=True)
+            return {"status": "OOM", "error": str(e)}
+        else:
+            raise
+
+
+def warmup(transformer, num_runs=3):
+    """预热"""
+    print("🔥 Warming up...")
+    for i in range(num_runs):
+        hidden_states, timestep, encoder_hidden_states = create_dummy_inputs(transformer, num_frames=5)
+        with torch.no_grad():
+            _ = transformer(
+                hidden_states=hidden_states,
+                timestep=timestep,
+                encoder_hidden_states=encoder_hidden_states,
+                return_dict=True,
+            )
+        print(f"  Warmup {i + 1}/{num_runs} done")
+    torch.cuda.empty_cache()
+    print("✅ Warmup completed\n")
+
+
+def run_experiment(his_tokens_list, experiment_name):
+    """运行完整实验"""
+    results = []
+
+    for his_token in his_tokens_list:
+        torch.cuda.reset_peak_memory_stats()
+        torch.cuda.empty_cache()
+
+        total_token = his_token + noise_total_token
+        num_frames = round((total_token / noise_per_token - 1) * 4 + 1)
+
+        print(f"\n{'=' * 60}")
+        print(f"{experiment_name} | tokens: {his_token} | frames: {int(num_frames)}")
+        print(f"{'=' * 60}")
+
+        result = {
+            "his_token": his_token,
+            "total_token": total_token,
+            "num_frames": int(num_frames),
+        }
+
+        # 1. 测推理速度 (不需要梯度)
+        print("📊 Measuring inference speed...")
+        try:
+            hidden_states, timestep, encoder_hidden_states = create_dummy_inputs(
+                transformer, num_frames, requires_grad=False
+            )
+            speed_stats = measure_inference_speed(transformer, hidden_states, timestep, encoder_hidden_states)
+
+            if speed_stats["status"] == "OOM":
+                print("   ❌ OOM - Skipping remaining tests for this config")
+                result.update({"speed_status": "OOM", "inference_status": "SKIPPED", "training_status": "SKIPPED"})
+                results.append(result)
+                del hidden_states, timestep, encoder_hidden_states
+                torch.cuda.empty_cache()
+                continue
+            else:
+                print(
+                    f"   Avg: {speed_stats['avg_time_s']:.4f}s | "
+                    f"Min: {speed_stats['min_time_s']:.4f}s | "
+                    f"Max: {speed_stats['max_time_s']:.4f}s"
+                )
+                result.update(speed_stats)
+
+            del hidden_states, timestep, encoder_hidden_states
+            torch.cuda.empty_cache()
+        except Exception as e:
+            print(f"   ❌ Error: {e}")
+            result["speed_status"] = "ERROR"
+            torch.cuda.empty_cache()
+
+        # 2. 测推理显存 (不需要梯度)
+        print("💾 Measuring inference memory...")
+        try:
+            hidden_states, timestep, encoder_hidden_states = create_dummy_inputs(
+                transformer, num_frames, requires_grad=False
+            )
+            inference_mem_stats = measure_inference_memory(transformer, hidden_states, timestep, encoder_hidden_states)
+
+            if inference_mem_stats["status"] == "OOM":
+                print("   ❌ OOM - Skipping training test")
+                result.update(inference_mem_stats)
+                result["training_status"] = "SKIPPED"
+                results.append(result)
+                del hidden_states, timestep, encoder_hidden_states
+                torch.cuda.empty_cache()
+                continue
+            else:
+                print(
+                    f"   Peak: {inference_mem_stats['inference_peak_gb']:.3f} GB | "
+                    f"Diff: {inference_mem_stats['inference_mem_diff_gb']:.3f} GB"
+                )
+                result.update(inference_mem_stats)
+
+            del hidden_states, timestep, encoder_hidden_states
+            torch.cuda.empty_cache()
+        except Exception as e:
+            print(f"   ❌ Error: {e}")
+            result["inference_status"] = "ERROR"
+            torch.cuda.empty_cache()
+
+        # 3. 测训练显存 (需要梯度)
+        print("🔥 Measuring training memory...")
+        try:
+            hidden_states, timestep, encoder_hidden_states = create_dummy_inputs(
+                transformer, num_frames, requires_grad=True
+            )
+            training_mem_stats = measure_training_memory(transformer, hidden_states, timestep, encoder_hidden_states)
+
+            if training_mem_stats["status"] == "OOM":
+                print("   ❌ OOM")
+                result.update(training_mem_stats)
+            else:
+                print(
+                    f"   Peak: {training_mem_stats['training_peak_gb']:.3f} GB | "
+                    f"Diff: {training_mem_stats['training_mem_diff_gb']:.3f} GB"
+                )
+                result.update(training_mem_stats)
+
+            del hidden_states, timestep, encoder_hidden_states
+            torch.cuda.empty_cache()
+        except Exception as e:
+            print(f"   ❌ Error: {e}")
+            result["training_status"] = "ERROR"
+            torch.cuda.empty_cache()
+
+        results.append(result)
+
+    return results
+
+
+# 运行实验
+warmup(transformer)
+
+print("\n" + "=" * 80)
+print("STANDARD EXPERIMENT")
+print("=" * 80)
+results_standard = run_experiment(his_tokens, "Standard")
+
+print("\n" + "=" * 80)
+print("NAIVE EXPERIMENT")
+print("=" * 80)
+results_naive = run_experiment(his_tokens_naive, "Naive")
+
+# 保存结果
+benchmark_results["experiments"] = [
+    {"name": "standard", "results": results_standard},
+    {"name": "naive", "results": results_naive},
+]
+
+output_file = "benchmark_patchification_results.json"
+with open(output_file, "w") as f:
+    json.dump(benchmark_results, f, indent=2)
+
+print("\n" + "=" * 80)
+print(f"✅ Results saved to {output_file}")
+print("=" * 80)
+
+# 打印汇总表格
+print("\n" + "=" * 80)
+print("BENCHMARK SUMMARY")
+print("=" * 80)
+
+for exp in benchmark_results["experiments"]:
+    print(f"\n=== {exp['name'].upper()} ===")
+    print(f"{'Tokens':>6} {'Frames':>6} {'Speed(s)':>10} {'Infer(GB)':>11} {'Train(GB)':>11} {'Status':>10}")
+    print("-" * 72)
+    for r in exp["results"]:
+        speed_str = f"{r.get('avg_time_s', 0):.4f}s" if r.get("status") == "success" else "N/A"
+        infer_str = f"{r.get('inference_mem_diff_gb', 0):.3f}" if r.get("inference_peak_gb") else "N/A"
+        train_str = f"{r.get('training_mem_diff_gb', 0):.3f}" if r.get("training_peak_gb") else "N/A"
+
+        # 判断整体状态
+        if r.get("speed_status") == "OOM":
+            status = "OOM"
+        elif r.get("training_status") == "OOM":
+            status = "OOM(train)"
+        elif r.get("status") == "success":
+            status = "OK"
+        else:
+            status = "PARTIAL"
+
+        print(f"{r['his_token']:6d} {r['num_frames']:6d} {speed_str:>10} {infer_str:>11} {train_str:>11} {status:>10}")
+
+print("\n" + "=" * 80)
+print("Legend:")
+print("  Speed(s)   - Average inference time per step")
+print("  Infer(GB)  - Memory usage during inference (forward only)")
+print("  Train(GB)  - Memory usage during training (forward + backward)")
+print("  Status     - OK/OOM/OOM(train)/PARTIAL")
+print("=" * 80)

Helios/_DEV/tools/others/benchmark/benchmark_patchification_results.json

@@ -0,0 +1,309 @@
+{
+  "timestamp": "2026-02-06T05:34:36.528673",
+  "noise_total_token": 8640,
+  "experiments": [
+    {
+      "name": "standard",
+      "results": [
+        {
+          "his_token": 960,
+          "total_token": 9600,
+          "num_frames": 37,
+          "avg_time_s": 4.1635,
+          "min_time_s": 4.1583,
+          "max_time_s": 4.1741,
+          "std_time_s": 0.0041,
+          "status": "success",
+          "mem_before_gb": 26.787,
+          "inference_peak_gb": 30.565,
+          "inference_mem_diff_gb": 3.778,
+          "training_peak_gb": 68.509,
+          "training_mem_diff_gb": 41.722
+        },
+        {
+          "his_token": 1920,
+          "total_token": 10560,
+          "num_frames": 41,
+          "avg_time_s": 4.7998,
+          "min_time_s": 4.798,
+          "max_time_s": 4.8031,
+          "std_time_s": 0.0013,
+          "status": "success",
+          "mem_before_gb": 26.819,
+          "inference_peak_gb": 31.001,
+          "inference_mem_diff_gb": 4.182,
+          "training_peak_gb": 70.252,
+          "training_mem_diff_gb": 43.433
+        },
+        {
+          "his_token": 3840,
+          "total_token": 12480,
+          "num_frames": 49,
+          "avg_time_s": 6.1835,
+          "min_time_s": 6.1744,
+          "max_time_s": 6.1921,
+          "std_time_s": 0.0049,
+          "status": "success",
+          "mem_before_gb": 26.82,
+          "inference_peak_gb": 31.815,
+          "inference_mem_diff_gb": 4.995,
+          "training_peak_gb": 73.733,
+          "training_mem_diff_gb": 46.913
+        },
+        {
+          "his_token": 5760,
+          "total_token": 14400,
+          "num_frames": 57,
+          "avg_time_s": 7.7019,
+          "min_time_s": 7.6963,
+          "max_time_s": 7.7083,
+          "std_time_s": 0.0039,
+          "status": "OOM",
+          "mem_before_gb": 26.821,
+          "inference_peak_gb": 32.628,
+          "inference_mem_diff_gb": 5.808,
+          "error": "CUDA out of memory. Tried to allocate 1.04 GiB. GPU 0 has a total capacity of 79.11 GiB of which 196.56 MiB is free. Including non-PyTorch memory, this process has 0 bytes memory in use. Of the allocated memory 75.12 GiB is allocated by PyTorch, and 3.04 GiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)"
+        },
+        {
+          "his_token": 7680,
+          "total_token": 16320,
+          "num_frames": 65,
+          "avg_time_s": 9.3743,
+          "min_time_s": 9.3587,
+          "max_time_s": 9.3922,
+          "std_time_s": 0.0092,
+          "status": "OOM",
+          "mem_before_gb": 26.822,
+          "inference_peak_gb": 33.442,
+          "inference_mem_diff_gb": 6.621,
+          "error": "CUDA out of memory. Tried to allocate 1.19 GiB. GPU 0 has a total capacity of 79.11 GiB of which 108.56 MiB is free. Including non-PyTorch memory, this process has 0 bytes memory in use. Of the allocated memory 77.18 GiB is allocated by PyTorch, and 1.07 GiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)"
+        },
+        {
+          "his_token": 9600,
+          "total_token": 18240,
+          "num_frames": 73,
+          "avg_time_s": 11.2228,
+          "min_time_s": 11.2066,
+          "max_time_s": 11.2309,
+          "std_time_s": 0.0076,
+          "status": "OOM",
+          "mem_before_gb": 26.823,
+          "inference_peak_gb": 34.256,
+          "inference_mem_diff_gb": 7.434,
+          "error": "CUDA out of memory. Tried to allocate 1.34 GiB. GPU 0 has a total capacity of 79.11 GiB of which 868.56 MiB is free. Including non-PyTorch memory, this process has 0 bytes memory in use. Of the allocated memory 75.75 GiB is allocated by PyTorch, and 1.76 GiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)"
+        },
+        {
+          "his_token": 11520,
+          "total_token": 20160,
+          "num_frames": 81,
+          "avg_time_s": 13.2451,
+          "min_time_s": 13.2332,
+          "max_time_s": 13.251,
+          "std_time_s": 0.0055,
+          "status": "OOM",
+          "mem_before_gb": 26.824,
+          "inference_peak_gb": 35.071,
+          "inference_mem_diff_gb": 8.248,
+          "error": "CUDA out of memory. Tried to allocate 1.48 GiB. GPU 0 has a total capacity of 79.11 GiB of which 608.56 MiB is free. Including non-PyTorch memory, this process has 0 bytes memory in use. Of the allocated memory 75.14 GiB is allocated by PyTorch, and 2.62 GiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)"
+        },
+        {
+          "his_token": 13440,
+          "total_token": 22080,
+          "num_frames": 89,
+          "avg_time_s": 15.2558,
+          "min_time_s": 15.24,
+          "max_time_s": 15.2622,
+          "std_time_s": 0.0081,
+          "status": "OOM",
+          "mem_before_gb": 26.825,
+          "inference_peak_gb": 35.885,
+          "inference_mem_diff_gb": 9.06,
+          "error": "CUDA out of memory. Tried to allocate 1.63 GiB. GPU 0 has a total capacity of 79.11 GiB of which 1.36 GiB is free. Including non-PyTorch memory, this process has 0 bytes memory in use. Of the allocated memory 74.19 GiB is allocated by PyTorch, and 2.80 GiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)"
+        },
+        {
+          "his_token": 15360,
+          "total_token": 24000,
+          "num_frames": 97,
+          "avg_time_s": 17.5647,
+          "min_time_s": 17.5502,
+          "max_time_s": 17.5807,
+          "std_time_s": 0.0095,
+          "status": "OOM",
+          "mem_before_gb": 26.825,
+          "inference_peak_gb": 36.699,
+          "inference_mem_diff_gb": 9.873,
+          "error": "CUDA out of memory. Tried to allocate 1.78 GiB. GPU 0 has a total capacity of 79.11 GiB of which 1.39 GiB is free. Including non-PyTorch memory, this process has 0 bytes memory in use. Of the allocated memory 74.90 GiB is allocated by PyTorch, and 2.07 GiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)"
+        },
+        {
+          "his_token": 17280,
+          "total_token": 25920,
+          "num_frames": 105,
+          "avg_time_s": 20.0106,
+          "min_time_s": 19.9988,
+          "max_time_s": 20.0365,
+          "std_time_s": 0.012,
+          "status": "OOM",
+          "mem_before_gb": 26.826,
+          "inference_peak_gb": 37.512,
+          "inference_mem_diff_gb": 10.686,
+          "error": "CUDA out of memory. Tried to allocate 1.92 GiB. GPU 0 has a total capacity of 79.11 GiB of which 1.18 GiB is free. Including non-PyTorch memory, this process has 0 bytes memory in use. Of the allocated memory 70.20 GiB is allocated by PyTorch, and 6.99 GiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)"
+        }
+      ]
+    },
+    {
+      "name": "naive",
+      "results": [
+        {
+          "his_token": 960,
+          "total_token": 9600,
+          "num_frames": 37,
+          "avg_time_s": 4.1671,
+          "min_time_s": 4.1616,
+          "max_time_s": 4.171,
+          "std_time_s": 0.0032,
+          "status": "success",
+          "mem_before_gb": 26.818,
+          "inference_peak_gb": 30.595,
+          "inference_mem_diff_gb": 3.777,
+          "training_peak_gb": 68.509,
+          "training_mem_diff_gb": 41.69
+        },
+        {
+          "his_token": 1920,
+          "total_token": 10560,
+          "num_frames": 41,
+          "avg_time_s": 4.8,
+          "min_time_s": 4.7986,
+          "max_time_s": 4.8014,
+          "std_time_s": 0.0009,
+          "status": "success",
+          "mem_before_gb": 26.819,
+          "inference_peak_gb": 31.001,
+          "inference_mem_diff_gb": 4.182,
+          "training_peak_gb": 70.252,
+          "training_mem_diff_gb": 43.433
+        },
+        {
+          "his_token": 2160,
+          "total_token": 10800,
+          "num_frames": 42,
+          "avg_time_s": 4.9164,
+          "min_time_s": 4.9075,
+          "max_time_s": 4.9335,
+          "std_time_s": 0.0082,
+          "status": "success",
+          "mem_before_gb": 26.819,
+          "inference_peak_gb": 31.105,
+          "inference_mem_diff_gb": 4.286,
+          "training_peak_gb": 70.689,
+          "training_mem_diff_gb": 43.87
+        },
+        {
+          "his_token": 2190,
+          "total_token": 10830,
+          "num_frames": 42,
+          "avg_time_s": 4.9196,
+          "min_time_s": 4.9037,
+          "max_time_s": 4.9359,
+          "std_time_s": 0.0105,
+          "status": "success",
+          "mem_before_gb": 26.819,
+          "inference_peak_gb": 31.105,
+          "inference_mem_diff_gb": 4.286,
+          "training_peak_gb": 70.689,
+          "training_mem_diff_gb": 43.87
+        },
+        {
+          "his_token": 2220,
+          "total_token": 10860,
+          "num_frames": 42,
+          "avg_time_s": 4.9201,
+          "min_time_s": 4.9098,
+          "max_time_s": 4.9369,
+          "std_time_s": 0.0086,
+          "status": "success",
+          "mem_before_gb": 26.819,
+          "inference_peak_gb": 31.105,
+          "inference_mem_diff_gb": 4.286,
+          "training_peak_gb": 70.689,
+          "training_mem_diff_gb": 43.87
+        },
+        {
+          "his_token": 2250,
+          "total_token": 10890,
+          "num_frames": 42,
+          "avg_time_s": 4.9168,
+          "min_time_s": 4.9079,
+          "max_time_s": 4.9294,
+          "std_time_s": 0.0073,
+          "status": "success",
+          "mem_before_gb": 26.819,
+          "inference_peak_gb": 31.105,
+          "inference_mem_diff_gb": 4.286,
+          "training_peak_gb": 70.689,
+          "training_mem_diff_gb": 43.87
+        },
+        {
+          "his_token": 2280,
+          "total_token": 10920,
+          "num_frames": 42,
+          "avg_time_s": 4.9187,
+          "min_time_s": 4.9082,
+          "max_time_s": 4.9277,
+          "std_time_s": 0.0058,
+          "status": "success",
+          "mem_before_gb": 26.819,
+          "inference_peak_gb": 31.105,
+          "inference_mem_diff_gb": 4.286,
+          "training_peak_gb": 70.689,
+          "training_mem_diff_gb": 43.87
+        },
+        {
+          "his_token": 2310,
+          "total_token": 10950,
+          "num_frames": 43,
+          "avg_time_s": 5.1375,
+          "min_time_s": 5.1308,
+          "max_time_s": 5.1426,
+          "std_time_s": 0.0039,
+          "status": "success",
+          "mem_before_gb": 26.819,
+          "inference_peak_gb": 31.205,
+          "inference_mem_diff_gb": 4.386,
+          "training_peak_gb": 71.118,
+          "training_mem_diff_gb": 44.298
+        },
+        {
+          "his_token": 2340,
+          "total_token": 10980,
+          "num_frames": 43,
+          "avg_time_s": 5.1378,
+          "min_time_s": 5.1338,
+          "max_time_s": 5.1434,
+          "std_time_s": 0.0036,
+          "status": "success",
+          "mem_before_gb": 26.819,
+          "inference_peak_gb": 31.205,
+          "inference_mem_diff_gb": 4.386,
+          "training_peak_gb": 71.118,
+          "training_mem_diff_gb": 44.298
+        },
+        {
+          "his_token": 2370,
+          "total_token": 11010,
+          "num_frames": 43,
+          "avg_time_s": 5.1388,
+          "min_time_s": 5.1317,
+          "max_time_s": 5.1453,
+          "std_time_s": 0.0051,
+          "status": "success",
+          "mem_before_gb": 26.819,
+          "inference_peak_gb": 31.205,
+          "inference_mem_diff_gb": 4.386,
+          "training_peak_gb": 71.118,
+          "training_mem_diff_gb": 44.298
+        }
+      ]
+    }
+  ]
+}

Helios/_DEV/tools/others/benchmark/benchmark_triton_performance.py

@@ -0,0 +1,659 @@
+import os
+
+
+os.environ["HF_ENABLE_PARALLEL_LOADING"] = "yes"
+os.environ["DIFFUSERS_ENABLE_HUB_KERNELS"] = "yes"
+
+import json
+import time
+from datetime import datetime
+
+import torch
+from helios.modules.kernels import (
+    replace_all_norms_with_flash_norms,
+    replace_linear_with_tiled_linear,
+    replace_rope_with_flash_rope,
+)
+from helios.modules.transformer_helios import HeliosTransformer3DModel
+
+from diffusers.training_utils import free_memory
+
+
+# ============================================================================
+# 配置参数
+# ============================================================================
+model_id = "Wan-AI/Wan2.1-T2V-14B-Diffusers"
+TEST_NUM_FRAMES = 21
+NUM_SPEED_RUNS = 10  # 速度测试的运行次数
+HEIGHT = 384
+WIDTH = 640
+
+benchmark_results = {
+    "timestamp": datetime.now().isoformat(),
+    "test_config": {"num_frames": TEST_NUM_FRAMES, "height": HEIGHT, "width": WIDTH, "num_speed_runs": NUM_SPEED_RUNS},
+    "experiments": [],
+}
+
+
+# ============================================================================
+# 辅助函数
+# ============================================================================
+def create_dummy_inputs(transformer, num_frames, height=384, width=640, requires_grad=False):
+    """创建transformer的dummy输入"""
+    batch_size = 1
+    device = transformer.device
+    dtype = transformer.dtype
+
+    in_channels = transformer.config.in_channels
+    latent_h = height // 8
+    latent_w = width // 8
+    latent_f = num_frames
+
+    hidden_states = torch.randn(
+        batch_size, in_channels, latent_f, latent_h, latent_w, device=device, dtype=dtype, requires_grad=requires_grad
+    )
+
+    timestep = torch.tensor([999], device=device, dtype=torch.long)
+    timestep = timestep.expand(batch_size)
+
+    seq_len = 512
+    hidden_dim = 4096
+    encoder_hidden_states = torch.randn(batch_size, seq_len, hidden_dim, device=device, dtype=dtype)
+
+    return hidden_states, timestep, encoder_hidden_states
+
+
+def measure_inference_speed(transformer, hidden_states, timestep, encoder_hidden_states, num_runs=10):
+    """测量推理速度"""
+    try:
+        # 预热
+        for _ in range(3):
+            with torch.no_grad():
+                _ = transformer(
+                    hidden_states=hidden_states,
+                    timestep=timestep,
+                    encoder_hidden_states=encoder_hidden_states,
+                    return_dict=False,
+                )[0]
+        torch.cuda.synchronize()
+
+        # 正式测速
+        times = []
+        for _ in range(num_runs):
+            torch.cuda.synchronize()
+            start_time = time.time()
+
+            with torch.no_grad():
+                _ = transformer(
+                    hidden_states=hidden_states,
+                    timestep=timestep,
+                    encoder_hidden_states=encoder_hidden_states,
+                    return_dict=False,
+                )[0]
+
+            torch.cuda.synchronize()
+            end_time = time.time()
+            times.append(end_time - start_time)
+
+        return {
+            "avg_time_s": round(sum(times) / len(times), 4),
+            "min_time_s": round(min(times), 4),
+            "max_time_s": round(max(times), 4),
+            "std_time_s": round(torch.std(torch.tensor(times)).item(), 4),
+            "status": "success",
+        }
+    except RuntimeError as e:
+        if "out of memory" in str(e).lower():
+            torch.cuda.empty_cache()
+            free_memory()
+            return {"status": "OOM", "error": str(e)}
+        else:
+            raise
+
+
+def measure_inference_memory(transformer, hidden_states, timestep, encoder_hidden_states):
+    """测量推理显存"""
+    try:
+        torch.cuda.reset_peak_memory_stats()
+        torch.cuda.empty_cache()
+        free_memory()
+        torch.cuda.synchronize()
+        mem_before = torch.cuda.memory_allocated() / 1024**3
+
+        torch.cuda.reset_peak_memory_stats()
+        with torch.no_grad():
+            _ = transformer(
+                hidden_states=hidden_states,
+                timestep=timestep,
+                encoder_hidden_states=encoder_hidden_states,
+                return_dict=False,
+                attention_kwargs=None,
+            )[0]
+        torch.cuda.synchronize()
+
+        inference_peak = torch.cuda.max_memory_allocated() / 1024**3
+        inference_mem_diff = inference_peak - mem_before
+
+        return {
+            "mem_before_gb": round(mem_before, 3),
+            "inference_peak_gb": round(inference_peak, 3),
+            "inference_mem_diff_gb": round(inference_mem_diff, 3),
+            "status": "success",
+        }
+    except RuntimeError as e:
+        if "out of memory" in str(e).lower():
+            torch.cuda.empty_cache()
+            free_memory()
+            return {"status": "OOM", "error": str(e)}
+        else:
+            raise
+
+
+def measure_training_speed(transformer, hidden_states, timestep, encoder_hidden_states, num_runs=10):
+    """测量训练速度(forward + backward)"""
+    try:
+        # 预热
+        for _ in range(3):
+            output = transformer(
+                hidden_states=hidden_states,
+                timestep=timestep,
+                encoder_hidden_states=encoder_hidden_states,
+                return_dict=False,
+            )[0]
+            loss = output.sum()
+            loss.backward()
+            transformer.zero_grad(set_to_none=True)
+        torch.cuda.synchronize()
+
+        # 正式测速
+        times = []
+        for _ in range(num_runs):
+            torch.cuda.synchronize()
+            start_time = time.time()
+
+            output = transformer(
+                hidden_states=hidden_states,
+                timestep=timestep,
+                encoder_hidden_states=encoder_hidden_states,
+                return_dict=False,
+            )[0]
+            loss = output.sum()
+            loss.backward()
+            transformer.zero_grad(set_to_none=True)
+
+            torch.cuda.synchronize()
+            end_time = time.time()
+            times.append(end_time - start_time)
+
+        return {
+            "avg_time_s": round(sum(times) / len(times), 4),
+            "min_time_s": round(min(times), 4),
+            "max_time_s": round(max(times), 4),
+            "std_time_s": round(torch.std(torch.tensor(times)).item(), 4),
+            "status": "success",
+        }
+    except RuntimeError as e:
+        if "out of memory" in str(e).lower():
+            torch.cuda.empty_cache()
+            free_memory()
+            transformer.zero_grad(set_to_none=True)
+            return {"status": "OOM", "error": str(e)}
+        else:
+            raise
+
+
+def measure_training_memory(transformer, hidden_states, timestep, encoder_hidden_states):
+    """测量训练显存(forward + backward)"""
+    try:
+        torch.cuda.reset_peak_memory_stats()
+        torch.cuda.empty_cache()
+        free_memory()
+        torch.cuda.synchronize()
+        mem_before = torch.cuda.memory_allocated() / 1024**3
+
+        torch.cuda.reset_peak_memory_stats()
+
+        output = transformer(
+            hidden_states=hidden_states,
+            timestep=timestep,
+            encoder_hidden_states=encoder_hidden_states,
+            return_dict=False,
+            attention_kwargs=None,
+        )[0]
+
+        loss = output.sum()
+        loss.backward()
+
+        torch.cuda.synchronize()
+
+        training_peak = torch.cuda.max_memory_allocated() / 1024**3
+        training_mem_diff = training_peak - mem_before
+
+        transformer.zero_grad(set_to_none=True)
+
+        return {
+            "mem_before_gb": round(mem_before, 3),
+            "training_peak_gb": round(training_peak, 3),
+            "training_mem_diff_gb": round(training_mem_diff, 3),
+            "status": "success",
+        }
+    except RuntimeError as e:
+        if "out of memory" in str(e).lower():
+            torch.cuda.empty_cache()
+            free_memory()
+            transformer.zero_grad(set_to_none=True)
+            return {"status": "OOM", "error": str(e)}
+        else:
+            raise
+
+
+def run_single_config(transformer, config_name, num_frames):
+    """运行单个配置的完整测试"""
+    print(f"\n{'=' * 70}")
+    print(f"Testing: {config_name}")
+    print(f"{'=' * 70}")
+
+    result = {"config": config_name, "num_frames": num_frames}
+
+    # 1. 测推理速度
+    print("📊 Measuring inference speed...")
+    try:
+        hidden_states, timestep, encoder_hidden_states = create_dummy_inputs(
+            transformer, num_frames, HEIGHT, WIDTH, requires_grad=False
+        )
+        speed_stats = measure_inference_speed(
+            transformer, hidden_states, timestep, encoder_hidden_states, NUM_SPEED_RUNS
+        )
+
+        if speed_stats["status"] == "OOM":
+            print("   ❌ OOM - Skipping remaining tests")
+            result.update(
+                {
+                    "inference_speed_status": "OOM",
+                    "inference_memory_status": "SKIPPED",
+                    "training_speed_status": "SKIPPED",
+                    "training_memory_status": "SKIPPED",
+                }
+            )
+            del hidden_states, timestep, encoder_hidden_states
+            torch.cuda.empty_cache()
+            free_memory()
+            return result
+        else:
+            print(
+                f"   ✓ Avg: {speed_stats['avg_time_s']:.4f}s | "
+                f"Min: {speed_stats['min_time_s']:.4f}s | "
+                f"Max: {speed_stats['max_time_s']:.4f}s"
+            )
+            result.update(
+                {
+                    "inference_speed_avg_s": speed_stats["avg_time_s"],
+                    "inference_speed_min_s": speed_stats["min_time_s"],
+                    "inference_speed_max_s": speed_stats["max_time_s"],
+                    "inference_speed_std_s": speed_stats["std_time_s"],
+                    "inference_speed_status": "success",
+                }
+            )
+
+        del hidden_states, timestep, encoder_hidden_states
+        torch.cuda.empty_cache()
+        free_memory()
+    except Exception as e:
+        print(f"   ❌ Error: {e}")
+        result["inference_speed_status"] = "ERROR"
+        torch.cuda.empty_cache()
+        free_memory()
+
+    # 2. 测推理显存
+    print("💾 Measuring inference memory...")
+    try:
+        hidden_states, timestep, encoder_hidden_states = create_dummy_inputs(
+            transformer, num_frames, HEIGHT, WIDTH, requires_grad=False
+        )
+        mem_stats = measure_inference_memory(transformer, hidden_states, timestep, encoder_hidden_states)
+
+        if mem_stats["status"] == "OOM":
+            print("   ❌ OOM - Skipping training tests")
+            result.update(
+                {
+                    "inference_memory_status": "OOM",
+                    "training_speed_status": "SKIPPED",
+                    "training_memory_status": "SKIPPED",
+                }
+            )
+            del hidden_states, timestep, encoder_hidden_states
+            torch.cuda.empty_cache()
+            free_memory()
+            return result
+        else:
+            print(
+                f"   ✓ Peak: {mem_stats['inference_peak_gb']:.3f} GB | "
+                f"Diff: {mem_stats['inference_mem_diff_gb']:.3f} GB"
+            )
+            result.update(
+                {
+                    "inference_memory_peak_gb": mem_stats["inference_peak_gb"],
+                    "inference_memory_diff_gb": mem_stats["inference_mem_diff_gb"],
+                    "inference_memory_status": "success",
+                }
+            )
+
+        del hidden_states, timestep, encoder_hidden_states
+        torch.cuda.empty_cache()
+        free_memory()
+    except Exception as e:
+        print(f"   ❌ Error: {e}")
+        result["inference_memory_status"] = "ERROR"
+        torch.cuda.empty_cache()
+        free_memory()
+
+    # 3. 测训练速度
+    print("⚡ Measuring training speed...")
+    try:
+        hidden_states, timestep, encoder_hidden_states = create_dummy_inputs(
+            transformer, num_frames, HEIGHT, WIDTH, requires_grad=True
+        )
+        train_speed_stats = measure_training_speed(
+            transformer, hidden_states, timestep, encoder_hidden_states, NUM_SPEED_RUNS
+        )
+
+        if train_speed_stats["status"] == "OOM":
+            print("   ❌ OOM")
+            result.update({"training_speed_status": "OOM", "training_memory_status": "SKIPPED"})
+            del hidden_states, timestep, encoder_hidden_states
+            torch.cuda.empty_cache()
+            free_memory()
+            return result
+        else:
+            print(
+                f"   ✓ Avg: {train_speed_stats['avg_time_s']:.4f}s | "
+                f"Min: {train_speed_stats['min_time_s']:.4f}s | "
+                f"Max: {train_speed_stats['max_time_s']:.4f}s"
+            )
+            result.update(
+                {
+                    "training_speed_avg_s": train_speed_stats["avg_time_s"],
+                    "training_speed_min_s": train_speed_stats["min_time_s"],
+                    "training_speed_max_s": train_speed_stats["max_time_s"],
+                    "training_speed_std_s": train_speed_stats["std_time_s"],
+                    "training_speed_status": "success",
+                }
+            )
+
+        del hidden_states, timestep, encoder_hidden_states
+        torch.cuda.empty_cache()
+        free_memory()
+    except Exception as e:
+        print(f"   ❌ Error: {e}")
+        result["training_speed_status"] = "ERROR"
+        torch.cuda.empty_cache()
+        free_memory()
+
+    # 4. 测训练显存
+    print("🔥 Measuring training memory...")
+    try:
+        hidden_states, timestep, encoder_hidden_states = create_dummy_inputs(
+            transformer, num_frames, HEIGHT, WIDTH, requires_grad=True
+        )
+        train_mem_stats = measure_training_memory(transformer, hidden_states, timestep, encoder_hidden_states)
+
+        if train_mem_stats["status"] == "OOM":
+            print("   ❌ OOM")
+            result["training_memory_status"] = "OOM"
+        else:
+            print(
+                f"   ✓ Peak: {train_mem_stats['training_peak_gb']:.3f} GB | "
+                f"Diff: {train_mem_stats['training_mem_diff_gb']:.3f} GB"
+            )
+            result.update(
+                {
+                    "training_memory_peak_gb": train_mem_stats["training_peak_gb"],
+                    "training_memory_diff_gb": train_mem_stats["training_mem_diff_gb"],
+                    "training_memory_status": "success",
+                }
+            )
+
+        del hidden_states, timestep, encoder_hidden_states
+        torch.cuda.empty_cache()
+        free_memory()
+    except Exception as e:
+        print(f"   ❌ Error: {e}")
+        result["training_memory_status"] = "ERROR"
+        torch.cuda.empty_cache()
+        free_memory()
+
+    return result
+
+
+# ============================================================================
+# 主测试流程
+# ============================================================================
+print("=" * 70)
+print("OPTIMIZATION BENCHMARK - SAME LENGTH COMPARISON")
+print("=" * 70)
+print(f"Model: {model_id}")
+print(f"Test frames: {TEST_NUM_FRAMES}")
+print(f"Resolution: {HEIGHT}x{WIDTH}")
+print(f"Speed test runs: {NUM_SPEED_RUNS}")
+print("=" * 70)
+
+# ============================================================================
+# 配置1: 原始模型
+# ============================================================================
+print("\n" + "=" * 70)
+print("CONFIG 1/5: BASELINE (No optimizations)")
+print("=" * 70)
+
+transformer_baseline = HeliosTransformer3DModel.from_pretrained(
+    model_id,
+    subfolder="transformer",
+    torch_dtype=torch.bfloat16,
+    use_default_loader=True,
+)
+transformer_baseline.enable_gradient_checkpointing()
+transformer_baseline.set_attention_backend("_flash_3_hub")
+transformer_baseline.to("cuda")
+
+result_baseline = run_single_config(transformer_baseline, "Baseline", TEST_NUM_FRAMES)
+benchmark_results["experiments"].append(result_baseline)
+
+del transformer_baseline
+torch.cuda.empty_cache()
+free_memory()
+
+# ============================================================================
+# 配置2: 只替换 TiledLinear
+# ============================================================================
+print("\n" + "=" * 70)
+print("CONFIG 2/5: TiledLinear only")
+print("=" * 70)
+
+transformer_tiled = HeliosTransformer3DModel.from_pretrained(
+    model_id,
+    subfolder="transformer",
+    torch_dtype=torch.bfloat16,
+    use_default_loader=True,
+)
+transformer_tiled.enable_gradient_checkpointing()
+transformer_tiled.set_attention_backend("_flash_3_hub")
+transformer_tiled = replace_linear_with_tiled_linear(transformer_tiled)
+transformer_tiled.to("cuda")
+
+result_tiled = run_single_config(transformer_tiled, "TiledLinear", TEST_NUM_FRAMES)
+benchmark_results["experiments"].append(result_tiled)
+
+transformer_tiled = None
+del transformer_tiled
+torch.cuda.empty_cache()
+free_memory()
+
+# ============================================================================
+# 配置3: 只替换 FlashNorm
+# ============================================================================
+print("\n" + "=" * 70)
+print("CONFIG 3/5: FlashNorm only")
+print("=" * 70)
+
+transformer_flashnorm = HeliosTransformer3DModel.from_pretrained(
+    model_id,
+    subfolder="transformer",
+    torch_dtype=torch.bfloat16,
+    use_default_loader=True,
+)
+transformer_flashnorm.enable_gradient_checkpointing()
+transformer_flashnorm.set_attention_backend("_flash_3_hub")
+transformer_flashnorm = replace_all_norms_with_flash_norms(transformer_flashnorm)
+transformer_flashnorm.to("cuda")
+
+result_flashnorm = run_single_config(transformer_flashnorm, "FlashNorm", TEST_NUM_FRAMES)
+benchmark_results["experiments"].append(result_flashnorm)
+
+transformer_flashnorm = None
+del transformer_flashnorm
+torch.cuda.empty_cache()
+free_memory()
+
+# ============================================================================
+# 配置4: 只替换 FlashRoPE
+# ============================================================================
+print("\n" + "=" * 70)
+print("CONFIG 4/5: FlashRoPE only")
+print("=" * 70)
+
+transformer_flashrope = HeliosTransformer3DModel.from_pretrained(
+    model_id,
+    subfolder="transformer",
+    torch_dtype=torch.bfloat16,
+    use_default_loader=True,
+)
+transformer_flashrope.enable_gradient_checkpointing()
+transformer_flashrope.set_attention_backend("_flash_3_hub")
+transformer_flashrope.to("cuda")
+
+# FlashRoPE 是全局替换,不可逆
+replace_rope_with_flash_rope()
+
+result_flashrope = run_single_config(transformer_flashrope, "FlashRoPE", TEST_NUM_FRAMES)
+benchmark_results["experiments"].append(result_flashrope)
+
+transformer_flashrope = None
+del transformer_flashrope
+torch.cuda.empty_cache()
+free_memory()
+
+# ============================================================================
+# 配置5: FlashNorm + FlashRoPE
+# ============================================================================
+print("\n" + "=" * 70)
+print("CONFIG 5/5: FlashNorm + FlashRoPE")
+print("=" * 70)
+
+transformer_combined = HeliosTransformer3DModel.from_pretrained(
+    model_id,
+    subfolder="transformer",
+    torch_dtype=torch.bfloat16,
+    use_default_loader=True,
+)
+transformer_combined.enable_gradient_checkpointing()
+transformer_combined.set_attention_backend("_flash_3_hub")
+transformer_combined = replace_all_norms_with_flash_norms(transformer_combined)
+transformer_combined.to("cuda")
+
+# FlashRoPE 已经在配置4中全局替换
+replace_rope_with_flash_rope()
+
+result_combined = run_single_config(transformer_combined, "FlashNorm+FlashRoPE", TEST_NUM_FRAMES)
+benchmark_results["experiments"].append(result_combined)
+
+transformer_combined = None
+del transformer_combined
+torch.cuda.empty_cache()
+free_memory()
+
+# ============================================================================
+# 保存结果
+# ============================================================================
+output_file = "benchmark_triton_results.json"
+with open(output_file, "w") as f:
+    json.dump(benchmark_results, f, indent=2)
+
+print("\n" + "=" * 70)
+print(f"✅ Results saved to {output_file}")
+print("=" * 70)
+
+# ============================================================================
+# 打印汇总表格
+# ============================================================================
+print("\n" + "=" * 70)
+print("BENCHMARK SUMMARY")
+print("=" * 70)
+
+# 表头
+print(f"\n{'Config':<20} {'InfSpeed(s)':>12} {'InfMem(GB)':>12} {'TrainSpeed(s)':>14} {'TrainMem(GB)':>13}")
+print("-" * 75)
+
+# 打印每个配置的结果
+for exp in benchmark_results["experiments"]:
+    config = exp["config"]
+
+    # 推理速度
+    inf_speed = (
+        f"{exp.get('inference_speed_avg_s', 0):.4f}" if exp.get("inference_speed_status") == "success" else "N/A"
+    )
+
+    # 推理显存
+    inf_mem = (
+        f"{exp.get('inference_memory_diff_gb', 0):.3f}" if exp.get("inference_memory_status") == "success" else "N/A"
+    )
+
+    # 训练速度
+    train_speed = (
+        f"{exp.get('training_speed_avg_s', 0):.4f}" if exp.get("training_speed_status") == "success" else "N/A"
+    )
+
+    # 训练显存
+    train_mem = (
+        f"{exp.get('training_memory_diff_gb', 0):.3f}" if exp.get("training_memory_status") == "success" else "N/A"
+    )
+
+    print(f"{config:<20} {inf_speed:>12} {inf_mem:>12} {train_speed:>14} {train_mem:>13}")
+
+# 计算加速比(如果baseline成功)
+baseline_result = benchmark_results["experiments"][0]
+if baseline_result.get("inference_speed_status") == "success":
+    baseline_inf_speed = baseline_result["inference_speed_avg_s"]
+    baseline_train_speed = baseline_result.get("training_speed_avg_s", None)
+
+    print("\n" + "=" * 70)
+    print("SPEEDUP vs BASELINE")
+    print("=" * 70)
+    print(f"{'Config':<20} {'InfSpeedup':>12} {'TrainSpeedup':>14}")
+    print("-" * 50)
+
+    for exp in benchmark_results["experiments"]:
+        config = exp["config"]
+
+        # 推理加速比
+        if exp.get("inference_speed_status") == "success":
+            speedup_inf = baseline_inf_speed / exp["inference_speed_avg_s"]
+            speedup_inf_str = f"{speedup_inf:.2f}x"
+        else:
+            speedup_inf_str = "N/A"
+
+        # 训练加速比
+        if exp.get("training_speed_status") == "success" and baseline_train_speed:
+            speedup_train = baseline_train_speed / exp["training_speed_avg_s"]
+            speedup_train_str = f"{speedup_train:.2f}x"
+        else:
+            speedup_train_str = "N/A"
+
+        print(f"{config:<20} {speedup_inf_str:>12} {speedup_train_str:>14}")
+
+print("\n" + "=" * 70)
+print("Legend:")
+print("  InfSpeed   - Inference time (forward only)")
+print("  InfMem     - Inference memory usage")
+print("  TrainSpeed - Training time (forward + backward)")
+print("  TrainMem   - Training memory usage")
+print("  Speedup    - Relative to baseline (higher is better)")
+print("=" * 70)

Helios/_DEV/tools/others/benchmark/benchmark_triton_results_helios.json

@@ -0,0 +1,111 @@
+{
+  "timestamp": "2026-02-06T09:14:11.892609",
+  "test_config": {
+    "num_frames": 13,
+    "height": 384,
+    "width": 640,
+    "num_speed_runs": 10
+  },
+  "experiments": [
+    {
+      "config": "Baseline",
+      "num_frames": 13,
+      "inference_speed_avg_s": 1.083,
+      "inference_speed_min_s": 1.0801,
+      "inference_speed_max_s": 1.088,
+      "inference_speed_std_s": 0.0027,
+      "inference_speed_status": "success",
+      "inference_memory_peak_gb": 29.777,
+      "inference_memory_diff_gb": 2.993,
+      "inference_memory_status": "success",
+      "training_speed_avg_s": 4.302,
+      "training_speed_min_s": 4.2982,
+      "training_speed_max_s": 4.3088,
+      "training_speed_std_s": 0.0031,
+      "training_speed_status": "success",
+      "training_memory_peak_gb": 60.792,
+      "training_memory_diff_gb": 33.978,
+      "training_memory_status": "success"
+    },
+    {
+      "config": "TiledLinear",
+      "num_frames": 13,
+      "inference_speed_avg_s": 1.1279,
+      "inference_speed_min_s": 1.1222,
+      "inference_speed_max_s": 1.1307,
+      "inference_speed_std_s": 0.0024,
+      "inference_speed_status": "success",
+      "inference_memory_peak_gb": 29.807,
+      "inference_memory_diff_gb": 2.992,
+      "inference_memory_status": "success",
+      "training_speed_avg_s": 4.8691,
+      "training_speed_min_s": 4.8631,
+      "training_speed_max_s": 4.8769,
+      "training_speed_std_s": 0.0035,
+      "training_speed_status": "success",
+      "training_memory_peak_gb": 60.867,
+      "training_memory_diff_gb": 34.052,
+      "training_memory_status": "success"
+    },
+    {
+      "config": "FlashNorm",
+      "num_frames": 13,
+      "inference_speed_avg_s": 0.9742,
+      "inference_speed_min_s": 0.9724,
+      "inference_speed_max_s": 0.9762,
+      "inference_speed_std_s": 0.0011,
+      "inference_speed_status": "success",
+      "inference_memory_peak_gb": 29.777,
+      "inference_memory_diff_gb": 2.993,
+      "inference_memory_status": "success",
+      "training_speed_avg_s": 3.8406,
+      "training_speed_min_s": 3.8371,
+      "training_speed_max_s": 3.8455,
+      "training_speed_std_s": 0.0025,
+      "training_speed_status": "success",
+      "training_memory_peak_gb": 59.703,
+      "training_memory_diff_gb": 32.888,
+      "training_memory_status": "success"
+    },
+    {
+      "config": "FlashRoPE",
+      "num_frames": 13,
+      "inference_speed_avg_s": 1.0208,
+      "inference_speed_min_s": 1.0183,
+      "inference_speed_max_s": 1.0252,
+      "inference_speed_std_s": 0.0021,
+      "inference_speed_status": "success",
+      "inference_memory_peak_gb": 29.807,
+      "inference_memory_diff_gb": 2.992,
+      "inference_memory_status": "success",
+      "training_speed_avg_s": 4.0924,
+      "training_speed_min_s": 4.0881,
+      "training_speed_max_s": 4.099,
+      "training_speed_std_s": 0.0044,
+      "training_speed_status": "success",
+      "training_memory_peak_gb": 60.817,
+      "training_memory_diff_gb": 34.002,
+      "training_memory_status": "success"
+    },
+    {
+      "config": "FlashNorm+FlashRoPE",
+      "num_frames": 13,
+      "inference_speed_avg_s": 0.9093,
+      "inference_speed_min_s": 0.9073,
+      "inference_speed_max_s": 0.9115,
+      "inference_speed_std_s": 0.0016,
+      "inference_speed_status": "success",
+      "inference_memory_peak_gb": 29.807,
+      "inference_memory_diff_gb": 2.992,
+      "inference_memory_status": "success",
+      "training_speed_avg_s": 3.5968,
+      "training_speed_min_s": 3.5889,
+      "training_speed_max_s": 3.6009,
+      "training_speed_std_s": 0.004,
+      "training_speed_status": "success",
+      "training_memory_peak_gb": 59.728,
+      "training_memory_diff_gb": 32.913,
+      "training_memory_status": "success"
+    }
+  ]
+}

Helios/_DEV/tools/others/benchmark/benchmark_triton_results_wan.json

@@ -0,0 +1,111 @@
+{
+  "timestamp": "2026-02-06T12:56:41.488612",
+  "test_config": {
+    "num_frames": 21,
+    "height": 384,
+    "width": 640,
+    "num_speed_runs": 10
+  },
+  "experiments": [
+    {
+      "config": "Baseline",
+      "num_frames": 21,
+      "inference_speed_avg_s": 1.9735,
+      "inference_speed_min_s": 1.97,
+      "inference_speed_max_s": 1.9756,
+      "inference_speed_std_s": 0.0016,
+      "inference_speed_status": "success",
+      "inference_memory_peak_gb": 31.615,
+      "inference_memory_diff_gb": 4.831,
+      "inference_memory_status": "success",
+      "training_speed_avg_s": 7.9606,
+      "training_speed_min_s": 7.9545,
+      "training_speed_max_s": 7.9712,
+      "training_speed_std_s": 0.0053,
+      "training_speed_status": "success",
+      "training_memory_peak_gb": 65.959,
+      "training_memory_diff_gb": 39.144,
+      "training_memory_status": "success"
+    },
+    {
+      "config": "TiledLinear",
+      "num_frames": 21,
+      "inference_speed_avg_s": 2.0023,
+      "inference_speed_min_s": 1.9987,
+      "inference_speed_max_s": 2.0085,
+      "inference_speed_std_s": 0.0028,
+      "inference_speed_status": "success",
+      "inference_memory_peak_gb": 31.647,
+      "inference_memory_diff_gb": 4.832,
+      "inference_memory_status": "success",
+      "training_speed_avg_s": 8.689,
+      "training_speed_min_s": 8.6836,
+      "training_speed_max_s": 8.6957,
+      "training_speed_std_s": 0.0036,
+      "training_speed_status": "success",
+      "training_memory_peak_gb": 65.429,
+      "training_memory_diff_gb": 38.614,
+      "training_memory_status": "success"
+    },
+    {
+      "config": "FlashNorm",
+      "num_frames": 21,
+      "inference_speed_avg_s": 1.7982,
+      "inference_speed_min_s": 1.7923,
+      "inference_speed_max_s": 1.8029,
+      "inference_speed_std_s": 0.0035,
+      "inference_speed_status": "success",
+      "inference_memory_peak_gb": 31.647,
+      "inference_memory_diff_gb": 4.832,
+      "inference_memory_status": "success",
+      "training_speed_avg_s": 7.2154,
+      "training_speed_min_s": 7.2076,
+      "training_speed_max_s": 7.223,
+      "training_speed_std_s": 0.0045,
+      "training_speed_status": "success",
+      "training_memory_peak_gb": 64.213,
+      "training_memory_diff_gb": 37.397,
+      "training_memory_status": "success"
+    },
+    {
+      "config": "FlashRoPE",
+      "num_frames": 21,
+      "inference_speed_avg_s": 1.8678,
+      "inference_speed_min_s": 1.8634,
+      "inference_speed_max_s": 1.8743,
+      "inference_speed_std_s": 0.0034,
+      "inference_speed_status": "success",
+      "inference_memory_peak_gb": 31.647,
+      "inference_memory_diff_gb": 4.832,
+      "inference_memory_status": "success",
+      "training_speed_avg_s": 7.5754,
+      "training_speed_min_s": 7.5696,
+      "training_speed_max_s": 7.5802,
+      "training_speed_std_s": 0.0038,
+      "training_speed_status": "success",
+      "training_memory_peak_gb": 66.0,
+      "training_memory_diff_gb": 39.185,
+      "training_memory_status": "success"
+    },
+    {
+      "config": "FlashNorm+FlashRoPE",
+      "num_frames": 21,
+      "inference_speed_avg_s": 1.6882,
+      "inference_speed_min_s": 1.6835,
+      "inference_speed_max_s": 1.6913,
+      "inference_speed_std_s": 0.0029,
+      "inference_speed_status": "success",
+      "inference_memory_peak_gb": 31.647,
+      "inference_memory_diff_gb": 4.832,
+      "inference_memory_status": "success",
+      "training_speed_avg_s": 6.8077,
+      "training_speed_min_s": 6.8014,
+      "training_speed_max_s": 6.8185,
+      "training_speed_std_s": 0.0049,
+      "training_speed_status": "success",
+      "training_memory_peak_gb": 64.252,
+      "training_memory_diff_gb": 37.436,
+      "training_memory_status": "success"
+    }
+  ]
+}

Helios/_DEV2/example/prompt.txt

@@ -0,0 +1,11 @@
+A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and the vivid colors of its surroundings. A close-up shot with dynamic movement.
+An extreme close-up of an gray-haired man with a beard in his 60s, he is deep in thought pondering the history of the universe as he sits at a cafe in Paris, his eyes focus on people offscreen as they walk as he sits mostly motionless, he is dressed in a wool coat suit coat with a button-down shirt , he wears a brown beret and glasses and has a very professorial appearance, and the end he offers a subtle closed-mouth smile as if he found the answer to the mystery of life, the lighting is very cinematic with the golden light and the Parisian streets and city in the background, depth of field, cinematic 35mm film.
+A handheld tracking shot following a red balloon floating above the ground in an abandoned street. The balloon drifts gracefully, its bright red color contrasting sharply against the decaying urban backdrop. The street is littered with debris and graffiti-covered walls, with broken windows and rusted cars scattered about. Shadows dance across the scene as sunlight filters through gaps in the buildings. The camera moves fluidly, capturing the balloon's gentle ascent and descent, emphasizing its playful motion. A close-up of the balloon transitions to a wider shot, showcasing the desolate environment.
+The camera follows behind a white vintage SUV with a black roof rack as it speeds up a steep dirt road surrounded by pine trees on a steep mountain slope, dust kicks up from it's tires, the sunlight shines on the SUV as it speeds along the dirt road, casting a warm glow over the scene. The dirt road curves gently into the distance, with no other cars or vehicles in sight. The trees on either side of the road are redwoods, with patches of greenery scattered throughout. The car is seen from the rear following the curve with ease, making it seem as if it is on a rugged drive through the rugged terrain. The dirt road itself is surrounded by steep hills and mountains, with a clear blue sky above with wispy clouds.
+A drone camera circles around a beautiful historic church built on a rocky outcropping along the Amalfi Coast, the view showcases historic and magnificent architectural details and tiered pathways and patios, waves are seen crashing against the rocks below as the view overlooks the horizon of the coastal waters and hilly landscapes of the Amalfi Coast Italy, several distant people are seen walking and enjoying vistas on patios of the dramatic ocean views, the warm glow of the afternoon sun creates a magical and romantic feeling to the scene, the view is stunning captured with beautiful photography.
+A large orange octopus is seen resting on the bottom of the ocean floor, blending in with the sandy and rocky terrain. Its tentacles are spread out around its body, and its eyes are closed. The octopus is unaware of a king crab that is crawling towards it from behind a rock, its claws raised and ready to attack. The crab is brown and spiny, with long legs and antennae. The scene is captured from a wide angle, showing the vastness and depth of the ocean. The water is clear and blue, with rays of sunlight filtering through. The shot is sharp and crisp, with a high dynamic range. The octopus and the crab are in focus, while the background is slightly blurred, creating a depth of field effect.
+A vibrant tropical fish glides gracefully through colorful ocean reefs, surrounded by swaying coral, shimmering schools of tiny fish, and beams of sunlight filtering down from the water’s surface. The scene feels alive with movement, as bubbles rise gently and the reef glows in vivid shades of blue, orange, and pink, creating a tranquil yet dynamic underwater atmosphere.
+Cinematic closeup and detailed portrait of a reindeer in a snowy forest at sunset. The lighting is cinematic and gorgeous and soft and sun-kissed, with golden backlight and dreamy bokeh and lens flares. The color grade is cinematic and magical.
+3D animation of a small, round, fluffy creature with big, expressive eyes explores a vibrant, enchanted forest. The creature, a whimsical blend of a rabbit and a squirrel, has soft blue fur and a bushy, striped tail. It hops along a sparkling stream, its eyes wide with wonder. The forest is alive with magical elements: flowers that glow and change colors, trees with leaves in shades of purple and silver, and small floating lights that resemble fireflies. The creature stops to interact playfully with a group of tiny, fairy-like beings dancing around a mushroom ring. The creature looks up in awe at a large, glowing tree that seems to be the heart of the forest.
+A dynamic time-lapse video showing the rapidly moving scenery from the window of a speeding train. The camera captures various elements such as lush green fields, towering trees, quaint countryside houses, and distant mountain ranges passing by quickly. The train window frames the view, adding a sense of speed and motion as the landscape rushes past. The camera remains static but emphasizes the fast-paced movement outside. The overall atmosphere is serene yet exhilarating, capturing the essence of travel and exploration. Medium shot focusing on the train window and the rushing scenery beyond.
+

Helios/_DEV2/example/prompt_interactive_helios.csv

@@ -0,0 +1,54 @@
+id,prompt_index,prompt
+6,0,"Underwater tornado affecting the ocean floor in a dramatic and chaotic scene. The water is murky, swirling violently, carrying debris and marine life into the vortex. Schools of fish scatter in panic, trying to avoid the powerful currents. Coral reefs and rocks are uprooted and tossed around, creating a tumultuous environment. In the background, large schools of fish swim away from the chaos, while smaller organisms cling to whatever they can find for safety. The camera remains stationary, capturing the intensity of the underwater tornado as it disrupts the serene ocean floor. Close-up shot emphasizing the turbulent motion and destruction."
+6,1,"The underwater vortex intensifies its grip on the seabed, pulling a rusted, barnacle-encrusted anchor from the sand. The heavy iron object spins lethargically at first before being whipped upward into the murky funnel, smashing through floating debris with violent force. Sediment billows in thick clouds around the base of the tornado, obscuring the terrified marine life darting through the gloom. The chaotic currents tear at the ocean floor, exposing deeper layers of rock and silt as the destruction mounts. Close-up shot emphasizing the turbulent motion and destruction."
+6,2,"The underwater tornado rages with unrelenting fury, now dislodging a massive, ancient shipwreck rib from the sediment. The curved wooden beam, blackened by time, groans silently as it is wrenched free and sucked into the spiraling column of water. Murky currents thrash wildly, tossing the heavy timber like a twig amidst the swirling sand and uprooted coral. Smaller debris clatters against the rotating wood, adding to the visual chaos of the deep-sea storm. The vortex dominates the frame, a terrifying engine of nature reshaping the seabed. Close-up shot emphasizing the turbulent motion and destruction."
+6,3,"The violent vortex now ensnares a large, glowing jellyfish, dragging its long, bioluminescent tentacles into the chaotic spiral. The delicate creature spins helplessly, its translucent bell pulsing rapidly against the crushing force of the murky water. Swirling currents rip through the surrounding gloom, tossing sand and fragmented shells in every direction as the tornado dominates the seabed. The glowing blue light of the jellyfish streaks through the darkness, creating a ghostly blur within the churning debris field. Close-up shot emphasizing the turbulent motion and destruction."
+6,4,"The swirling underwater vortex now seizes a heavy, encrusted treasure chest, its lid flapping open as it is torn from the ocean floor. Gold coins and silver trinkets spill out, glittering briefly in the murky water before being swept instantly into the violent funnel. The heavy wooden box tumbles end over end, colliding with floating rocks and adding to the debris field. Swirling sediment and bubbles surround the spilling fortune, highlighting the chaotic power of the storm as it ravages the seabed. Close-up shot emphasizing the turbulent motion and destruction."
+6,5,"The violent underwater tornado continues its rampage, now ripping a massive, stone tiki statue from its resting place on the ocean floor. The carved face of the heavy idol spins wildly as it is sucked into the murky vortex, colliding with swirling rocks and sand. Debris crashes against the stone surface, chipping away at its ancient features while the chaotic currents drag it higher into the funnel. The surrounding water remains thick with sediment, obscuring the background as the heavy statue becomes another victim of the deep-sea storm. Close-up shot emphasizing the turbulent motion and destruction."
+8,1,"A medium close-up of a serene, young East Asian woman with long pink hair, wearing a simple white gown that flows softly around her. She stands amidst gently falling sakura petals, which swirl around her, partially obscuring her figure in a dreamy, ethereal haze. Her delicate features are calm and tranquil as she gazes off into the distance. The background is blurred, featuring a soft pink and white sky with faint outlines of cherry blossom branches. The scene is bathed in a gentle, diffused light, creating a soft, dreamlike atmosphere."
+8,2,"In a serene, still environment, a woman gently lifts her hand towards a delicate flower petal, her fingertips barely touching the wisps of smoke floating nearby. She has a soft, contemplative expression on her face, and her hand moves slowly and gracefully. The scene is captured from a medium close-up angle, focusing on her hand and the petal, with the subtle movement and interaction emphasized. The background is blurred, creating a gentle focus on the main action. The lighting is soft and diffused, adding to the tranquil atmosphere."
+8,3,"A gentle breeze rustles through the air, causing cherry blossom petals to dance gracefully around a young woman's outstretched hand. She stands with a serene expression, wearing a traditional hanfu gown with flowing sleeves. The background showcases a tranquil garden with a winding path and blooming cherry trees. Soft sunlight filters through the leaves, casting dappled shadows on the ground. The scene is captured in a medium close-up, focusing on her hand and the swirling petals, with a slow pan to reveal the beautiful surroundings."
+8,4,"A serene woman with closed eyes and soft, resting eyelashes, exuding a sense of tranquility and peace. She sits gracefully with her hands gently folded in her lap, wearing a flowing, pastel-colored dress that complements her calm demeanor. The lighting is soft and diffused, casting a gentle glow over her face. The background is a blurred, natural setting with hints of greenery and a tranquil atmosphere. The camera focuses closely on her face, capturing the subtle rise and fall of her breath as she maintains a peaceful composure. Close-up shot, emphasizing her serene expression and the gentle movement of her body."
+8,5,"A serene nature scene where a young woman with flowing hair and a gentle expression steps forward gracefully on a grassy meadow. In the background, a small bird flutters and lands on a nearby tree branch. The woman's soft movements contrast with the bird's quick flight, creating a peaceful and harmonious atmosphere. The camera follows her as she moves, capturing the delicate interplay between the woman and the natural world in a medium close-up. The lighting is soft and natural, casting a warm glow over the scene."
+8,6,"A serene moment captured in a magical realism style, where a graceful bird perches delicately on the outstretched finger of a woman. The bird has vibrant plumage and a calm demeanor. Pink and faint cyan-blue smoke begins to swirl and thicken around them, gently enveloping the scene in a soft, misty haze. The woman stands gracefully, her hand extended, with a serene expression. The background is a dimly lit, cozy room with warm wooden elements and soft lighting, adding to the enchanting atmosphere. Medium close-up shot focusing on the interaction between the woman and the bird, with the smoke swirling in the foreground."
+11,1,"In a serene autumn clearing bathed in the warm, golden hues of late afternoon sunlight filtering through tall maple trees, a carpet of vibrant red and orange leaves blankets the ground. A rustic wooden footbridge arches gracefully over a gently trickling stream. Center frame, a sleek silver-gray house cat trots briskly across the leaf-strewn ground, its tail flicking energetically. As a cool breeze stirs, more leaves swirl and dance across the lens, adding a dynamic motion to the tranquil scene. Medium shot capturing the cat in motion against the backdrop of falling leaves."
+11,2,"In a lush forest setting, a playful house cat bounds towards the treeline, leaping gracefully over a fallen log. Mid-stride, the cat transforms into a sleek, smoky brown wildcat with tufted ears and lean, powerful muscles. It continues to run swiftly through the drifting autumn leaves, propelled by its agility and strength. The camera follows the wildcat in a smooth tracking shot, capturing the dynamic motion and the rich, vibrant colors of the forest floor."
+11,3,"In the warm golden hour, a wildcat leaps gracefully across a sparkling stream. As it runs, its body broadens and its fur transforms from its original color to a deep russet tone, morphing seamlessly into a sleek red fox. The fox's bushy, vibrant plume tail catches the sunlight, illuminating its swift movement as it dashes forward. The scene is captured from a dynamic tracking shot, emphasizing the fluid transition and the natural beauty of the changing landscape. Close-up and mid-shot transitions highlight the transformation and the glowing amber sky."
+11,4,"In twilight, a red fox races across an old stone bridge, its chest heaving and coat gradually graying as it transforms into a majestic gray wolf mid-jump. The wolf then gallops through an open forest clearing, leaping over a babbling stream, and continues up the hillside. The sky transitions from orange to deep purple, with stars beginning to twinkle overhead. The camera follows the wolf's swift movement, starting from a medium shot on the bridge and zooming out to a wide-angle view of the wolf bounding towards the hillside under the fading light."
+11,5,"In a serene moonlit forest, the transformation of a wolf into an antelope unfolds gracefully. Initially, the wolf's limbs elongate and refine, its fur shortening from its dense winter coat to a sleek, tawny color. As it shifts, small horns begin to emerge from its forehead. The antelope then swiftly bounds between trees, leaping over obstacles with ease, and finally clearing a tranquil stream in a single graceful leap. The camera captures this magical metamorphosis with smooth tracking shots and close-ups, emphasizing the fluidity and beauty of the change."
+11,6,"In a mystical scene under the bright moonlight, an antelope gradually transforms into a powerful horse. Initially, the antelope has a slender frame with a rich chestnut coat. As the transformation progresses, it grows taller and heavier, developing the muscular build and sturdy legs of a horse. The horse then begins to gallop majestically towards the horizon, its mane flowing freely in the wind. Its hooves rhythmically ring against the leaf-strewn ground, seamlessly completing the metamorphosis from cat-like agility to equine power. The scene is captured in a sweeping aerial shot, emphasizing the fluidity and grace of the transformation."
+14,1,"Close-up from the left side of a forest clearing, focus on a little girl in a light pink tulle dress with long flowing brown hair. She gazes slightly upward with a gentle, serene expression. The ground is covered in green grass and scattered wildflowers, with light mist creating an ethereal atmosphere. Sunbeams filter through the tall tree branches, casting dappled light. The scene is rendered in fantasy realism with soft, dreamy lighting, emphasizing the magical quality of the forest."
+14,2,"A slow pullback reveals a glowing magical stone appearing on the right side of the frame. In the center, a young girl remains stationary, her expression serene and focused. Sunbeams filter through the clouds, shifting slightly as the camera moves backward, casting gentle shadows across the scene. The background gradually comes into view, showcasing a mystical forest with tall trees and vibrant greenery. The camera captures the magic and wonder of the moment in a medium-wide shot."
+14,3,"Start with a close-up of a young boy in a blue robe adorned with a light tulle cloak as he enters from the right side of the frame. As he stops, the camera slowly pulls back to reveal a girl watching him intently from a few feet away. In the background, a large stone statue remains stationary, adding a sense of permanence and stillness to the scene. The environment is a dimly lit, ancient-looking room with stone walls and pillars. The camera movement emphasizes the interaction between the characters and their surroundings, capturing their expressions and body language clearly. Medium to wide shot transition."
+14,4,"A slight pan and pullback reveal a young boy nodding his head, his face showing a mixture of curiosity and determination. In response, a young girl raises her hand in acknowledgment, her expression serene and focused. Both children stand near a luminous stone that continues to emit a soft, warm glow, casting gentle light over the surrounding area. The scene takes place in a dimly lit forest clearing, with tall trees and dense undergrowth visible in the background. Medium shot transitioning to wide shot."
+14,5,"In a serene forest clearing, a young woman with flowing blonde hair turns towards a young man standing beside her. As the camera pulls to a medium shot, the couple's intimate moment is revealed against a backdrop of vibrant wildflowers and wisps of mist gently hovering above the ground. The environment is bathed in soft, natural light, enhancing the romantic atmosphere. The camera movement smoothly captures the subtle shift in their positions, bringing the entire scene into clear focus."
+14,6,"Wide shot: A young boy in a casual outfit walks out to the right, while a girl stays stationary to the left. In the middle of a fully lit forest clearing, a luminous stone emits a warm glow, surrounded by drifting mist and soft sunbeams filtering through the canopy. The camera pans slowly to follow the boy as he moves, capturing the serene beauty of the misty landscape and the mystical ambiance created by the glowing stone."
+20,0,"A majestic lion named Leo stands regally in the heart of a dense jungle, embodying the essence of a king. Leo has a golden mane that flows gracefully around his broad shoulders, and his piercing amber eyes survey the landscape with confidence and authority. He is positioned on a rocky outcrop, towering over the lush greenery below. The background showcases a vibrant jungle scene with tall trees, cascading vines, and dappled sunlight filtering through the canopy. Leo's posture is proud and commanding, with his tail held high. The scene is captured from a medium close-up perspective, emphasizing Leo’s powerful stance and the regal aura surrounding him."
+20,1,"Leo shifts his powerful weight slightly on the rocky outcrop, his golden mane rippling as he does so. Suddenly, he opens his massive jaws to release a deep, resonant roar that vibrates through the humid air, revealing his formidable white teeth. The dappled sunlight filtering through the canopy dances across his fur as his chest expands with the effort. The vibrant jungle remains lush and green around him, with tall trees and cascading vines framing his commanding figure. A medium close-up perspective emphasizing Leo’s powerful stance and the regal aura surrounding him."
+20,2,"Leo maintains his regal position on the rocky outcrop as the humid jungle air settles around his broad shoulders. He suddenly lowers his massive head to sniff a vibrant blue butterfly that has fluttered near his nose, his piercing amber eyes momentarily softening with curiosity. The dappled sunlight continues to filter through the tall trees and cascading vines, illuminating the golden hues of his mane against the lush green background. His tail remains held high, a symbol of his enduring authority over the landscape. A medium close-up perspective emphasizing Leo’s powerful stance and the regal aura surrounding him."
+20,3,"Leo stands tall on the rocky outcrop in the heart of the dense jungle, his golden mane glowing in the dappled sunlight. He lifts a massive paw to swipe gently at a low-hanging vine that dangles just within his reach, testing its texture with sharp claws. His piercing amber eyes remain alert, scanning the lush greenery and tall trees that surround him. The vibrant background of cascading vines and filtered light frames his regal form perfectly. A medium close-up perspective emphasizing Leo’s powerful stance and the regal aura surrounding him."
+20,4,"Leo remains on the rocky outcrop in the heart of the dense jungle, his golden mane catching the filtered light. He suddenly turns his head sharply to the left, his ears twitching as he focuses on a brightly colored parrot that lands on a nearby branch. His piercing amber eyes lock onto the bird with intense focus, analyzing the new arrival amidst the tall trees and cascading vines. The lush greenery provides a vibrant backdrop as he stands with authority, his posture commanding and proud. A medium close-up perspective emphasizing Leo’s powerful stance and the regal aura surrounding him."
+20,5,"Leo stands regally on the rocky outcrop in the heart of the dense jungle, his golden mane flowing around his broad shoulders. He dips his head low to lap cool water from a small, clear puddle that has formed in a crevice of the stone, his rough tongue splashing gently. His piercing amber eyes briefly close in satisfaction before reopening to survey the lush greenery, tall trees, and cascading vines. The dappled sunlight filters through the canopy, highlighting the wet fur on his muzzle. A medium close-up perspective emphasizing Leo’s powerful stance and the regal aura surrounding him."
+153,0,"90s VHS-style The Weather Channel scene, featuring a weatherman standing in front of a green screen with a large map of storm systems behind him. The weatherman, dressed in a casual but professional outfit, points emphatically at the rapidly moving storms on the map. His face shows concern and urgency as he speaks directly to the camera. The background map displays swirling patterns indicating severe weather conditions. The overall scene has a vintage, grainy texture with the characteristic noise and color palette of old VHS recordings. Medium close-up shot focusing on the weatherman's gestures and expressions."
+153,1,"The weatherman now reaches into his pocket and pulls out a chunky black walkie-talkie, pressing it against his ear with a sudden look of intense focus. He nods sharply while listening to an urgent update, his brow furrowing deeper under the studio lights. The green screen map behind him flickers slightly as the swirling storm systems intensify in color, shifting from red to deep purple. The vintage VHS grain distorts the edges of his suit jacket as he lowers the device and turns back to address the viewers with renewed alarm. Medium close-up shot focusing on the weatherman's gestures and expressions."
+153,2,"The weatherman suddenly unrolls a large, paper topographic map across a small stand that appears from the side, smoothing out the creases with frantic energy. He traces a specific mountain range with his finger, highlighting a dangerous path the storm is taking, his eyes wide with genuine fear. The digital map behind him glitches momentarily, syncing with his analogue demonstration as the VHS static rolls vertically across the frame. The studio lights reflect off the glossy paper surface as he taps a specific valley location repeatedly. Medium close-up shot focusing on the weatherman's gestures and expressions."
+153,3,"The weatherman abruptly grabs a bright red marker pen from the desk edge and begins circling a specific coastal city directly on the camera lens itself. He draws a jagged, erratic line across the glass to simulate the storm's unpredictable path, his hand shaking slightly with adrenaline. The ink squeaks audibly against the surface as the green screen map behind him pulses with warning icons. The VHS static buzzes louder, momentarily distorting his face as he caps the marker and stares intensely through his red drawings. Medium close-up shot focusing on the weatherman's gestures and expressions."
+153,4,"The weatherman now lifts a large, distinct ""Hurricane Warning"" sign made of heavy cardboard, holding it up beside his face for the audience to see clearly. The blocky red letters on the sign contrast sharply with his beige suit as he taps the edge of the board for emphasis. Behind him, the digital map swirls violently, the green screen effects blending slightly with the edges of the physical prop. The VHS tracking lines jitter horizontally across the bottom of the frame, enhancing the retro aesthetic as he maintains intense eye contact. Medium close-up shot focusing on the weatherman's gestures and expressions."
+153,5,"The weatherman suddenly dons a bright yellow rain slicker over his suit, struggling momentarily with the snaps as he prepares for a simulated outdoor report. He pulls the hood up over his head, framing his face tightly while the green screen behind him shifts to show footage of swaying palm trees and flying debris. The synthetic material of the coat reflects the studio lights with a harsh glare, adding to the chaotic atmosphere. The grainy VHS texture creates color bleeding around the vibrant yellow fabric as he shouts over imaginary wind. Medium close-up shot focusing on the weatherman's gestures and expressions."
+200,0,"A female astronaut in a full spacesuit, including an astronaut helmet, is running swiftly away from an unknown threat. She has a determined and focused expression on her face. The spacesuit is sleek, silver, and equipped with various gadgets and sensors. Her hair is visible under the helmet, flowing behind her as she runs. The background shows a desolate, rocky landscape with distant mountains and a dark, starry sky. The scene captures a medium shot of the woman mid-run, emphasizing her speed and urgency."
+200,1,"The silver-suited astronaut sprints across the rocky terrain, but now she firmly clutches a glowing red geological scanner in her right hand, its lights pulsing rhythmically against the dark environment. Her expression remains intense under the helmet visor as she navigates the uneven ground, the sleek gadgets on her suit reflecting faint starlight. The desolate landscape stretches endlessly around her, framed by jagged mountains in the distance. The medium shot tracks alongside her movement, keeping pace with her urgent stride against the backdrop of the vast, starry void. medium shot mid-run speed urgency"
+200,2,"The female astronaut races forward across the jagged terrain, her silver spacesuit gleaming against the dark void. Suddenly, a small drone detaches from her shoulder armor and hovers briefly before zooming ahead to scout the path. Her face remains locked in focused determination behind the helmet visor as her hair shifts with her rapid movement. The desolate rocky ground and looming distant mountains provide a stark backdrop to her flight. The camera maintains a medium shot of the woman mid-run, emphasizing her speed and urgency"
+200,3,"The female astronaut sprints across the desolate, rocky landscape, her silver spacesuit reflecting the cold starlight. As she runs, she suddenly raises her left arm to activate a holographic map projected from her wrist gauntlet, displaying a complex grid of blue lines and waypoints. Her expression remains fierce and concentrated behind the helmet visor while her hair moves with the momentum of her stride. The dark mountains loom in the distance under the starry sky. The scene captures a medium shot of the woman mid-run, emphasizing her speed and urgency"
+200,4,"The female astronaut dashes across the uneven, rocky ground, her sleek silver spacesuit shimmering under the starry sky. Without slowing her rapid pace, she reaches to her belt and deploys a luminous blue energy flare, dropping it behind her to mark her trail. Her face is set in a look of grim determination inside the helmet, with strands of hair floating with her motion. The dark, desolate landscape and distant mountains rush by as she flees. The scene captures a medium shot of the woman mid-run, emphasizing her speed and urgency"
+200,5,"The silver-clad astronaut sprints relentlessly across the treacherous rocky terrain, her breath fogging the corner of her helmet visor. As she runs, she suddenly taps a control on her chest plate, causing a pair of bright white headlights to activate on either side of her helmet, cutting through the darkness ahead. Her determined eyes scan the illuminated path while the desolate landscape and jagged mountains blur in the background. The starry sky hangs heavy above her swift escape. The scene captures a medium shot of the woman mid-run, emphasizing her speed and urgency"
+312,0,"A young woman standing in the rain, looking up at the sky with a warm, inviting smile on her face. She is dressed in a light, flowy dress that clings to her form as droplets of water fall around her. Her hair is gently tousled from the rain, framing her delicate features. The background shows a blurred cityscape with tall buildings and the faint glow of streetlights. The scene captures the serene beauty of a rainy evening. Medium close-up, static shot focusing on the girl's face and upper body."
+312,2,"The young woman remains framed against the soft blur of city lights, the rain now glistening on her skin as she slowly extends her right hand palm-up to catch the falling droplets. Her expression shifts slightly to one of quiet wonder as the water pools in her cupped fingers. The light fabric of her dress continues to sway subtly with the gentle wind, emphasizing the damp atmosphere. The distant streetlights create bokeh orbs behind her silhouette. Medium close-up, static shot focusing on the girl's face and upper body."
+312,3,"The young woman in the light, flowy dress now closes her eyes, tilting her head back slightly to let the rain wash over her face. She reaches into her pocket and pulls out a bright red origami crane, holding it delicately between her fingers. The paper quickly darkens as it absorbs the moisture, contrasting with the blurred gray cityscape behind her. Her hair is plastered more closely to her cheeks by the persistent downpour, while the streetlights cast a soft, shimmering glow on the wet paper bird. Medium close-up, static shot focusing on the girl's face and upper body."
+312,4,"The young woman in the soaked flowy dress opens her eyes and suddenly unfurls a small, transparent umbrella with a floral pattern above her head. The rain drums rhythmically against the plastic canopy, creating a protective bubble around her upper body while water streams down the sides. The red paper crane she held previously is now tucked away or gone, replaced by her grip on the curved umbrella handle. The blurred city lights reflect beautifully on the wet surface of the umbrella as she gazes forward with renewed calmness. Medium close-up, static shot focusing on the girl's face and upper body."
+312,5,"The young woman stands beneath the transparent floral umbrella, the rain creating a rhythmic patter on its surface. She reaches up with her free hand and adjusts a pair of round, gold-rimmed glasses onto the bridge of her nose, blinking behind the lenses as they catch the ambient city light. Her damp hair frames her face, and the light dress clings softly to her form in the humid air. The blurred cityscape behind her glows with the warmth of streetlights, enhancing the serene mood. Medium close-up, static shot focusing on the girl's face and upper body."
+334,0,"A stylish, young woman riding a sleek black motorcycle down a bustling city street. She wears a fitted leather jacket, dark sunglasses, and a helmet with a visor up, revealing her confident expression. Her posture is relaxed yet controlled as she grips the handlebars firmly. The motorcycle's engine roars as she navigates through traffic. The urban backdrop includes tall buildings, street signs, and passing cars, creating a vibrant, dynamic scene. Medium shot focusing on the girl and the motorcycle, capturing the energy of the city."
+334,1,"The stylish young woman on the sleek black motorcycle leans slightly to the right as she smoothly changes lanes. Her fitted leather jacket gleams under the city lights, and her dark sunglasses reflect the passing scenery. With her helmet visor up, a faint smile plays on her lips, showing her enjoyment of the ride. Suddenly, she extends her left hand to adjust the side mirror, briefly checking the reflection of the vibrant urban backdrop behind her before returning her grip to the handlebars. Medium shot focusing on the girl and the motorcycle, capturing the energy of the city."
+334,2,"The stylish young woman on the sleek black motorcycle accelerates gently, causing her hair to flutter beneath the edge of her helmet. Her fitted leather jacket remains snug against the wind, while her dark sunglasses shield her eyes from the glare. As she cruises past towering skyscrapers and vibrant street signs, she reaches down with her right hand to toggle a switch on the dashboard, activating the motorcycle's bright turn signal. The urban environment blurs slightly in the background, emphasizing her focused movement through the traffic. Medium shot focusing on the girl and the motorcycle, capturing the energy of the city."
+334,3,"The stylish young woman on the sleek black motorcycle maintains her steady pace through the busy urban corridor. Her fitted leather jacket and dark sunglasses remain prominent against the backdrop of tall buildings and passing cars. With her helmet visor up, her confident expression is clear as she navigates the road. As she rides, she briefly lifts her left boot to shift gears, pressing down decisively on the pedal near the footrest. The engine note changes pitch slightly, blending with the city noise, while street signs flash by in the background. Medium shot focusing on the girl and the motorcycle, capturing the energy of the city."
+334,4,"The stylish young woman on the sleek black motorcycle rides confidently forward amidst the bustling traffic. Her fitted leather jacket and dark sunglasses stay consistent with her cool demeanor, while the helmet visor remains up. As she passes a row of tall buildings and street signs, she suddenly raises her left hand to wave at a pedestrian standing on the nearby sidewalk. Her posture stays relaxed despite the momentary gesture, and she quickly returns her hand to the grip to maintain control. The urban backdrop continues to provide a vibrant, dynamic atmosphere around her. Medium shot focusing on the girl and the motorcycle, capturing the energy of the city."
+334,5,"The stylish young woman on the sleek black motorcycle rides forward, her fitted leather jacket absorbing the ambient city light. She wears dark sunglasses and keeps her helmet visor up, maintaining a confident, relaxed expression amidst the towering buildings and passing cars. While cruising through the vibrant urban scene, she briefly tilts her head to glance at a large digital billboard flashing colorful advertisements above the street. Her grip on the handlebars remains steady as she takes in the glowing display before refocusing on the road ahead. Medium shot focusing on the girl and the motorcycle, capturing the energy of the city."

Helios/_DEV2/example/toy_data/toy_filter.json

@@ -0,0 +1,46 @@
+[
+  {
+    "cut": [
+      0,
+      81
+    ],
+    "crop": [
+      0,
+      832,
+      0,
+      480
+    ],
+    "fps": 24.0,
+    "num_frames": 81,
+    "resolution": {
+      "height": 480,
+      "width": 832
+    },
+    "cap": [
+      "A stunning mid-afternoon landscape photograph with a low camera angle, showcasing several giant wooly mammoths treading through a snowy meadow. Their long, wooly fur gently billows in the brisk wind as they move, creating a sense of natural movement. Snow-covered trees and dramatic snow-capped mountains loom in the distance, adding to the majestic setting. Wispy clouds and a high sun cast a warm glow over the scene, enhancing the serene and awe-inspiring atmosphere. The depth of field brings out the detailed textures of the mammoths and the snowy environment, capturing every nuance of these prehistoric giants in breathtaking clarity."
+    ],
+    "path": "videos/2_240_ori81.mp4"
+  },
+  {
+    "cut": [
+      0,
+      129
+    ],
+    "crop": [
+      0,
+      832,
+      0,
+      480
+    ],
+    "fps": 24.0,
+    "num_frames": 129,
+    "resolution": {
+      "height": 480,
+      "width": 832
+    },
+    "cap": [
+      "An old man in blue jeans and a white T-shirt takes a leisurely stroll along a bustling street in Mumbai, India, during a breathtaking sunset. He walks with a gentle sway, his weathered face reflecting the warm hues of the setting sun. His hands rest casually in his pockets, and he appears content and at peace. The background features a vibrant mix of colorful buildings, street vendors, and pedestrians, with the sky painted in shades of orange, pink, and purple. The photo has a nostalgic and documentary style, capturing the essence of a serene moment amidst the city's energy. A medium shot with a soft focus on the old man."
+    ],
+    "path": "videos/239_120_ori129.mp4"
+  }
+]

Helios/_DEV2/helios/dataset/dataloader_dmd.py

@@ -0,0 +1,531 @@
+import os
+import pickle
+import random
+from collections import defaultdict
+
+import torch
+from einops import rearrange
+from torch.utils.data import Dataset, Sampler
+
+
+class BucketedFeatureDataset(Dataset):
+    def __init__(
+        self,
+        gan_folders=None,
+        ode_folders=None,
+        text_folders=None,
+        is_use_gt_history=False,
+        return_secondary=False,
+        force_rebuild=False,
+        single_res=True,
+        single_length=True,
+        single_num_frame=81,
+        single_height=384,
+        single_width=640,
+        seed=42,
+    ):
+        self.is_use_gt_history = is_use_gt_history
+        self.return_secondary = return_secondary
+        self.force_rebuild = force_rebuild
+        self.base_seed = seed
+        self._epoch = 0
+
+        self.single_res = single_res
+        self.single_length = single_length
+        self.single_num_frame = single_num_frame
+        self.single_height = single_height
+        self.single_width = single_width
+
+        self.gan_samples = self._init_samples(gan_folders, "gan")
+        self.ode_samples = self._init_samples(ode_folders, "ode")
+        self.text_samples = self._init_samples(text_folders, "text")
+
+        self._align_sample_counts()
+
+    def _init_samples(self, folders, data_type):
+        if folders is None:
+            return []
+
+        folders = [folders] if isinstance(folders, str) else folders
+        samples = []
+
+        for folder in folders:
+            cache_file = os.path.join(folder, f"{data_type}_dataset_cache.pkl")
+            folder_samples = self._process_folder(folder, cache_file, data_type)
+            samples.extend(folder_samples)
+
+        return samples
+
+    def _align_sample_counts(self, is_log=True):
+        lengths = {"gan": len(self.gan_samples), "ode": len(self.ode_samples), "text": len(self.text_samples)}
+
+        non_empty_lengths = {k: v for k, v in lengths.items() if v > 0}
+        if not non_empty_lengths:
+            return
+        max_length = max(non_empty_lengths.values())
+
+        if is_log:
+            print(f"\nAligning sample counts to max: {max_length}")
+            print(f"Original counts - GAN: {lengths['gan']}, ODE: {lengths['ode']}, TEXT: {lengths['text']}")
+
+        random.seed(self.base_seed)
+
+        if self.gan_samples and len(self.gan_samples) < max_length:
+            self.gan_samples = self._expand_samples(self.gan_samples, max_length, "GAN")
+
+        if self.ode_samples and len(self.ode_samples) < max_length:
+            self.ode_samples = self._expand_samples(self.ode_samples, max_length, "ODE")
+
+        if self.text_samples and len(self.text_samples) < max_length:
+            self.text_samples = self._expand_samples(self.text_samples, max_length, "TEXT")
+
+        if is_log:
+            print(
+                f"Aligned counts - GAN: {len(self.gan_samples)}, ODE: {len(self.ode_samples)}, TEXT: {len(self.text_samples)}\n"
+            )
+
+    def _expand_samples(self, samples, target_length, data_type):
+        original_length = len(samples)
+        expanded_samples = samples.copy()
+
+        while len(expanded_samples) < target_length:
+            random_sample = random.choice(samples)
+            expanded_samples.append(random_sample)
+
+        print(f"{data_type}: Expanded from {original_length} to {len(expanded_samples)} samples")
+        return expanded_samples
+
+    def _process_folder(self, folder, cache_file, data_type):
+        if self.force_rebuild or not os.path.exists(cache_file):
+            # if os.path.exists(cache_file):
+            #     os.remove(cache_file)
+            print(f"{data_type.upper()}: Building metadata cache for folder: {folder}")
+            folder_samples = self._build_folder_metadata(folder, data_type)
+
+            if not self.force_rebuild:
+                print(f"{data_type.upper()}: Saving metadata cache for folder: {folder}")
+                with open(cache_file, "wb") as f:
+                    pickle.dump({"samples": folder_samples}, f)
+
+            print(f"{data_type.upper()}: Cached {len(folder_samples)} samples from {folder}")
+        else:
+            print(f"{data_type.upper()}: Loading cached metadata from: {folder}")
+            with open(cache_file, "rb") as f:
+                folder_samples = pickle.load(f)["samples"]
+            print(f"{data_type.upper()}: Loaded {len(folder_samples)} samples from cache: {folder}")
+
+        return folder_samples
+
+    def _build_folder_metadata(self, folder, data_type):
+        feature_files = [f for f in os.listdir(folder) if f.endswith(".pt")]
+        samples = []
+
+        print(f"{data_type.upper()}: Processing {len(feature_files)} files in {folder}...")
+        for i, feature_file in enumerate(feature_files):
+            if i % 10000 == 0:
+                print(f"  {data_type.upper()}: Processed {i}/{len(feature_files)} files")
+
+            feature_path = os.path.join(folder, feature_file)
+
+            # TODO hard code here now
+            if data_type == "gan":
+                parts = feature_file.split("_")
+                num_frame = int(parts[-3])
+                height = int(parts[-2])
+                width = int(parts[-1].replace(".pt", ""))
+
+                if self.is_use_gt_history:
+                    if (height, width) not in [(self.single_height, self.single_width)]:
+                        continue
+                else:
+                    if (num_frame, height, width) not in [
+                        (self.single_num_frame, self.single_height, self.single_width)
+                    ]:
+                        continue
+
+            samples.append(
+                {
+                    "uttid": os.path.splitext(os.path.basename(feature_file))[0],
+                    "dataset_name": folder.rstrip("/"),
+                    "file_path": feature_path,
+                }
+            )
+
+        return samples
+
+    def prepare_stage1_latent(self, vae_latent, idx, base_vae_latent=None, return_secondary=False):
+        self.is_keep_x0 = (True,)
+        self.history_sizes = [16, 2, 1]
+        self.num_rollout_sections = 9
+
+        source_latent = base_vae_latent if base_vae_latent is not None else vae_latent
+
+        x0_latent = None
+        if self.is_keep_x0:
+            x0_latent = source_latent[0, :, :1, :, :].clone()
+        total_sections = source_latent.shape[0]
+        latent_window_size = source_latent.shape[2]
+        history_window_size = sum(self.history_sizes)
+        section_size = history_window_size + latent_window_size
+
+        temp_source_latent = rearrange(source_latent, "b c t h w -> c (b t) h w")
+        zero_padding_source = torch.zeros(
+            temp_source_latent.shape[0],
+            history_window_size,
+            temp_source_latent.shape[2],
+            temp_source_latent.shape[3],
+            device=temp_source_latent.device,
+            dtype=temp_source_latent.dtype,
+        )
+        continue_source_latent = torch.cat([zero_padding_source, temp_source_latent], dim=1)
+
+        temp_vae_latent = rearrange(vae_latent, "b c t h w -> c (b t) h w")
+        zero_padding_vae = torch.zeros(
+            temp_vae_latent.shape[0],
+            history_window_size,
+            temp_vae_latent.shape[2],
+            temp_vae_latent.shape[3],
+            device=temp_vae_latent.device,
+            dtype=temp_vae_latent.dtype,
+        )
+        continue_vae_latent = torch.cat([zero_padding_vae, temp_vae_latent], dim=1)
+
+        sample_seed = self.base_seed + self._epoch * 1000000 + idx
+        choice_idx = torch.randint(
+            0, total_sections, (1,), generator=torch.Generator().manual_seed(sample_seed)
+        ).item()
+        if choice_idx == 0 and x0_latent is not None:
+            x0_latent = torch.zeros_like(x0_latent)
+
+        start_indice = choice_idx * latent_window_size
+        end_indice = start_indice + section_size
+
+        history_latent = continue_source_latent[:, start_indice : start_indice + history_window_size, :, :]
+        target_latent = continue_vae_latent[:, start_indice + history_window_size : end_indice, :, :]
+
+        x0_latent_2 = None
+        history_latent_2 = None
+        target_latent_2 = None
+        if return_secondary:
+            sample_seed_2 = self.base_seed + self._epoch * 1000000 + idx + 999999
+            choice_idx_2 = torch.randint(
+                0, total_sections, (1,), generator=torch.Generator().manual_seed(sample_seed_2)
+            ).item()
+
+            x0_latent_2 = None
+            if self.is_keep_x0:
+                x0_latent_2 = source_latent[0, :, :1, :, :].clone()
+                if choice_idx_2 == 0:
+                    x0_latent_2 = torch.zeros_like(x0_latent_2)
+
+            start_indice_2 = choice_idx_2 * latent_window_size
+            end_indice_2 = start_indice_2 + section_size
+
+            history_latent_2 = continue_source_latent[:, start_indice_2 : start_indice_2 + history_window_size, :, :]
+            target_latent_2 = continue_vae_latent[:, start_indice_2 + history_window_size : end_indice_2, :, :]
+
+        return (x0_latent, history_latent, target_latent), (x0_latent_2, history_latent_2, target_latent_2)
+
+    def set_epoch(self, epoch):
+        self._epoch = epoch
+        random.seed(self.base_seed + epoch)
+        self._align_sample_counts(is_log=False)
+
+    def __len__(self):
+        return max(len(self.gan_samples), len(self.ode_samples), len(self.text_samples))
+
+    def __getitem__(self, idx):
+        while True:
+            try:
+                output_dict = {}
+
+                if self.gan_samples:
+                    gan_sample = self.gan_samples[idx]
+                    gan_feature = torch.load(gan_sample["file_path"], map_location="cpu", weights_only=False)
+                    if self.is_use_gt_history:
+                        (
+                            (x0_latent, history_latent, target_latent),
+                            (x0_latent_2, history_latent_2, target_latent_2),
+                        ) = self.prepare_stage1_latent(
+                            gan_feature["vae_latent"],
+                            idx,
+                            return_secondary=self.return_secondary,
+                        )
+                        output_dict.update(
+                            {
+                                "gan_uttid": gan_sample["uttid"],
+                                "gan_dataset_name": gan_sample["dataset_name"],
+                                "gan_vae_latents": target_latent,
+                                "gan_x0_latents": x0_latent,
+                                "gan_history_latents": history_latent,
+                                "gan_vae_latents_2": target_latent_2,
+                                "gan_x0_latents_2": x0_latent_2,
+                                "gan_history_latents_2": history_latent_2,
+                                "gan_prompt_raws": gan_feature["prompt_raw"],
+                                "gan_prompt_embeds": gan_feature["prompt_embed"],
+                            }
+                        )
+                    else:
+                        output_dict.update(
+                            {
+                                "gan_uttid": gan_sample["uttid"],
+                                "gan_dataset_name": gan_sample["dataset_name"],
+                                "gan_vae_latents": gan_feature["vae_latent"],
+                                "gan_prompt_raws": gan_feature["prompt_raw"],
+                                "gan_prompt_embeds": gan_feature["prompt_embed"],
+                            }
+                        )
+                    gan_sample = None
+                    gan_feature = None
+                    del gan_sample
+                    del gan_feature
+
+                if self.ode_samples:
+                    ode_sample = self.ode_samples[idx]
+                    ode_feature = torch.load(ode_sample["file_path"], map_location="cpu", weights_only=False)
+                    output_dict.update(
+                        {
+                            "ode_uttid": ode_sample["uttid"],
+                            "ode_dataset_name": ode_sample["dataset_name"],
+                            "ode_latent_window_size": ode_feature["latent_window_size"],
+                            "ode_latents": ode_feature["ode_latents"],
+                            "ode_prompt_raws": ode_feature["prompt_raw"],
+                            "ode_prompt_embeds": ode_feature["prompt_embed"][0],
+                        }
+                    )
+                    ode_sample = None
+                    ode_feature = None
+                    del ode_sample
+                    del ode_feature
+
+                if self.text_samples:
+                    text_sample = self.text_samples[idx]
+                    text_feature = torch.load(text_sample["file_path"], map_location="cpu", weights_only=False)
+                    output_dict.update(
+                        {
+                            "text_uttid": text_sample["uttid"],
+                            "text_dataset_name": text_sample["dataset_name"],
+                            "text_prompt_raws": text_feature["prompt_raw"],
+                            "text_prompt_embeds": text_feature["prompt_embed"],
+                        }
+                    )
+                    text_sample = None
+                    text_feature = None
+                    del text_sample
+                    del text_feature
+
+                return output_dict
+
+            except Exception as e:
+                idx = random.randint(0, len(self) - 1)
+                print(f"Error loading sample at idx {idx}, retrying... Error: {e}")
+
+
+class BucketedSampler(Sampler):
+    def __init__(
+        self,
+        dataset,
+        batch_size,
+        dataset_sampling_ratios={},
+        drop_last=False,
+        shuffle=True,
+        seed=42,
+        num_sp_groups=1,
+        sp_world_size=1,
+        global_rank=0,
+    ):
+        self.dataset = dataset
+        self.batch_size = batch_size
+        self.drop_last = drop_last
+        self.shuffle = shuffle
+        self.seed = seed
+        self.generator = torch.Generator()
+        self._epoch = 0
+
+        # Distributed parameters
+        self.num_sp_groups = num_sp_groups
+        self.sp_world_size = sp_world_size
+        self.global_rank = global_rank
+        self.ith_sp_group = self.global_rank // self.sp_world_size
+
+    def set_epoch(self, epoch):
+        self._epoch = epoch
+
+    def _shard_indices_for_sp_group(self, indices):
+        """
+        Shard indices across SP groups.
+        Each SP group gets a disjoint subset of the data.
+        """
+        if self.num_sp_groups == 1:
+            return indices
+
+        # Convert to tensor if it's a list
+        if isinstance(indices, list):
+            indices_tensor = torch.tensor(indices, dtype=torch.long)
+        else:
+            indices_tensor = indices
+
+        # Pad indices if necessary to make it divisible by num_sp_groups
+        total_size = len(indices_tensor)
+        if total_size % self.num_sp_groups != 0:
+            if not self.drop_last:
+                padding_size = self.num_sp_groups - (total_size % self.num_sp_groups)
+                indices_tensor = torch.cat([indices_tensor, indices_tensor[:padding_size]])
+        else:
+            # If drop_last, truncate to be divisible
+            if self.drop_last:
+                truncate_size = (total_size // self.num_sp_groups) * self.num_sp_groups
+                indices_tensor = indices_tensor[:truncate_size]
+
+        # Shard: each SP group gets every num_sp_groups-th element
+        sp_group_indices = indices_tensor[self.ith_sp_group :: self.num_sp_groups]
+
+        return sp_group_indices.tolist()
+
+    def __iter__(self):
+        # Use epoch-level seed for reproducibility
+        epoch_seed = self.seed + self._epoch
+        self.generator.manual_seed(epoch_seed)
+
+        # Get all indices
+        all_indices = list(range(len(self.dataset)))
+
+        # Global shuffle before sharding (important for distributed consistency)
+        if self.shuffle:
+            perm = torch.randperm(len(all_indices), generator=self.generator).tolist()
+            all_indices = [all_indices[i] for i in perm]
+
+        # Shard indices for this SP group
+        sp_group_indices = self._shard_indices_for_sp_group(all_indices)
+
+        # Create batches
+        for i in range(0, len(sp_group_indices), self.batch_size):
+            batch = sp_group_indices[i : i + self.batch_size]
+            if len(batch) == self.batch_size or not self.drop_last:
+                yield batch
+
+    def __len__(self):
+        # Total samples in dataset
+        total_samples = len(self.dataset)
+
+        # Account for SP group sharding
+        sp_group_samples = total_samples // self.num_sp_groups
+        if not self.drop_last and total_samples % self.num_sp_groups != 0:
+            sp_group_samples += 1
+
+        # Calculate number of batches
+        total_batches = sp_group_samples // self.batch_size
+        if not self.drop_last and sp_group_samples % self.batch_size != 0:
+            total_batches += 1
+
+        return total_batches
+
+
+def collate_fn(batch):
+    return {
+        key: torch.stack([d[key] for d in batch])
+        if isinstance(batch[0][key], torch.Tensor)
+        else [d[key] for d in batch]
+        for key in batch[0]
+    }
+
+
+if __name__ == "__main__":
+    from accelerate import Accelerator
+    from torchdata.stateful_dataloader import StatefulDataLoader
+
+    dataloader_num_workers = 8
+    batch_size = 2
+    num_train_epochs = 2
+    seed = 0
+
+    gan_folder = [
+        "/mnt/hdfs/data/ysh_new/userful_things_wan/gan_latents/ultravideo/clips_long_960",
+        "/mnt/hdfs/data/ysh_new/userful_things_wan/gan_latents/ultravideo/clips_short_960",
+    ]
+    ode_folder = [
+        "/mnt/hdfs/data/ysh_new/userful_things_wan/ode_pairs/vidprom_filtered_extended",
+    ]
+    text_folder = [
+        "/mnt/hdfs/data/ysh_new/userful_things_wan/text-embedding/mixkit_filter",
+        "/mnt/hdfs/data/ysh_new/userful_things_wan/text-embedding/vidprom_filtered_extended",
+    ]
+
+    accelerator = Accelerator()
+    print(accelerator.process_index, accelerator.num_processes)
+
+    dataset = BucketedFeatureDataset(
+        gan_folders=gan_folder,
+        ode_folders=ode_folder,
+        text_folders=text_folder,
+        is_use_gt_history=True,
+        force_rebuild=True,
+        seed=seed,
+    )
+    sampler = BucketedSampler(
+        dataset,
+        batch_size=batch_size,
+        drop_last=True,
+        shuffle=True,
+        seed=seed,
+        num_sp_groups=accelerator.num_processes // 1,
+        sp_world_size=1,
+        global_rank=accelerator.process_index,
+    )
+    dataloader = StatefulDataLoader(
+        dataset,
+        batch_sampler=sampler,
+        collate_fn=collate_fn,
+        num_workers=dataloader_num_workers,
+        prefetch_factor=2 if dataloader_num_workers > 0 else None,
+    )
+    print(len(dataset), len(dataloader))
+    print(f"Dataset size: {len(dataset)}, Dataloader batches: {len(dataloader)}")
+
+    step = 0
+    global_step = 0
+    first_epoch = 0
+    print("Testing dataloader...")
+    dataset_counts = defaultdict(int)
+    for epoch in range(first_epoch, num_train_epochs):
+        sampler.set_epoch(epoch)
+        dataset.set_epoch(epoch)
+        for i, batch in enumerate(dataloader):
+            # Get metadata
+            gan_uttid = batch["gan_uttid"]
+            ode_uttid = batch["ode_uttid"]
+            text_uttid = batch["text_uttid"]
+
+            # Get feature
+            # For GAN
+            gan_vae_latents = batch["gan_vae_latents"]
+            gan_prompt_raws = batch["gan_prompt_raws"]
+            gan_prompt_embeds = batch["gan_prompt_embeds"]
+            print(gan_vae_latents.shape, gan_prompt_embeds.shape, gan_prompt_raws)
+
+            # For ODE
+            ode_prompt_raws = batch["ode_prompt_raws"]
+            ode_prompt_embeds = batch["ode_prompt_embeds"]
+            print(ode_prompt_embeds.shape, ode_prompt_raws)
+
+            # For Text
+            text_prompt_raws = batch["text_prompt_raws"]
+            text_prompt_embeds = batch["text_prompt_embeds"]
+            print(text_prompt_embeds.shape, text_prompt_raws)
+
+            if accelerator.process_index == 0:
+                # print info
+                print(f" Step {step}:")
+                print(f"  Batch {i}:")
+                print(f"  Batch size: {len(gan_uttid)}")
+                print(f"  Uttids: {gan_uttid}, {ode_uttid}, {text_uttid}")
+                print(
+                    f"  Data Name: {batch['gan_dataset_name']}, {batch['ode_dataset_name']}, {batch['text_dataset_name']}"
+                )
+
+            for dataset_name in batch["gan_dataset_name"]:
+                dataset_counts[dataset_name] += 1
+
+            step += 1
+
+    print("实际采样统计:", dict(dataset_counts))

Helios/_DEV2/helios/dataset/dataloader_history_latents_dist.py

@@ -0,0 +1,685 @@
+import os
+import pickle
+import random
+from collections import defaultdict
+
+import torch
+from einops import rearrange
+from torch.utils.data import Dataset, Sampler
+
+
+class BucketedFeatureDataset(Dataset):
+    def __init__(
+        self,
+        feature_folders,
+        history_sizes=[16, 2, 1],
+        is_keep_x0=True,
+        force_rebuild=False,
+        return_all_vae_latent=False,
+        return_prompt_raw=False,
+        num_rollout_sections=3,
+        single_res=False,
+        single_height=384,
+        single_width=640,
+        seed=42,
+    ):
+        self.history_sizes = history_sizes
+        self.is_keep_x0 = is_keep_x0
+        self.force_rebuild = force_rebuild
+        self.return_all_vae_latent = return_all_vae_latent
+        self.return_prompt_raw = return_prompt_raw
+        self.num_rollout_sections = num_rollout_sections
+        self.single_res = single_res
+        self.single_height = single_height
+        self.single_width = single_width
+        assert self.is_keep_x0, "is_keep_x0 need to be True now!"
+
+        self.base_seed = seed
+        self._epoch = 0
+
+        if isinstance(feature_folders, str):
+            self.feature_folders = [feature_folders]
+        else:
+            self.feature_folders = feature_folders
+
+        self.samples = []
+        self.buckets = defaultdict(list)
+
+        for folder in self.feature_folders:
+            cache_file = os.path.join(folder, "dataset_cache.pkl")
+            self._process_folder(folder, cache_file)
+
+    def _process_folder(self, folder, cache_file):
+        if self.force_rebuild or not os.path.exists(cache_file):
+            print(f"Building metadata cache for folder: {folder}")
+            folder_samples, folder_buckets = self._build_folder_metadata(folder)
+
+            print(f"Saving metadata cache for folder: {folder}")
+            cached_data = {"samples": folder_samples, "buckets": folder_buckets}
+            if not self.force_rebuild:
+                with open(cache_file, "wb") as f:
+                    pickle.dump(cached_data, f)
+            print(f"Cached {len(folder_samples)} samples from {folder}\n")
+        else:
+            print(f"Loading cached metadata from: {folder}")
+            with open(cache_file, "rb") as f:
+                cached_data = pickle.load(f)
+            folder_samples = cached_data["samples"]
+            folder_buckets = cached_data["buckets"]
+            print(f"Loaded {len(folder_samples)} samples from cache: {folder}\n")
+
+        sample_idx_offset = len(self.samples)
+        self.samples.extend(folder_samples)
+
+        for bucket_key, indices in folder_buckets.items():
+            adjusted_indices = [idx + sample_idx_offset for idx in indices]
+            self.buckets[bucket_key].extend(adjusted_indices)
+
+    def _build_folder_metadata(self, folder):
+        feature_files = [f for f in os.listdir(folder) if f.endswith(".pt")]
+        samples = []
+        buckets = defaultdict(list)
+        sample_idx = 0
+
+        print(f"Processing {len(feature_files)} files in {folder}...")
+
+        for i, feature_file in enumerate(feature_files):
+            if i % 10000 == 0:
+                print(f"  Processed {i}/{len(feature_files)} files")
+
+            feature_path = os.path.join(folder, feature_file)
+
+            # Parse filename
+            parts = feature_file.split("_")
+            uttid = "_".join(parts[:-3])
+            num_frame = int(parts[-3])
+            height = int(parts[-2])
+            width = int(parts[-1].replace(".pt", ""))
+
+            # keep length >= 121
+            if num_frame < 121:
+                continue
+
+            # keep resolution
+            allowed_resolutions = [
+                (self.single_height, self.single_width),
+                (self.single_height // 2, self.single_width // 2),
+                (self.single_height // 4, self.single_width // 4),
+            ]
+            if self.single_res and (height, width) not in allowed_resolutions:
+                continue
+
+            bucket_key = (num_frame, height, width)
+
+            sample_info = {
+                "uttid": uttid,
+                "dataset_name": folder.rstrip("/"),
+                "file_path": feature_path,
+                "bucket_key": bucket_key,
+                "num_frame": num_frame,
+                "height": height,
+                "width": width,
+            }
+
+            samples.append(sample_info)
+            buckets[bucket_key].append(sample_idx)
+            sample_idx += 1
+
+        return samples, buckets
+
+    def set_epoch(self, epoch):
+        self._epoch = epoch
+
+    def prepare_stage1_latent(self, vae_latent, idx, base_vae_latent=None):
+        source_latent = base_vae_latent if base_vae_latent is not None else vae_latent
+
+        x0_latent = None
+        if self.is_keep_x0:
+            x0_latent = source_latent[0, :, :1, :, :].clone()
+        total_sections = source_latent.shape[0]
+        latent_window_size = source_latent.shape[2]
+        history_window_size = sum(self.history_sizes)
+        section_size = history_window_size + latent_window_size
+
+        temp_source_latent = rearrange(source_latent, "b c t h w -> c (b t) h w")
+        zero_padding_source = torch.zeros(
+            temp_source_latent.shape[0],
+            history_window_size,
+            temp_source_latent.shape[2],
+            temp_source_latent.shape[3],
+            device=temp_source_latent.device,
+            dtype=temp_source_latent.dtype,
+        )
+        continue_source_latent = torch.cat([zero_padding_source, temp_source_latent], dim=1)
+
+        temp_vae_latent = rearrange(vae_latent, "b c t h w -> c (b t) h w")
+        zero_padding_vae = torch.zeros(
+            temp_vae_latent.shape[0],
+            history_window_size,
+            temp_vae_latent.shape[2],
+            temp_vae_latent.shape[3],
+            device=temp_vae_latent.device,
+            dtype=temp_vae_latent.dtype,
+        )
+        continue_vae_latent = torch.cat([zero_padding_vae, temp_vae_latent], dim=1)
+
+        sample_seed = self.base_seed + self._epoch * 1000000 + idx
+        choice_idx = torch.randint(
+            0, total_sections, (1,), generator=torch.Generator().manual_seed(sample_seed)
+        ).item()
+        if choice_idx == 0 and x0_latent is not None:
+            x0_latent = torch.zeros_like(x0_latent)
+
+        clean_all_vae_latent = None
+        if self.return_all_vae_latent:
+            max_start_idx = total_sections - self.num_rollout_sections
+            if max_start_idx < 0:
+                raise ValueError(
+                    f"Not enough sections: total_sections={total_sections}, num_rollout_sections={self.num_rollout_sections}"
+                )
+            start_section_idx = random.randint(0, max_start_idx)
+            start_indice = start_section_idx * latent_window_size
+            end_indice = start_indice + history_window_size + self.num_rollout_sections * latent_window_size
+            clean_all_vae_latent = continue_source_latent[:, start_indice:end_indice, :, :]
+
+        start_indice = choice_idx * latent_window_size
+        end_indice = start_indice + section_size
+
+        history_latent = continue_source_latent[:, start_indice : start_indice + history_window_size, :, :]
+        target_latent = continue_vae_latent[:, start_indice + history_window_size : end_indice, :, :]
+
+        return x0_latent, history_latent, target_latent, clean_all_vae_latent
+
+    def __len__(self):
+        return len(self.samples)
+
+    def __getitem__(self, idx):
+        anchor_f = self.samples[idx]["num_frame"]
+        anchor_h = self.samples[idx]["height"]
+        anchor_w = self.samples[idx]["width"]
+        while True:
+            sample_info = self.samples[idx]
+
+            if (
+                anchor_f != sample_info["num_frame"]
+                or anchor_h != sample_info["height"]
+                or anchor_w != sample_info["width"]
+            ):
+                idx = random.randint(0, len(self.samples) - 1)
+                print("Try to find a same dim sample, retrying...")
+                continue
+
+            try:
+                base_vae_latent = None
+                if (anchor_h, anchor_w) in [
+                    (self.single_height // 2, self.single_width // 2),
+                    (self.single_height // 4, self.single_width // 4),
+                ]:
+                    base_file_path = (
+                        sample_info["file_path"]
+                        .replace("/mid", "")
+                        .replace("/low", "")
+                        .replace(
+                            f"{self.single_height // 2}_{self.single_width // 2}",
+                            f"{self.single_height}_{self.single_width}",
+                        )
+                        .replace(
+                            f"{self.single_height // 4}_{self.single_width // 4}",
+                            f"{self.single_height}_{self.single_width}",
+                        )
+                    )
+                    base_vae_latent = torch.load(base_file_path, map_location="cpu", weights_only=False)["vae_latent"]
+
+                feature_data = torch.load(sample_info["file_path"], map_location="cpu", weights_only=False)
+                x0_latent, history_latent, target_latent, clean_all_vae_latent = self.prepare_stage1_latent(
+                    feature_data["vae_latent"], idx, base_vae_latent
+                )
+                if self.return_prompt_raw:
+                    prompt_raws = feature_data["prompt_raw"]
+                break
+            except Exception:
+                idx = random.randint(0, len(self.samples) - 1)
+                print(f"Error loading {sample_info['file_path']}, retrying...")
+                file_name = os.path.basename(sample_info["file_path"])
+                txt_name = f"{file_name}.txt"
+                with open(txt_name, "w") as f:
+                    f.write(sample_info["file_path"] + "\n")
+
+        output_dict = {
+            "uttid": sample_info["uttid"],
+            "bucket_key": sample_info["bucket_key"],
+            "dataset_name": sample_info["dataset_name"],
+            "num_frame": sample_info["num_frame"],
+            "height": sample_info["height"],
+            "width": sample_info["width"],
+            "x0_latents": x0_latent,
+            "history_latents": history_latent,
+            "target_latents": target_latent,
+            "clean_all_latents": clean_all_vae_latent,
+            "prompt_embeds": feature_data["prompt_embed"],
+            "prompt_attention_masks": feature_data.get("prompt_attention_mask", None),
+        }
+
+        if self.return_prompt_raw:
+            output_dict["prompt_raws"] = prompt_raws
+
+        return output_dict
+
+
+class BucketedSampler(Sampler):
+    def __init__(
+        self,
+        dataset,
+        batch_size,
+        drop_last=False,
+        shuffle=True,
+        seed=42,
+        dataset_sampling_ratios=None,
+        num_sp_groups=1,
+        sp_world_size=1,
+        global_rank=0,
+    ):
+        self.dataset = dataset
+        self.batch_size = batch_size
+        self.drop_last = drop_last
+        self.shuffle = shuffle
+        self.seed = seed
+        self.generator = torch.Generator()
+        self.buckets = dataset.buckets
+        self._epoch = 0
+
+        # Distributed parameters
+        self.num_sp_groups = num_sp_groups
+        self.sp_world_size = sp_world_size
+        self.global_rank = global_rank
+        self.ith_sp_group = self.global_rank // self.sp_world_size
+
+        self.dataset_sampling_ratios = (
+            {key.rstrip("/"): value for key, value in dataset_sampling_ratios.items()}
+            if dataset_sampling_ratios is not None
+            else {}
+        )
+        self._prepare_dataset_buckets()
+
+    def _prepare_dataset_buckets(self):
+        self.dataset_buckets = {}
+
+        for bucket_key, sample_indices in self.buckets.items():
+            dataset_groups = {}
+            for idx in sample_indices:
+                dataset_name = self.dataset.samples[idx]["dataset_name"]
+                if dataset_name not in dataset_groups:
+                    dataset_groups[dataset_name] = []
+                dataset_groups[dataset_name].append(idx)
+            self.dataset_buckets[bucket_key] = dataset_groups
+
+    def set_epoch(self, epoch):
+        self._epoch = epoch
+
+    def _shard_indices_for_sp_group(self, indices):
+        """
+        Shard indices across SP groups, similar to DP_SP_BatchSampler.
+        Each SP group gets a disjoint subset of the data.
+        """
+        if self.num_sp_groups == 1:
+            return indices
+
+        # Convert to tensor if it's a list
+        if isinstance(indices, list):
+            indices_tensor = torch.tensor(indices, dtype=torch.long)
+        else:
+            indices_tensor = indices
+
+        # Pad indices if necessary to make it divisible by num_sp_groups
+        total_size = len(indices_tensor)
+        if total_size % self.num_sp_groups != 0:
+            if not self.drop_last:
+                padding_size = self.num_sp_groups - (total_size % self.num_sp_groups)
+                indices_tensor = torch.cat([indices_tensor, indices_tensor[:padding_size]])
+        else:
+            # If drop_last, truncate to be divisible
+            if self.drop_last:
+                truncate_size = (total_size // self.num_sp_groups) * self.num_sp_groups
+                indices_tensor = indices_tensor[:truncate_size]
+
+        # Shard: each SP group gets every num_sp_groups-th element
+        sp_group_indices = indices_tensor[self.ith_sp_group :: self.num_sp_groups]
+
+        return sp_group_indices.tolist()
+
+    def _apply_global_ratio_sampling(self):
+        if not self.dataset_sampling_ratios:
+            return
+
+        dataset_sample_map = {}
+        for bucket_key, dataset_groups in self.dataset_buckets.items():
+            for dataset_name, indices in dataset_groups.items():
+                if dataset_name not in dataset_sample_map:
+                    dataset_sample_map[dataset_name] = {"indices": [], "buckets": []}
+                dataset_sample_map[dataset_name]["indices"].extend(indices)
+                dataset_sample_map[dataset_name]["buckets"].extend([bucket_key] * len(indices))
+
+        total_samples = sum(len(info["indices"]) for info in dataset_sample_map.values())
+        total_ratio = sum(self.dataset_sampling_ratios.values())
+
+        sampled_dataset_map = {}
+        for dataset_name, info in dataset_sample_map.items():
+            if dataset_name in self.dataset_sampling_ratios:
+                ratio = self.dataset_sampling_ratios[dataset_name] / total_ratio
+                target_samples = max(1, int(total_samples * ratio))
+
+                indices = info["indices"]
+                buckets = info["buckets"]
+
+                if len(indices) >= target_samples:
+                    selected = torch.randperm(len(indices), generator=self.generator)[:target_samples].tolist()
+                    sampled_indices = [indices[i] for i in selected]
+                    sampled_buckets = [buckets[i] for i in selected]
+                else:
+                    sampled_indices = []
+                    sampled_buckets = []
+                    remaining = target_samples
+
+                    while remaining > 0:
+                        repeat_count = min(remaining, len(indices))
+                        selected = torch.randperm(len(indices), generator=self.generator)[:repeat_count].tolist()
+                        sampled_indices.extend([indices[i] for i in selected])
+                        sampled_buckets.extend([buckets[i] for i in selected])
+                        remaining -= repeat_count
+
+                sampled_dataset_map[dataset_name] = {"indices": sampled_indices, "buckets": sampled_buckets}
+            else:
+                sampled_dataset_map[dataset_name] = info
+
+        new_dataset_buckets = {}
+        for bucket_key in self.dataset_buckets.keys():
+            new_dataset_buckets[bucket_key] = {}
+
+        for dataset_name, info in sampled_dataset_map.items():
+            indices = info["indices"]
+            buckets = info["buckets"]
+
+            for idx, bucket_key in zip(indices, buckets):
+                if dataset_name not in new_dataset_buckets[bucket_key]:
+                    new_dataset_buckets[bucket_key][dataset_name] = []
+                new_dataset_buckets[bucket_key][dataset_name].append(idx)
+
+        self.dataset_buckets = new_dataset_buckets
+
+    def __iter__(self):
+        # Use epoch-level seed for reproducibility
+        epoch_seed = self.seed + self._epoch
+        self.generator.manual_seed(epoch_seed)
+
+        if self.dataset_sampling_ratios:
+            self._apply_global_ratio_sampling()
+
+        bucket_iterators = {}
+        bucket_batches = {}
+
+        for bucket_key, dataset_groups in self.dataset_buckets.items():
+            balanced_indices = self._create_balanced_indices(dataset_groups)
+
+            # Global shuffle before sharding (important for distributed consistency)
+            if self.shuffle:
+                perm = torch.randperm(len(balanced_indices), generator=self.generator).tolist()
+                balanced_indices = [balanced_indices[i] for i in perm]
+
+            # Shard indices for this SP group
+            sp_group_indices = self._shard_indices_for_sp_group(balanced_indices)
+
+            batches = []
+            for i in range(0, len(sp_group_indices), self.batch_size):
+                batch = sp_group_indices[i : i + self.batch_size]
+                if len(batch) == self.batch_size or not self.drop_last:
+                    batches.append(batch)
+
+            if batches:
+                bucket_batches[bucket_key] = batches
+                bucket_iterators[bucket_key] = iter(batches)
+
+        remaining_buckets = list(bucket_iterators.keys())
+
+        while remaining_buckets:
+            idx = torch.randint(len(remaining_buckets), (1,), generator=self.generator).item()
+            bucket_key = remaining_buckets[idx]
+            bucket_iter = bucket_iterators[bucket_key]
+
+            try:
+                batch = next(bucket_iter)
+                yield batch
+            except StopIteration:
+                remaining_buckets.remove(bucket_key)
+
+    def _create_balanced_indices(self, dataset_groups):
+        return sum(dataset_groups.values(), [])
+
+    def _equal_sampling(self, dataset_groups):
+        all_indices = []
+        dataset_names = list(dataset_groups.keys())
+
+        if len(dataset_names) <= 1:
+            return sum(dataset_groups.values(), [])
+
+        min_samples = min(len(indices) for indices in dataset_groups.values())
+
+        for dataset_name, indices in dataset_groups.items():
+            if len(indices) > min_samples:
+                selected = torch.randperm(len(indices), generator=self.generator)[:min_samples].tolist()
+                sampled_indices = [indices[i] for i in selected]
+            else:
+                sampled_indices = indices
+            all_indices.extend(sampled_indices)
+
+        return all_indices
+
+    def _ratio_sampling(self, dataset_groups):
+        return sum(dataset_groups.values(), [])
+
+    def __len__(self):
+        if self.dataset_sampling_ratios:
+            temp_generator = torch.Generator()
+            temp_generator.manual_seed(self.seed)
+
+            dataset_sample_map = {}
+            for bucket_key, dataset_groups in self.dataset_buckets.items():
+                for dataset_name, indices in dataset_groups.items():
+                    if dataset_name not in dataset_sample_map:
+                        dataset_sample_map[dataset_name] = []
+                    dataset_sample_map[dataset_name].extend(indices)
+
+            total_samples = sum(len(indices) for indices in dataset_sample_map.values())
+            total_ratio = sum(self.dataset_sampling_ratios.values())
+
+            sampled_total = 0
+            for dataset_name, indices in dataset_sample_map.items():
+                if dataset_name in self.dataset_sampling_ratios:
+                    ratio = self.dataset_sampling_ratios[dataset_name] / total_ratio
+                    target_samples = max(1, int(total_samples * ratio))
+                    sampled_total += target_samples
+                else:
+                    sampled_total += len(indices)
+
+            # Account for SP group sharding
+            sp_group_samples = sampled_total // self.num_sp_groups
+            if not self.drop_last and sampled_total % self.num_sp_groups != 0:
+                sp_group_samples += 1
+
+            total_batches = sp_group_samples // self.batch_size
+            if not self.drop_last and sp_group_samples % self.batch_size != 0:
+                total_batches += 1
+            return total_batches
+        else:
+            total_batches = 0
+            for bucket_key, dataset_groups in self.dataset_buckets.items():
+                balanced_indices = self._create_balanced_indices(dataset_groups)
+
+                # Account for SP group sharding
+                sp_group_size = len(balanced_indices) // self.num_sp_groups
+                if not self.drop_last and len(balanced_indices) % self.num_sp_groups != 0:
+                    sp_group_size += 1
+
+                num_batches = sp_group_size // self.batch_size
+                if not self.drop_last and sp_group_size % self.batch_size != 0:
+                    num_batches += 1
+                total_batches += num_batches
+            return total_batches
+
+
+def collate_fn(batch):
+    return {
+        key: torch.stack([d[key] for d in batch])
+        if isinstance(batch[0][key], torch.Tensor)
+        else [d[key] for d in batch]
+        for key in batch[0]
+    }
+
+
+if __name__ == "__main__":
+    import torch.distributed.checkpoint as dcp
+    from accelerate import Accelerator
+    from torchdata.stateful_dataloader import StatefulDataLoader
+
+    feature_folder = [
+        "demo_data/ultravideo-long",
+    ]
+    dataloader_num_workers = 0
+    batch_size = 2
+    num_train_epochs = 2
+    seed = 0
+    output_dir = "accelerate_checkpoints"
+    checkpoint_dirs = (
+        [
+            d
+            for d in os.listdir(output_dir)
+            if d.startswith("checkpoint-") and os.path.isdir(os.path.join(output_dir, d))
+        ]
+        if os.path.exists(output_dir)
+        else []
+    )
+
+    dataset_ratios = {}
+    # dataset_ratios = {
+    #     "demo_data/ultravideo-long": 0.9,
+    # }
+
+    accelerator = Accelerator()
+    print(accelerator.process_index, accelerator.num_processes)
+
+    dataset = BucketedFeatureDataset(
+        feature_folder,
+        force_rebuild=True,
+        return_all_vae_latent=True,
+        return_prompt_raw=True,
+        single_res=True,
+        single_height=384,
+        single_width=640,
+        seed=seed,
+    )
+    sampler = BucketedSampler(
+        dataset,
+        batch_size=batch_size,
+        drop_last=True,
+        shuffle=True,
+        dataset_sampling_ratios=dataset_ratios,
+        seed=seed,
+        # num_sp_groups=get_world_size() // get_sp_world_size(),
+        # sp_world_size=get_sp_world_size(),
+        # global_rank=get_world_rank(),
+        num_sp_groups=accelerator.num_processes // 1,
+        sp_world_size=1,
+        global_rank=accelerator.process_index,
+    )
+    dataloader = StatefulDataLoader(
+        dataset, batch_sampler=sampler, collate_fn=collate_fn, num_workers=dataloader_num_workers
+    )
+
+    print(len(dataset), len(dataloader))
+    print(f"Dataset size: {len(dataset)}, Dataloader batches: {len(dataloader)}")
+
+    step = 0
+    global_step = 0
+    first_epoch = 0
+    num_update_steps_per_epoch = len(dataloader)
+    if checkpoint_dirs:
+        latest_checkpoint = max(checkpoint_dirs, key=lambda x: int(x.split("-")[1]))
+        checkpoint_path = os.path.join(output_dir, latest_checkpoint)
+        print(f"Found checkpoint: {checkpoint_path}")
+
+        accelerator.load_state(checkpoint_path)
+        global_step = int(latest_checkpoint.split("-")[1])
+        first_epoch = global_step // num_update_steps_per_epoch
+
+        states = {
+            "dataloader": dataloader,
+        }
+        dcp_dir = os.path.join(checkpoint_path, "distributed_checkpoint")
+        dcp.load(states, checkpoint_id=dcp_dir)
+
+        print(f"Resuming from step {global_step}, epoch {first_epoch}")
+
+    print("Testing dataloader...")
+    step = global_step
+    dataset_counts = defaultdict(int)
+    for epoch in range(first_epoch, num_train_epochs):
+        sampler.set_epoch(epoch)
+        dataset.set_epoch(epoch)
+        for i, batch in enumerate(dataloader):
+            # Get metadata
+            uttid = batch["uttid"]
+            num_frame = batch["num_frame"]
+            height = batch["height"]
+            width = batch["width"]
+            bucket_key = batch["bucket_key"]
+
+            # Get feature
+            x0_latents = batch["x0_latents"]
+            history_latents = batch["history_latents"]
+            target_latents = batch["target_latents"]
+            prompt_embeds = batch["prompt_embeds"]
+
+            if accelerator.process_index == 0:
+                # print info
+                print(f" Step {step}:")
+                print(f"  Batch {i}:")
+                # print(f"  Data Name: {batch['dataset_name']}")
+                print(f"  Batch size: {len(uttid)}")
+                print(f"  Uttids: {uttid}")
+                print(f"  Dimensions - frames: {num_frame[0]}, height: {height[0]}, width: {width[0]}")
+                print(f"  Bucket key: {bucket_key[0]}")
+                print(f"  X0 latent shape: {x0_latents.shape}")
+                print(f"  History latent shape: {history_latents.shape}")
+                print(f"  Context latent shape: {target_latents.shape}")
+                print(f"  Prompt embed shape: {prompt_embeds.shape}")
+                # print(f"  Prompt attention mask shape: {prompt_attention_masks.shape}")
+
+                # verify
+                assert all(nf == num_frame[0] for nf in num_frame), "Frame numbers not consistent in batch"
+                assert all(h == height[0] for h in height), "Heights not consistent in batch"
+                assert all(w == width[0] for w in width), "Widths not consistent in batch"
+
+                print("  ✓ Batch dimensions are consistent")
+
+            for dataset_name in batch["dataset_name"]:
+                dataset_counts[dataset_name] += 1
+
+            step += 1
+
+            # if step == 20:
+            #     checkpoint_dir = f"checkpoint-{step}"
+            #     save_path = os.path.join(output_dir, checkpoint_dir)
+            #     os.makedirs(save_path, exist_ok=True)
+
+            #     if accelerator.is_main_process:
+            #         print(f"Saving checkpoint at step {step}")
+
+            #         accelerator.save_state(save_path)
+
+            #     print(accelerator.process_index, accelerator.num_processes)
+            #     states = {
+            #         "dataloader": dataloader,
+            #     }
+            #     dcp_dir = os.path.join(save_path, "distributed_checkpoint")
+            #     dcp.save(states, checkpoint_id=dcp_dir)
+
+    print("实际采样统计:", dict(dataset_counts))

Helios/_DEV2/helios/dataset/dataloader_mp4_dist.py

@@ -0,0 +1,854 @@
+import json
+import os
+import pickle
+import random
+from collections import defaultdict
+from typing import Optional
+
+import pandas as pd
+import torch
+import torchvision
+from torch.utils.data import Dataset, Sampler
+from video_reader import PyVideoReader
+
+from diffusers.training_utils import free_memory
+from diffusers.utils import export_to_video
+
+
+resolution_bucket_options = {
+    640: [
+        (768, 320),
+        (768, 384),
+        (640, 384),
+        (768, 512),
+        (576, 448),
+        (512, 512),
+        (448, 576),
+        (512, 768),
+        (384, 640),
+        (384, 768),
+        (320, 768),
+    ],
+}
+
+length_bucket_options = {
+    1: [
+        501,
+        481,
+        461,
+        441,
+        421,
+        401,
+        381,
+        361,
+        341,
+        321,
+        301,
+        281,
+        261,
+        241,
+        221,
+        193,
+        181,
+        161,
+        141,
+        121,
+        101,
+        81,
+        61,
+        41,
+        21,
+    ],
+    2: [193, 177, 161, 156, 145, 133, 129, 121, 113, 109, 97, 85, 81, 73, 65, 61, 49, 37, 25],
+}
+
+
+def find_nearest_resolution_bucket(h, w, resolution=640):
+    min_metric = float("inf")
+    best_bucket = None
+    for bucket_h, bucket_w in resolution_bucket_options[resolution]:
+        metric = abs(h * bucket_w - w * bucket_h)
+        if metric <= min_metric:
+            min_metric = metric
+            best_bucket = (bucket_h, bucket_w)
+    return best_bucket
+
+
+def find_nearest_length_bucket(length, stride=1):
+    buckets = length_bucket_options[stride]
+    min_bucket = min(buckets)
+    if length < min_bucket:
+        return length
+    valid_buckets = [bucket for bucket in buckets if bucket <= length]
+    return max(valid_buckets)
+
+
+def read_cut_crop_and_resize(
+    video_path, f_prime, h_prime, w_prime, stride=1, start_frame=None, end_frame=None, crop=None
+):
+    frame_indices = list(range(start_frame, end_frame, stride))
+    assert len(frame_indices) == f_prime
+
+    vr = PyVideoReader(video_path, threads=0)  # 0 means auto (let ffmpeg pick the optimal number)
+    frames = torch.from_numpy(vr.get_batch(frame_indices)).float()
+
+    frames = (frames / 127.5) - 1
+    video = frames.permute(0, 3, 1, 2)
+
+    s_x, e_x, s_y, e_y = crop
+    video = video[:, :, s_y:e_y, s_x:e_x]
+
+    frames, channels, h, w = video.shape
+    aspect_ratio_original = h / w
+    aspect_ratio_target = h_prime / w_prime
+
+    if aspect_ratio_original >= aspect_ratio_target:
+        new_h = int(w * aspect_ratio_target)
+        top = (h - new_h) // 2
+        bottom = top + new_h
+        left = 0
+        right = w
+    else:
+        new_w = int(h / aspect_ratio_target)
+        left = (w - new_w) // 2
+        right = left + new_w
+        top = 0
+        bottom = h
+
+    # Crop the video
+    cropped_video = video[:, :, top:bottom, left:right]
+    # Resize the cropped video
+    resized_video = torchvision.transforms.functional.resize(cropped_video, (h_prime, w_prime))
+    return resized_video
+
+
+def save_frames(frame_raw, fps=24, video_path="1.mp4"):
+    save_list = []
+    for frame in frame_raw:
+        frame = (frame + 1) / 2 * 255
+        frame = torchvision.transforms.transforms.ToPILImage()(frame.to(torch.uint8)).convert("RGB")
+        save_list.append(frame)
+        frame = None
+        del frame
+    export_to_video(save_list, video_path, fps=fps)
+
+    save_list = None
+    del save_list
+    free_memory()
+
+
+class BucketedFeatureDataset(Dataset):
+    def __init__(
+        self,
+        json_files,
+        video_folders,
+        stride=1,
+        base_fps=None,
+        resolution=640,
+        force_rebuild=True,
+        single_res=False,
+        single_length=False,
+        single_num_frame=81,
+        single_height=384,
+        single_width=640,
+        multi_res=False,
+        id_token: Optional[str] = None,
+    ):
+        self.stride = stride
+        self.base_fps = base_fps
+        self.resolution = resolution
+        self.force_rebuild = force_rebuild
+        self.single_res = single_res
+        self.single_height = single_height
+        self.single_width = single_width
+        self.single_length = single_length
+        self.single_num_frame = single_num_frame
+        self.multi_res = multi_res
+        self.id_token = id_token or ""
+        self._epoch = 0
+
+        if isinstance(json_files, str):
+            self.json_files = [json_files]
+        else:
+            self.json_files = json_files
+
+        if isinstance(video_folders, str):
+            self.video_folders = [video_folders]
+        else:
+            self.video_folders = video_folders
+
+        assert len(self.json_files) == len(self.video_folders), (
+            f"json_files ({len(self.json_files)}) and video_folders ({len(self.video_folders)}) must have the same length"
+        )
+
+        self.samples = []
+        self.buckets = defaultdict(list)
+
+        for json_file, video_folder in zip(self.json_files, self.video_folders):
+            cache_file = json_file.replace(".json", "_cache.pkl").replace(".csv", "_cache.pkl")
+            self._process_json_file(json_file, video_folder, cache_file)
+
+    def _process_json_file(self, json_file, video_folder, cache_file):
+        if self.force_rebuild or not os.path.exists(cache_file):
+            if os.path.exists(cache_file):
+                print(f"Remove {cache_file}")
+                os.remove(cache_file)
+            print(f"Building metadata cache for file: {json_file}")
+            print(f"  Video folder: {video_folder}")
+            file_samples, file_buckets = self._build_file_metadata(json_file, video_folder)
+
+            print(f"Saving metadata cache to: {cache_file}")
+            cached_data = {"samples": file_samples, "buckets": file_buckets}
+            with open(cache_file, "wb") as f:
+                pickle.dump(cached_data, f)
+            print(f"Cached {len(file_samples)} samples from {json_file}\n")
+        else:
+            print(f"Loading cached metadata from: {cache_file}")
+            with open(cache_file, "rb") as f:
+                cached_data = pickle.load(f)
+            file_samples = cached_data["samples"]
+            file_buckets = cached_data["buckets"]
+            print(f"Loaded {len(file_samples)} samples from cache: {cache_file}\n")
+
+        sample_idx_offset = len(self.samples)
+        self.samples.extend(file_samples)
+
+        for bucket_key, indices in file_buckets.items():
+            adjusted_indices = [idx + sample_idx_offset for idx in indices]
+            self.buckets[bucket_key].extend(adjusted_indices)
+
+    def _build_file_metadata(self, json_file, video_folder):
+        with open(json_file, "r") as f:
+            data = json.load(f)
+
+        print(f"Scanning video folder: {video_folder}")
+        existing_videos = set()
+        for root, dirs, files in os.walk(video_folder):
+            for file in files:
+                if file.endswith(".mp4"):
+                    rel_path = os.path.relpath(os.path.join(root, file), video_folder)
+                    existing_videos.add(rel_path)
+        print(f"Found {len(existing_videos)} video files")
+
+        df = pd.DataFrame(
+            [
+                {
+                    "cut": item["cut"],
+                    "crop": item["crop"],
+                    "path": item["path"],
+                    "num_frames": item["num_frames"],
+                    "width": item["resolution"]["width"],
+                    "height": item["resolution"]["height"],
+                    "fps": item["fps"],
+                    "cap": item["cap"],
+                }
+                for item in data
+            ]
+        )
+
+        samples = []
+        buckets = defaultdict(list)
+        sample_idx = 0
+
+        print(f"Processing {len(df)} records from {json_file} with stride={self.stride}...")
+        for i, row in df.iterrows():
+            if i % 10000 == 0:
+                print(f"  Processed {i}/{len(df)} records")
+
+            video_file = (
+                row["path"]
+                .replace("videos_clip_v1_20241111/", "")
+                .replace("videos_clip_v2_20241111/", "")
+                .replace("videos_clip_v4_20241111/", "")
+            )
+            if video_file not in existing_videos:
+                print("bad video!")
+                continue
+            video_path = os.path.join(video_folder, video_file)
+
+            cut_start_frame = row["cut"][0]
+            cut_end_frame = row["cut"][1]
+            num_frame = cut_end_frame - cut_start_frame
+
+            if self.single_length:
+                if num_frame < self.single_num_frame:
+                    continue
+            else:
+                if num_frame < 121:
+                    continue
+
+            uttid = os.path.basename(video_file).replace(".mp4", "") + f"_{cut_start_frame}-{cut_end_frame}"
+            fps = row["fps"]
+
+            crop = row["crop"]
+            width = crop[1] - crop[0]
+            height = crop[3] - crop[2]
+
+            prompt = row["cap"][0]
+
+            # TODO need to be checked
+            effective_num_frame = (num_frame + self.stride - 1) // self.stride
+            bucket_num_frame = find_nearest_length_bucket(effective_num_frame, stride=self.stride)
+            bucket_height, bucket_width = find_nearest_resolution_bucket(height, width, resolution=self.resolution)
+
+            if self.single_res or self.multi_res:
+                allowed_resolutions = [(self.single_height, self.single_width)]
+                if self.multi_res:
+                    allowed_resolutions.extend(
+                        [
+                            (self.single_height // 2, self.single_width // 2),
+                            (self.single_height // 4, self.single_width // 4),
+                        ]
+                    )
+                if (bucket_height, bucket_width) not in allowed_resolutions:
+                    print("continue res")
+                    continue
+                bucket_height, bucket_width = random.choice(allowed_resolutions)
+
+            if self.single_length:
+                bucket_num_frame = self.single_num_frame
+
+            if self.base_fps is not None:
+                stride = max(int(fps / self.base_fps), 1)
+                required_frames = bucket_num_frame * stride
+                if required_frames >= num_frame:
+                    print("continue frame")
+                    continue
+            else:
+                stride = self.stride
+
+            bucket_key = (bucket_num_frame, bucket_height, bucket_width)
+
+            sample_info = {
+                "uttid": uttid,
+                "dataset_name": json_file.rstrip("/"),
+                "video_folder": video_folder,
+                "video_path": video_path,
+                "bucket_key": bucket_key,
+                "prompt": self.id_token + prompt,
+                "fps": fps,
+                "stride": stride,
+                "effective_num_frame": effective_num_frame,
+                "num_frame": num_frame,
+                "height": height,
+                "width": width,
+                "bucket_num_frame": bucket_num_frame,
+                "bucket_height": bucket_height,
+                "bucket_width": bucket_width,
+                "cut_start_frame": cut_start_frame,
+                "cut_end_frame": cut_end_frame,
+                "crop": crop,
+            }
+
+            samples.append(sample_info)
+            buckets[bucket_key].append(sample_idx)
+            sample_idx += 1
+
+        return samples, buckets
+
+    def set_epoch(self, epoch):
+        self._epoch = epoch
+
+    def __len__(self):
+        return len(self.samples)
+
+    def __getitem__(self, idx):
+        anchor_h = self.samples[idx]["bucket_height"]
+        anchor_w = self.samples[idx]["bucket_width"]
+        anchor_f = self.samples[idx]["bucket_num_frame"]
+
+        max_retries = 1000
+        retry_count = 0
+
+        while retry_count < max_retries:
+            sample_info = self.samples[idx]
+
+            if (
+                anchor_h != sample_info["bucket_height"]
+                or anchor_w != sample_info["bucket_width"]
+                or anchor_f != sample_info["bucket_num_frame"]
+            ):
+                idx = random.randint(0, len(self.samples) - 1)
+                retry_count += 1
+                continue
+
+            try:
+                stride = sample_info["stride"]
+                cut_start_frame = sample_info["cut_start_frame"]
+                cut_end_frame = sample_info["cut_end_frame"]
+                bucket_num_frame = sample_info["bucket_num_frame"]
+
+                max_start_frame = cut_end_frame - bucket_num_frame * stride
+                if max_start_frame < cut_start_frame:
+                    start_frame = cut_start_frame
+                else:
+                    start_frame = random.randint(cut_start_frame, max_start_frame)
+                end_frame = start_frame + bucket_num_frame * stride
+
+                video_data = read_cut_crop_and_resize(
+                    video_path=sample_info["video_path"],
+                    f_prime=sample_info["bucket_num_frame"],
+                    h_prime=sample_info["bucket_height"],
+                    w_prime=sample_info["bucket_width"],
+                    stride=stride,
+                    start_frame=start_frame,
+                    end_frame=end_frame,
+                    crop=sample_info["crop"],
+                )
+
+                return {
+                    "uttid": sample_info["uttid"],
+                    "bucket_key": sample_info["bucket_key"],
+                    "dataset_name": sample_info["dataset_name"],
+                    "video_metadata": {
+                        "num_frames": sample_info["bucket_num_frame"],
+                        "height": sample_info["bucket_height"],
+                        "width": sample_info["bucket_width"],
+                        "fps": sample_info["fps"],
+                        "stride": stride,
+                        "effective_num_frame": sample_info["effective_num_frame"],
+                    },
+                    "videos": video_data,
+                    "prompts": sample_info["prompt"],
+                    "first_frames_images": (video_data[0] + 1) / 2 * 255,
+                }
+            except Exception as e:
+                print(f"Error loading {sample_info['video_path']}: {e}")
+                idx = random.randint(0, len(self.samples) - 1)
+                retry_count += 1
+
+        print(f"Failed to load sample after {max_retries} retries, returning None")
+        return None
+
+
+class BucketedSampler(Sampler):
+    def __init__(
+        self,
+        dataset,
+        batch_size,
+        drop_last=False,
+        shuffle=True,
+        seed=42,
+        dataset_sampling_ratios=None,
+        num_sp_groups=1,
+        sp_world_size=1,
+        global_rank=0,
+    ):
+        self.dataset = dataset
+        self.batch_size = batch_size
+        self.drop_last = drop_last
+        self.shuffle = shuffle
+        self.seed = seed
+        self.generator = torch.Generator()
+        self.buckets = dataset.buckets
+        self._epoch = 0
+
+        # Distributed parameters
+        self.num_sp_groups = num_sp_groups
+        self.sp_world_size = sp_world_size
+        self.global_rank = global_rank
+        self.ith_sp_group = self.global_rank // self.sp_world_size
+
+        self.dataset_sampling_ratios = (
+            {key.rstrip("/"): value for key, value in dataset_sampling_ratios.items()}
+            if dataset_sampling_ratios is not None
+            else {}
+        )
+        self._prepare_dataset_buckets()
+
+    def _prepare_dataset_buckets(self):
+        self.dataset_buckets = {}
+
+        for bucket_key, sample_indices in self.buckets.items():
+            dataset_groups = {}
+            for idx in sample_indices:
+                dataset_name = self.dataset.samples[idx]["dataset_name"]
+                if dataset_name not in dataset_groups:
+                    dataset_groups[dataset_name] = []
+                dataset_groups[dataset_name].append(idx)
+            self.dataset_buckets[bucket_key] = dataset_groups
+
+    def set_epoch(self, epoch):
+        self._epoch = epoch
+
+    def _shard_indices_for_sp_group(self, indices):
+        """
+        Shard indices across SP groups, similar to DP_SP_BatchSampler.
+        Each SP group gets a disjoint subset of the data.
+        """
+        if self.num_sp_groups == 1:
+            return indices
+
+        # Convert to tensor if it's a list
+        if isinstance(indices, list):
+            indices_tensor = torch.tensor(indices, dtype=torch.long)
+        else:
+            indices_tensor = indices
+
+        # Pad indices if necessary to make it divisible by num_sp_groups
+        total_size = len(indices_tensor)
+        if total_size % self.num_sp_groups != 0:
+            if not self.drop_last:
+                padding_size = self.num_sp_groups - (total_size % self.num_sp_groups)
+                indices_tensor = torch.cat([indices_tensor, indices_tensor[:padding_size]])
+        else:
+            # If drop_last, truncate to be divisible
+            if self.drop_last:
+                truncate_size = (total_size // self.num_sp_groups) * self.num_sp_groups
+                indices_tensor = indices_tensor[:truncate_size]
+
+        # Shard: each SP group gets every num_sp_groups-th element
+        sp_group_indices = indices_tensor[self.ith_sp_group :: self.num_sp_groups]
+
+        return sp_group_indices.tolist()
+
+    def _apply_global_ratio_sampling(self):
+        if not self.dataset_sampling_ratios:
+            return
+
+        dataset_sample_map = {}
+        for bucket_key, dataset_groups in self.dataset_buckets.items():
+            for dataset_name, indices in dataset_groups.items():
+                if dataset_name not in dataset_sample_map:
+                    dataset_sample_map[dataset_name] = {"indices": [], "buckets": []}
+                dataset_sample_map[dataset_name]["indices"].extend(indices)
+                dataset_sample_map[dataset_name]["buckets"].extend([bucket_key] * len(indices))
+
+        total_samples = sum(len(info["indices"]) for info in dataset_sample_map.values())
+        total_ratio = sum(self.dataset_sampling_ratios.values())
+
+        sampled_dataset_map = {}
+        for dataset_name, info in dataset_sample_map.items():
+            if dataset_name in self.dataset_sampling_ratios:
+                ratio = self.dataset_sampling_ratios[dataset_name] / total_ratio
+                target_samples = max(1, int(total_samples * ratio))
+
+                indices = info["indices"]
+                buckets = info["buckets"]
+
+                if len(indices) >= target_samples:
+                    selected = torch.randperm(len(indices), generator=self.generator)[:target_samples].tolist()
+                    sampled_indices = [indices[i] for i in selected]
+                    sampled_buckets = [buckets[i] for i in selected]
+                else:
+                    sampled_indices = []
+                    sampled_buckets = []
+                    remaining = target_samples
+
+                    while remaining > 0:
+                        repeat_count = min(remaining, len(indices))
+                        selected = torch.randperm(len(indices), generator=self.generator)[:repeat_count].tolist()
+                        sampled_indices.extend([indices[i] for i in selected])
+                        sampled_buckets.extend([buckets[i] for i in selected])
+                        remaining -= repeat_count
+
+                sampled_dataset_map[dataset_name] = {"indices": sampled_indices, "buckets": sampled_buckets}
+            else:
+                sampled_dataset_map[dataset_name] = info
+
+        new_dataset_buckets = {}
+        for bucket_key in self.dataset_buckets.keys():
+            new_dataset_buckets[bucket_key] = {}
+
+        for dataset_name, info in sampled_dataset_map.items():
+            indices = info["indices"]
+            buckets = info["buckets"]
+
+            for idx, bucket_key in zip(indices, buckets):
+                if dataset_name not in new_dataset_buckets[bucket_key]:
+                    new_dataset_buckets[bucket_key][dataset_name] = []
+                new_dataset_buckets[bucket_key][dataset_name].append(idx)
+
+        self.dataset_buckets = new_dataset_buckets
+
+    def __iter__(self):
+        # Use epoch-level seed for reproducibility
+        epoch_seed = self.seed + self._epoch
+        self.generator.manual_seed(epoch_seed)
+
+        if self.dataset_sampling_ratios:
+            self._apply_global_ratio_sampling()
+
+        bucket_iterators = {}
+        bucket_batches = {}
+
+        for bucket_key, dataset_groups in self.dataset_buckets.items():
+            balanced_indices = self._create_balanced_indices(dataset_groups)
+
+            # Global shuffle before sharding (important for distributed consistency)
+            if self.shuffle:
+                perm = torch.randperm(len(balanced_indices), generator=self.generator).tolist()
+                balanced_indices = [balanced_indices[i] for i in perm]
+
+            # Shard indices for this SP group
+            sp_group_indices = self._shard_indices_for_sp_group(balanced_indices)
+
+            batches = []
+            for i in range(0, len(sp_group_indices), self.batch_size):
+                batch = sp_group_indices[i : i + self.batch_size]
+                if len(batch) == self.batch_size or not self.drop_last:
+                    batches.append(batch)
+
+            if batches:
+                bucket_batches[bucket_key] = batches
+                bucket_iterators[bucket_key] = iter(batches)
+
+        remaining_buckets = list(bucket_iterators.keys())
+
+        while remaining_buckets:
+            idx = torch.randint(len(remaining_buckets), (1,), generator=self.generator).item()
+            bucket_key = remaining_buckets[idx]
+            bucket_iter = bucket_iterators[bucket_key]
+
+            try:
+                batch = next(bucket_iter)
+                yield batch
+            except StopIteration:
+                remaining_buckets.remove(bucket_key)
+
+    def _create_balanced_indices(self, dataset_groups):
+        return sum(dataset_groups.values(), [])
+
+    def _equal_sampling(self, dataset_groups):
+        all_indices = []
+        dataset_names = list(dataset_groups.keys())
+
+        if len(dataset_names) <= 1:
+            return sum(dataset_groups.values(), [])
+
+        min_samples = min(len(indices) for indices in dataset_groups.values())
+
+        for dataset_name, indices in dataset_groups.items():
+            if len(indices) > min_samples:
+                selected = torch.randperm(len(indices), generator=self.generator)[:min_samples].tolist()
+                sampled_indices = [indices[i] for i in selected]
+            else:
+                sampled_indices = indices
+            all_indices.extend(sampled_indices)
+
+        return all_indices
+
+    def _ratio_sampling(self, dataset_groups):
+        return sum(dataset_groups.values(), [])
+
+    def __len__(self):
+        if self.dataset_sampling_ratios:
+            temp_generator = torch.Generator()
+            temp_generator.manual_seed(self.seed)
+
+            dataset_sample_map = {}
+            for bucket_key, dataset_groups in self.dataset_buckets.items():
+                for dataset_name, indices in dataset_groups.items():
+                    if dataset_name not in dataset_sample_map:
+                        dataset_sample_map[dataset_name] = []
+                    dataset_sample_map[dataset_name].extend(indices)
+
+            total_samples = sum(len(indices) for indices in dataset_sample_map.values())
+            total_ratio = sum(self.dataset_sampling_ratios.values())
+
+            sampled_total = 0
+            for dataset_name, indices in dataset_sample_map.items():
+                if dataset_name in self.dataset_sampling_ratios:
+                    ratio = self.dataset_sampling_ratios[dataset_name] / total_ratio
+                    target_samples = max(1, int(total_samples * ratio))
+                    sampled_total += target_samples
+                else:
+                    sampled_total += len(indices)
+
+            # Account for SP group sharding
+            sp_group_samples = sampled_total // self.num_sp_groups
+            if not self.drop_last and sampled_total % self.num_sp_groups != 0:
+                sp_group_samples += 1
+
+            total_batches = sp_group_samples // self.batch_size
+            if not self.drop_last and sp_group_samples % self.batch_size != 0:
+                total_batches += 1
+            return total_batches
+        else:
+            total_batches = 0
+            for bucket_key, dataset_groups in self.dataset_buckets.items():
+                balanced_indices = self._create_balanced_indices(dataset_groups)
+
+                # Account for SP group sharding
+                sp_group_size = len(balanced_indices) // self.num_sp_groups
+                if not self.drop_last and len(balanced_indices) % self.num_sp_groups != 0:
+                    sp_group_size += 1
+
+                num_batches = sp_group_size // self.batch_size
+                if not self.drop_last and sp_group_size % self.batch_size != 0:
+                    num_batches += 1
+                total_batches += num_batches
+            return total_batches
+
+
+def collate_fn(batch):
+    batch = [item for item in batch if item is not None]
+
+    if len(batch) == 0:
+        return None
+
+    def collate_dict(data_list):
+        if isinstance(data_list[0], dict):
+            return {key: collate_dict([d[key] for d in data_list]) for key in data_list[0]}
+        elif isinstance(data_list[0], torch.Tensor):
+            return torch.stack(data_list)
+        else:
+            return data_list
+
+    return {key: collate_dict([d[key] for d in batch]) for key in batch[0]}
+
+
+if __name__ == "__main__":
+    import torch.distributed.checkpoint as dcp
+    from accelerate import Accelerator
+    from torchdata.stateful_dataloader import StatefulDataLoader
+
+    json_file = [
+        "opensoraplan/jsons/video_mixkit_513f_1997.json",
+    ]
+    video_folder = [
+        "opensoraplan/videos",
+    ]
+    stride = 1
+    batch_size = 2
+    num_train_epochs = 1
+    seed = 0
+    num_workers = 8
+    output_dir = "accelerate_checkpoints"
+    checkpoint_dirs = (
+        [
+            d
+            for d in os.listdir(output_dir)
+            if d.startswith("checkpoint-") and os.path.isdir(os.path.join(output_dir, d))
+        ]
+        if os.path.exists(output_dir)
+        else []
+    )
+
+    dataset_ratios = {}
+    # dataset_ratios = {
+    #     "/mnt/hdfs/data/ysh_new/userful_things_wan/open-sora-plan-istock/istock_v4/latents": 0.9,
+    #     "/mnt/hdfs/data/ysh_new/userful_things_wan/sekai/sekai-real-walking-hq-193/latents_stride1": 0.1
+    # }
+
+    accelerator = Accelerator()
+    print(accelerator.process_index, accelerator.num_processes)
+
+    dataset = BucketedFeatureDataset(
+        json_files=json_file,
+        video_folders=video_folder,
+        stride=stride,
+        force_rebuild=False,
+        resolution=640,
+        single_res=True,
+        single_height=384,
+        single_width=640,
+        single_length=True,
+        single_num_frame=81,
+        multi_res=True,
+    )
+    sampler = BucketedSampler(
+        dataset,
+        batch_size=batch_size,
+        drop_last=True,
+        shuffle=False,
+        dataset_sampling_ratios=dataset_ratios,
+        seed=seed,
+        # num_sp_groups=get_world_size() // get_sp_world_size(),
+        # sp_world_size=get_sp_world_size(),
+        # global_rank=get_world_rank(),
+        num_sp_groups=accelerator.num_processes // 1,
+        sp_world_size=1,
+        global_rank=accelerator.process_index,
+    )
+    dataloader = StatefulDataLoader(dataset, batch_sampler=sampler, collate_fn=collate_fn, num_workers=num_workers)
+
+    print(len(dataset), len(dataloader))
+    print(f"Dataset size: {len(dataset)}, Dataloader batches: {len(dataloader)}")
+
+    step = 0
+    global_step = 0
+    first_epoch = 0
+    num_update_steps_per_epoch = len(dataloader)
+    if checkpoint_dirs:
+        latest_checkpoint = max(checkpoint_dirs, key=lambda x: int(x.split("-")[1]))
+        checkpoint_path = os.path.join(output_dir, latest_checkpoint)
+        print(f"Found checkpoint: {checkpoint_path}")
+
+        accelerator.load_state(checkpoint_path)
+        global_step = int(latest_checkpoint.split("-")[1])
+        first_epoch = global_step // num_update_steps_per_epoch
+
+        states = {
+            "dataloader": dataloader,
+        }
+        dcp_dir = os.path.join(checkpoint_path, "distributed_checkpoint")
+        dcp.load(states, checkpoint_id=dcp_dir)
+
+        print(f"Resuming from step {global_step}, epoch {first_epoch}")
+
+    print("Testing dataloader...")
+    step = global_step
+    dataset_counts = defaultdict(int)
+    for epoch in range(first_epoch, num_train_epochs):
+        sampler.set_epoch(epoch)
+        dataset.set_epoch(epoch)
+        for i, batch in enumerate(dataloader):
+            # Get metadata
+            uttid = batch["uttid"]
+            bucket_key = batch["bucket_key"]
+            num_frame = batch["video_metadata"]["num_frames"]
+            height = batch["video_metadata"]["height"]
+            width = batch["video_metadata"]["width"]
+
+            # Get feature
+            video_data = batch["videos"]
+            prompt = batch["prompts"]
+            first_frames_images = batch["first_frames_images"]
+            first_frames_images = [torchvision.transforms.ToPILImage()(x.to(torch.uint8)) for x in first_frames_images]
+
+            # save_frames(video_data[0].squeeze(0), video_path="1.mp4")
+            # import pdb;pdb.set_trace()
+
+            if accelerator.process_index == 0:
+                # print info
+                print(f" Step {step}:")
+                print(f"  Batch {i}:")
+                # print(f"  Data Name: {batch['dataset_name']}")
+                print(f"  Batch size: {len(uttid)}")
+                print(f"  Uttids: {uttid}")
+                print(f"  Dimensions - frames: {num_frame[0]}, height: {height[0]}, width: {width[0]}")
+                print(f"  Bucket key: {bucket_key[0]}")
+                print(f"  Videos shape: {video_data.shape}")
+                print(f"  Cpation: {prompt}")
+
+                # verify
+                assert all(nf == num_frame[0] for nf in num_frame), "Frame numbers not consistent in batch"
+                assert all(h == height[0] for h in height), "Heights not consistent in batch"
+                assert all(w == width[0] for w in width), "Widths not consistent in batch"
+
+                print("  ✓ Batch dimensions are consistent")
+
+            for dataset_name in batch["dataset_name"]:
+                dataset_counts[dataset_name] += 1
+
+            step += 1
+
+            # if step == 20:
+            #     checkpoint_dir = f"checkpoint-{step}"
+            #     save_path = os.path.join(output_dir, checkpoint_dir)
+            #     os.makedirs(save_path, exist_ok=True)
+
+            #     if accelerator.is_main_process:
+            #         print(f"Saving checkpoint at step {step}")
+
+            #         accelerator.save_state(save_path)
+
+            #     print(accelerator.process_index, accelerator.num_processes)
+            #     states = {
+            #         "dataloader": dataloader,
+            #     }
+            #     dcp_dir = os.path.join(save_path, "distributed_checkpoint")
+            #     dcp.save(states, checkpoint_id=dcp_dir)
+
+    print("实际采样统计:", dict(dataset_counts))

Helios/_DEV2/helios/diffusers_version/pipeline_helios_diffusers.py

@@ -0,0 +1,1460 @@
+# Copyright 2025 The Helios Team and The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import html
+import math
+from itertools import accumulate
+from typing import Any, Callable
+
+import numpy as np
+import regex as re
+import torch
+import torch.nn.functional as F
+from transformers import AutoTokenizer, UMT5EncoderModel
+
+from diffusers.callbacks import MultiPipelineCallbacks, PipelineCallback
+from diffusers.image_processor import PipelineImageInput
+from diffusers.loaders import HeliosLoraLoaderMixin
+from diffusers.models import AutoencoderKLWan, HeliosTransformer3DModel
+from diffusers.pipelines.pipeline_utils import DiffusionPipeline
+from diffusers.schedulers import HeliosScheduler
+from diffusers.utils import is_ftfy_available, is_torch_xla_available, logging, replace_example_docstring
+from diffusers.utils.torch_utils import randn_tensor
+from diffusers.video_processor import VideoProcessor
+
+from ..pipelines.pipeline_output import HeliosPipelineOutput
+
+
+if is_torch_xla_available():
+    import torch_xla.core.xla_model as xm
+
+    XLA_AVAILABLE = True
+else:
+    XLA_AVAILABLE = False
+
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
+
+if is_ftfy_available():
+    import ftfy
+
+
+EXAMPLE_DOC_STRING = """
+    Examples:
+        ```python
+        >>> import torch
+        >>> from diffusers.utils import export_to_video
+        >>> from diffusers import AutoencoderKLWan, HeliosPipeline
+
+        >>> # Available models: BestWishYsh/Helios-Base, BestWishYsh/Helios-Mid, BestWishYsh/Helios-Distilled
+        >>> model_id = "BestWishYsh/Helios-Base"
+        >>> vae = AutoencoderKLWan.from_pretrained(model_id, subfolder="vae", torch_dtype=torch.float32)
+        >>> pipe = HeliosPipeline.from_pretrained(model_id, vae=vae, torch_dtype=torch.bfloat16)
+        >>> pipe.to("cuda")
+
+        >>> prompt = "A cat and a dog baking a cake together in a kitchen. The cat is carefully measuring flour, while the dog is stirring the batter with a wooden spoon. The kitchen is cozy, with sunlight streaming through the window."
+        >>> negative_prompt = "Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality, low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards"
+
+        >>> output = pipe(
+        ...     prompt=prompt,
+        ...     negative_prompt=negative_prompt,
+        ...     height=384,
+        ...     width=640,
+        ...     num_frames=132,
+        ...     guidance_scale=5.0,
+        ... ).frames[0]
+        >>> export_to_video(output, "output.mp4", fps=24)
+        ```
+"""
+
+
+def optimized_scale(positive_flat, negative_flat):
+    positive_flat = positive_flat.float()
+    negative_flat = negative_flat.float()
+    # Calculate dot production
+    dot_product = torch.sum(positive_flat * negative_flat, dim=1, keepdim=True)
+    # Squared norm of uncondition
+    squared_norm = torch.sum(negative_flat**2, dim=1, keepdim=True) + 1e-8
+    # st_star = v_cond^T * v_uncond / ||v_uncond||^2
+    st_star = dot_product / squared_norm
+    return st_star
+
+
+def basic_clean(text):
+    text = ftfy.fix_text(text)
+    text = html.unescape(html.unescape(text))
+    return text.strip()
+
+
+def whitespace_clean(text):
+    text = re.sub(r"\s+", " ", text)
+    text = text.strip()
+    return text
+
+
+def prompt_clean(text):
+    text = whitespace_clean(basic_clean(text))
+    return text
+
+
+# Copied from diffusers.pipelines.flux.pipeline_flux.calculate_shift
+def calculate_shift(
+    image_seq_len,
+    base_seq_len: int = 256,
+    max_seq_len: int = 4096,
+    base_shift: float = 0.5,
+    max_shift: float = 1.15,
+):
+    m = (max_shift - base_shift) / (max_seq_len - base_seq_len)
+    b = base_shift - m * base_seq_len
+    mu = image_seq_len * m + b
+    return mu
+
+
+class HeliosPipeline(DiffusionPipeline, HeliosLoraLoaderMixin):
+    r"""
+    Pipeline for text-to-video / image-to-video / video-to-video generation using Helios.
+
+    This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods
+    implemented for all pipelines (downloading, saving, running on a particular device, etc.).
+
+    Args:
+        tokenizer ([`T5Tokenizer`]):
+            Tokenizer from [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer),
+            specifically the [google/umt5-xxl](https://huggingface.co/google/umt5-xxl) variant.
+        text_encoder ([`T5EncoderModel`]):
+            [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), specifically
+            the [google/umt5-xxl](https://huggingface.co/google/umt5-xxl) variant.
+        transformer ([`HeliosTransformer3DModel`]):
+            Conditional Transformer to denoise the input latents.
+        scheduler ([`HeliosScheduler`]):
+            A scheduler to be used in combination with `transformer` to denoise the encoded image latents.
+        vae ([`AutoencoderKLWan`]):
+            Variational Auto-Encoder (VAE) Model to encode and decode videos to and from latent representations.
+    """
+
+    model_cpu_offload_seq = "text_encoder->transformer->vae"
+    _callback_tensor_inputs = ["latents", "prompt_embeds", "negative_prompt_embeds"]
+    _optional_components = ["transformer"]
+
+    def __init__(
+        self,
+        tokenizer: AutoTokenizer,
+        text_encoder: UMT5EncoderModel,
+        vae: AutoencoderKLWan,
+        scheduler: HeliosScheduler,
+        transformer: HeliosTransformer3DModel,
+        is_cfg_zero_star: bool = False,
+        is_distilled: bool = False,
+    ):
+        super().__init__()
+
+        self.register_modules(
+            vae=vae,
+            text_encoder=text_encoder,
+            tokenizer=tokenizer,
+            transformer=transformer,
+            scheduler=scheduler,
+        )
+        self.register_to_config(is_cfg_zero_star=is_cfg_zero_star)
+        self.register_to_config(is_distilled=is_distilled)
+        self.vae_scale_factor_temporal = self.vae.config.scale_factor_temporal if getattr(self, "vae", None) else 4
+        self.vae_scale_factor_spatial = self.vae.config.scale_factor_spatial if getattr(self, "vae", None) else 8
+        self.video_processor = VideoProcessor(vae_scale_factor=self.vae_scale_factor_spatial)
+
+    def _get_t5_prompt_embeds(
+        self,
+        prompt: str | list[str] = None,
+        num_videos_per_prompt: int = 1,
+        max_sequence_length: int = 226,
+        device: torch.device | None = None,
+        dtype: torch.dtype | None = None,
+    ):
+        device = device or self._execution_device
+        dtype = dtype or self.text_encoder.dtype
+
+        prompt = [prompt] if isinstance(prompt, str) else prompt
+        prompt = [prompt_clean(u) for u in prompt]
+        batch_size = len(prompt)
+
+        text_inputs = self.tokenizer(
+            prompt,
+            padding="max_length",
+            max_length=max_sequence_length,
+            truncation=True,
+            add_special_tokens=True,
+            return_attention_mask=True,
+            return_tensors="pt",
+        )
+        text_input_ids, mask = text_inputs.input_ids, text_inputs.attention_mask
+        seq_lens = mask.gt(0).sum(dim=1).long()
+
+        prompt_embeds = self.text_encoder(text_input_ids.to(device), mask.to(device)).last_hidden_state
+        prompt_embeds = prompt_embeds.to(dtype=dtype, device=device)
+        prompt_embeds = [u[:v] for u, v in zip(prompt_embeds, seq_lens)]
+        prompt_embeds = torch.stack(
+            [torch.cat([u, u.new_zeros(max_sequence_length - u.size(0), u.size(1))]) for u in prompt_embeds], dim=0
+        )
+
+        # duplicate text embeddings for each generation per prompt, using mps friendly method
+        _, seq_len, _ = prompt_embeds.shape
+        prompt_embeds = prompt_embeds.repeat(1, num_videos_per_prompt, 1)
+        prompt_embeds = prompt_embeds.view(batch_size * num_videos_per_prompt, seq_len, -1)
+
+        return prompt_embeds, text_inputs.attention_mask.bool()
+
+    def encode_prompt(
+        self,
+        prompt: str | list[str],
+        negative_prompt: str | list[str] | None = None,
+        do_classifier_free_guidance: bool = True,
+        num_videos_per_prompt: int = 1,
+        prompt_embeds: torch.Tensor | None = None,
+        negative_prompt_embeds: torch.Tensor | None = None,
+        max_sequence_length: int = 226,
+        device: torch.device | None = None,
+        dtype: torch.dtype | None = None,
+    ):
+        r"""
+        Encodes the prompt into text encoder hidden states.
+
+        Args:
+            prompt (`str` or `list[str]`, *optional*):
+                prompt to be encoded
+            negative_prompt (`str` or `list[str]`, *optional*):
+                The prompt or prompts not to guide the image generation. If not defined, one has to pass
+                `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is
+                less than `1`).
+            do_classifier_free_guidance (`bool`, *optional*, defaults to `True`):
+                Whether to use classifier free guidance or not.
+            num_videos_per_prompt (`int`, *optional*, defaults to 1):
+                Number of videos that should be generated per prompt. torch device to place the resulting embeddings on
+            prompt_embeds (`torch.Tensor`, *optional*):
+                Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not
+                provided, text embeddings will be generated from `prompt` input argument.
+            negative_prompt_embeds (`torch.Tensor`, *optional*):
+                Pre-generated negative text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt
+                weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input
+                argument.
+            device: (`torch.device`, *optional*):
+                torch device
+            dtype: (`torch.dtype`, *optional*):
+                torch dtype
+        """
+        device = device or self._execution_device
+
+        prompt = [prompt] if isinstance(prompt, str) else prompt
+        if prompt is not None:
+            batch_size = len(prompt)
+        else:
+            batch_size = prompt_embeds.shape[0]
+
+        if prompt_embeds is None:
+            prompt_embeds, _ = self._get_t5_prompt_embeds(
+                prompt=prompt,
+                num_videos_per_prompt=num_videos_per_prompt,
+                max_sequence_length=max_sequence_length,
+                device=device,
+                dtype=dtype,
+            )
+
+        if do_classifier_free_guidance and negative_prompt_embeds is None:
+            negative_prompt = negative_prompt or ""
+            negative_prompt = batch_size * [negative_prompt] if isinstance(negative_prompt, str) else negative_prompt
+
+            if prompt is not None and type(prompt) is not type(negative_prompt):
+                raise TypeError(
+                    f"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !="
+                    f" {type(prompt)}."
+                )
+            elif batch_size != len(negative_prompt):
+                raise ValueError(
+                    f"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:"
+                    f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"
+                    " the batch size of `prompt`."
+                )
+
+            negative_prompt_embeds, _ = self._get_t5_prompt_embeds(
+                prompt=negative_prompt,
+                num_videos_per_prompt=num_videos_per_prompt,
+                max_sequence_length=max_sequence_length,
+                device=device,
+                dtype=dtype,
+            )
+
+        return prompt_embeds, negative_prompt_embeds
+
+    def check_inputs(
+        self,
+        prompt,
+        negative_prompt,
+        height,
+        width,
+        prompt_embeds=None,
+        negative_prompt_embeds=None,
+        callback_on_step_end_tensor_inputs=None,
+        image=None,
+        video=None,
+        use_interpolate_prompt=False,
+        num_videos_per_prompt=None,
+        interpolate_time_list=None,
+        interpolation_steps=None,
+        guidance_scale=None,
+    ):
+        if height % 16 != 0 or width % 16 != 0:
+            raise ValueError(f"`height` and `width` have to be divisible by 16 but are {height} and {width}.")
+
+        if callback_on_step_end_tensor_inputs is not None and not all(
+            k in self._callback_tensor_inputs for k in callback_on_step_end_tensor_inputs
+        ):
+            raise ValueError(
+                f"`callback_on_step_end_tensor_inputs` has to be in {self._callback_tensor_inputs}, but found {[k for k in callback_on_step_end_tensor_inputs if k not in self._callback_tensor_inputs]}"
+            )
+
+        if prompt is not None and prompt_embeds is not None:
+            raise ValueError(
+                f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to"
+                " only forward one of the two."
+            )
+        elif negative_prompt is not None and negative_prompt_embeds is not None:
+            raise ValueError(
+                f"Cannot forward both `negative_prompt`: {negative_prompt} and `negative_prompt_embeds`: {negative_prompt_embeds}. Please make sure to"
+                " only forward one of the two."
+            )
+        elif prompt is None and prompt_embeds is None:
+            raise ValueError(
+                "Provide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined."
+            )
+        elif prompt is not None and (not isinstance(prompt, str) and not isinstance(prompt, list)):
+            raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
+        elif negative_prompt is not None and (
+            not isinstance(negative_prompt, str) and not isinstance(negative_prompt, list)
+        ):
+            raise ValueError(f"`negative_prompt` has to be of type `str` or `list` but is {type(negative_prompt)}")
+
+        if image is not None and video is not None:
+            raise ValueError("image and video cannot be provided simultaneously")
+
+        if use_interpolate_prompt:
+            assert num_videos_per_prompt == 1, f"num_videos_per_prompt must be 1, got {num_videos_per_prompt}"
+            assert isinstance(prompt, list), "prompt must be a list"
+            assert len(prompt) == len(interpolate_time_list), (
+                f"Length mismatch: {len(prompt)} vs {len(interpolate_time_list)}"
+            )
+            assert min(interpolate_time_list) > interpolation_steps, (
+                f"Minimum value {min(interpolate_time_list)} must be greater than {interpolation_steps}"
+            )
+
+        if guidance_scale > 1.0 and self.config.is_distilled:
+            logger.warning(f"Guidance scale {guidance_scale} is ignored for step-wise distilled models.")
+
+    def prepare_latents(
+        self,
+        batch_size: int,
+        num_channels_latents: int = 16,
+        height: int = 384,
+        width: int = 640,
+        num_frames: int = 33,
+        dtype: torch.dtype | None = None,
+        device: torch.device | None = None,
+        generator: torch.Generator | list[torch.Generator] | None = None,
+        latents: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        if latents is not None:
+            return latents.to(device=device, dtype=dtype)
+
+        num_latent_frames = (num_frames - 1) // self.vae_scale_factor_temporal + 1
+        shape = (
+            batch_size,
+            num_channels_latents,
+            num_latent_frames,
+            int(height) // self.vae_scale_factor_spatial,
+            int(width) // self.vae_scale_factor_spatial,
+        )
+        if isinstance(generator, list) and len(generator) != batch_size:
+            raise ValueError(
+                f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
+                f" size of {batch_size}. Make sure the batch size matches the length of the generators."
+            )
+
+        latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
+        return latents
+
+    def prepare_image_latents(
+        self,
+        image: torch.Tensor,
+        latents_mean: torch.Tensor,
+        latents_std: torch.Tensor,
+        num_latent_frames_per_chunk: int,
+        dtype: torch.dtype | None = None,
+        device: torch.device | None = None,
+        generator: torch.Generator | list[torch.Generator] | None = None,
+        latents: torch.Tensor | None = None,
+        fake_latents: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        device = device or self._execution_device
+        if latents is None:
+            image = image.unsqueeze(2).to(device=device, dtype=self.vae.dtype)
+            latents = self.vae.encode(image).latent_dist.sample(generator=generator)
+            latents = (latents - latents_mean) * latents_std
+        if fake_latents is None:
+            min_frames = (num_latent_frames_per_chunk - 1) * self.vae_scale_factor_temporal + 1
+            fake_video = image.repeat(1, 1, min_frames, 1, 1).to(device=device, dtype=self.vae.dtype)
+            fake_latents_full = self.vae.encode(fake_video).latent_dist.sample(generator=generator)
+            fake_latents_full = (fake_latents_full - latents_mean) * latents_std
+            fake_latents = fake_latents_full[:, :, -1:, :, :]
+        return latents.to(device=device, dtype=dtype), fake_latents.to(device=device, dtype=dtype)
+
+    def prepare_video_latents(
+        self,
+        video: torch.Tensor,
+        latents_mean: torch.Tensor,
+        latents_std: torch.Tensor,
+        num_latent_frames_per_chunk: int,
+        dtype: torch.dtype | None = None,
+        device: torch.device | None = None,
+        generator: torch.Generator | list[torch.Generator] | None = None,
+        latents: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        device = device or self._execution_device
+        video = video.to(device=device, dtype=self.vae.dtype)
+        if latents is None:
+            num_frames = video.shape[2]
+            min_frames = (num_latent_frames_per_chunk - 1) * self.vae_scale_factor_temporal + 1
+            num_chunks = num_frames // min_frames
+            if num_chunks == 0:
+                raise ValueError(
+                    f"Video must have at least {min_frames} frames "
+                    f"(got {num_frames} frames). "
+                    f"Required: (num_latent_frames_per_chunk - 1) * {self.vae_scale_factor_temporal} + 1 = ({num_latent_frames_per_chunk} - 1) * {self.vae_scale_factor_temporal} + 1 = {min_frames}"
+                )
+            total_valid_frames = num_chunks * min_frames
+            start_frame = num_frames - total_valid_frames
+
+            first_frame = video[:, :, 0:1, :, :]
+            first_frame_latent = self.vae.encode(first_frame).latent_dist.sample(generator=generator)
+            first_frame_latent = (first_frame_latent - latents_mean) * latents_std
+
+            latents_chunks = []
+            for i in range(num_chunks):
+                chunk_start = start_frame + i * min_frames
+                chunk_end = chunk_start + min_frames
+                video_chunk = video[:, :, chunk_start:chunk_end, :, :]
+                chunk_latents = self.vae.encode(video_chunk).latent_dist.sample(generator=generator)
+                chunk_latents = (chunk_latents - latents_mean) * latents_std
+                latents_chunks.append(chunk_latents)
+            latents = torch.cat(latents_chunks, dim=2)
+        return first_frame_latent.to(device=device, dtype=dtype), latents.to(device=device, dtype=dtype)
+
+    def interpolate_prompt_embeds(
+        self,
+        prompt_embeds_1: torch.Tensor,
+        prompt_embeds_2: torch.Tensor,
+        interpolation_steps: int = 3,
+    ):
+        x = torch.lerp(
+            prompt_embeds_1,
+            prompt_embeds_2,
+            torch.linspace(0, 1, steps=interpolation_steps).unsqueeze(1).unsqueeze(2).to(prompt_embeds_1),
+        )
+        interpolated_prompt_embeds = list(x.chunk(interpolation_steps, dim=0))
+        return interpolated_prompt_embeds
+
+    def sample_block_noise(
+        self,
+        batch_size,
+        channel,
+        num_frames,
+        height,
+        width,
+        patch_size: tuple[int, ...] = (1, 2, 2),
+        device: torch.device | None = None,
+        generator: torch.Generator | None = None,
+    ):
+        # NOTE: A generator must be provided to ensure correct and reproducible results.
+        # Creating a default generator here is a fallback only — without a fixed seed,
+        # the output will be non-deterministic and may produce incorrect results in CP context.
+        if generator is None:
+            generator = torch.Generator(device=device)
+        elif isinstance(generator, list):
+            generator = generator[0]
+
+        gamma = self.scheduler.config.gamma
+        _, ph, pw = patch_size
+        block_size = ph * pw
+
+        cov = (
+            torch.eye(block_size, device=device) * (1 + gamma)
+            - torch.ones(block_size, block_size, device=device) * gamma
+        )
+        cov += torch.eye(block_size, device=device) * 1e-8
+        cov = cov.float()  # Upcast to fp32 for numerical stability — cholesky is unreliable in fp16/bf16.
+
+        L = torch.linalg.cholesky(cov)
+        block_number = batch_size * channel * num_frames * (height // ph) * (width // pw)
+        z = torch.randn(block_number, block_size, generator=generator, device=generator.device).to(device=device)
+        noise = z @ L.T
+
+        noise = noise.view(batch_size, channel, num_frames, height // ph, width // pw, ph, pw)
+        noise = noise.permute(0, 1, 2, 3, 5, 4, 6).reshape(batch_size, channel, num_frames, height, width)
+
+        return noise
+
+    def record_relative_l1(
+        self,
+        records: list[dict[str, float | int]] | None,
+        chunk_index: int,
+        stage_index: int | None,
+        step_index: int,
+        timestep: torch.Tensor,
+        latents_t: torch.Tensor,
+        latents_t_minus_1: torch.Tensor,
+    ):
+        if records is None:
+            return
+
+        latents_t = latents_t.detach().float()
+        latents_t_minus_1 = latents_t_minus_1.detach().float()
+        delta_abs = (latents_t_minus_1 - latents_t).abs()
+        latents_abs = latents_t.abs()
+        relative_l1 = (delta_abs / latents_abs.clamp_min(1e-8)).mean()
+        relative_l1_ratio = delta_abs.mean() / latents_abs.mean().clamp_min(1e-8)
+        timestep_value = timestep.detach().float().mean().item() if torch.is_tensor(timestep) else float(timestep)
+
+        records.append(
+            {
+                "chunk_index": int(chunk_index),
+                "stage_index": -1 if stage_index is None else int(stage_index),
+                "step_index": int(step_index),
+                "timestep": float(timestep_value),
+                "relative_l1": float(relative_l1.item()),
+                "relative_l1_ratio": float(relative_l1_ratio.item()),
+            }
+        )
+
+    def stage1_sample(
+        self,
+        latents: torch.Tensor = None,
+        prompt_embeds: torch.Tensor = None,
+        negative_prompt_embeds: torch.Tensor = None,
+        timesteps: torch.Tensor = None,
+        guidance_scale: float | None = 5.0,
+        indices_hidden_states: torch.Tensor = None,
+        indices_latents_history_short: torch.Tensor = None,
+        indices_latents_history_mid: torch.Tensor = None,
+        indices_latents_history_long: torch.Tensor = None,
+        latents_history_short: torch.Tensor = None,
+        latents_history_mid: torch.Tensor = None,
+        latents_history_long: torch.Tensor = None,
+        attention_kwargs: dict | None = None,
+        device: torch.device | None = None,
+        transformer_dtype: torch.dtype = None,
+        generator: torch.Generator | None = None,
+        num_warmup_steps: int | None = None,
+        # ------------ CFG Zero ------------
+        use_zero_init: bool | None = True,
+        zero_steps: int | None = 1,
+        # ------------ Callback ------------
+        callback_on_step_end: Callable[[int, int], None] | PipelineCallback | MultiPipelineCallbacks | None = None,
+        callback_on_step_end_tensor_inputs: list[str] = ["latents"],
+        progress_bar=None,
+        chunk_index: int = 0,
+        relative_l1_records: list[dict[str, float | int]] | None = None,
+    ):
+        batch_size = latents.shape[0]
+
+        for i, t in enumerate(timesteps):
+            if self.interrupt:
+                continue
+
+            self._current_timestep = t
+            timestep = t.expand(latents.shape[0])
+
+            latent_model_input = latents.to(transformer_dtype)
+            self.transformer.set_short_attn_debug_context(
+                chunk_index=chunk_index,
+                stage="stage1",
+                stage_index=None,
+                step_index=i,
+                total_steps=len(timesteps),
+                pass_name="cond",
+                timestep=float(t.detach().cpu().item()) if torch.is_tensor(t) else float(t),
+            )
+            with self.transformer.cache_context("cond"):
+                noise_pred = self.transformer(
+                    hidden_states=latent_model_input,
+                    timestep=timestep,
+                    encoder_hidden_states=prompt_embeds,
+                    indices_hidden_states=indices_hidden_states,
+                    indices_latents_history_short=indices_latents_history_short,
+                    indices_latents_history_mid=indices_latents_history_mid,
+                    indices_latents_history_long=indices_latents_history_long,
+                    latents_history_short=latents_history_short.to(transformer_dtype),
+                    latents_history_mid=latents_history_mid.to(transformer_dtype),
+                    latents_history_long=latents_history_long.to(transformer_dtype),
+                    attention_kwargs=attention_kwargs,
+                    return_dict=False,
+                )[0]
+
+            if self.do_classifier_free_guidance:
+                self.transformer.set_short_attn_debug_context(
+                    chunk_index=chunk_index,
+                    stage="stage1",
+                    stage_index=None,
+                    step_index=i,
+                    total_steps=len(timesteps),
+                    pass_name="uncond",
+                    timestep=float(t.detach().cpu().item()) if torch.is_tensor(t) else float(t),
+                )
+                with self.transformer.cache_context("uncond"):
+                    noise_uncond = self.transformer(
+                        hidden_states=latent_model_input,
+                        timestep=timestep,
+                        encoder_hidden_states=negative_prompt_embeds,
+                        indices_hidden_states=indices_hidden_states,
+                        indices_latents_history_short=indices_latents_history_short,
+                        indices_latents_history_mid=indices_latents_history_mid,
+                        indices_latents_history_long=indices_latents_history_long,
+                        latents_history_short=latents_history_short.to(transformer_dtype),
+                        latents_history_mid=latents_history_mid.to(transformer_dtype),
+                        latents_history_long=latents_history_long.to(transformer_dtype),
+                        attention_kwargs=attention_kwargs,
+                        return_dict=False,
+                    )[0]
+
+                if self.config.is_cfg_zero_star:
+                    noise_pred_text = noise_pred
+                    positive_flat = noise_pred_text.view(batch_size, -1)
+                    negative_flat = noise_uncond.view(batch_size, -1)
+
+                    alpha = optimized_scale(positive_flat, negative_flat)
+                    alpha = alpha.view(batch_size, *([1] * (len(noise_pred_text.shape) - 1)))
+                    alpha = alpha.to(noise_pred_text.dtype)
+
+                    if (i <= zero_steps) and use_zero_init:
+                        noise_pred = noise_pred_text * 0.0
+                    else:
+                        noise_pred = noise_uncond * alpha + guidance_scale * (noise_pred_text - noise_uncond * alpha)
+                else:
+                    noise_pred = noise_uncond + guidance_scale * (noise_pred - noise_uncond)
+
+            latents_t = latents
+            latents = self.scheduler.step(
+                noise_pred,
+                t,
+                latents,
+                return_dict=False,
+            )[0]
+            self.record_relative_l1(relative_l1_records, chunk_index, None, i, t, latents_t, latents)
+
+            if callback_on_step_end is not None:
+                callback_kwargs = {}
+                for k in callback_on_step_end_tensor_inputs:
+                    callback_kwargs[k] = locals()[k]
+                callback_outputs = callback_on_step_end(self, i, t, callback_kwargs)
+
+                latents = callback_outputs.pop("latents", latents)
+                prompt_embeds = callback_outputs.pop("prompt_embeds", prompt_embeds)
+                negative_prompt_embeds = callback_outputs.pop("negative_prompt_embeds", negative_prompt_embeds)
+
+            if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):
+                progress_bar.update()
+
+            if XLA_AVAILABLE:
+                xm.mark_step()
+
+        return latents
+
+    def stage2_sample(
+        self,
+        latents: torch.Tensor = None,
+        pyramid_num_stages: int = None,
+        pyramid_num_inference_steps_list: list[int] = None,
+        prompt_embeds: torch.Tensor = None,
+        negative_prompt_embeds: torch.Tensor = None,
+        guidance_scale: float | None = 5.0,
+        indices_hidden_states: torch.Tensor = None,
+        indices_latents_history_short: torch.Tensor = None,
+        indices_latents_history_mid: torch.Tensor = None,
+        indices_latents_history_long: torch.Tensor = None,
+        latents_history_short: torch.Tensor = None,
+        latents_history_mid: torch.Tensor = None,
+        latents_history_long: torch.Tensor = None,
+        attention_kwargs: dict | None = None,
+        device: torch.device | None = None,
+        transformer_dtype: torch.dtype = None,
+        generator: torch.Generator | None = None,
+        # ------------ CFG Zero ------------
+        use_zero_init: bool | None = True,
+        zero_steps: int | None = 1,
+        # -------------- DMD --------------
+        is_amplify_first_chunk: bool = False,
+        # ------------ Callback ------------
+        callback_on_step_end: Callable[[int, int], None] | PipelineCallback | MultiPipelineCallbacks | None = None,
+        callback_on_step_end_tensor_inputs: list[str] = ["latents"],
+        progress_bar=None,
+        chunk_index: int = 0,
+        relative_l1_records: list[dict[str, float | int]] | None = None,
+    ):
+        batch_size, num_channel, num_frames, height, width = latents.shape
+        latents = latents.permute(0, 2, 1, 3, 4).reshape(batch_size * num_frames, num_channel, height, width)
+        for _ in range(pyramid_num_stages - 1):
+            height //= 2
+            width //= 2
+            latents = (
+                F.interpolate(
+                    latents,
+                    size=(height, width),
+                    mode="bilinear",
+                )
+                * 2
+            )
+        latents = latents.reshape(batch_size, num_frames, num_channel, height, width).permute(0, 2, 1, 3, 4)
+
+        batch_size = latents.shape[0]
+        start_point_list = None
+        if self.config.is_distilled:
+            start_point_list = [latents]
+
+        i = 0
+        total_stage2_steps = sum(pyramid_num_inference_steps_list)
+        for i_s in range(pyramid_num_stages):
+            patch_size = self.transformer.config.patch_size
+            image_seq_len = (latents.shape[-1] * latents.shape[-2] * latents.shape[-3]) // (
+                patch_size[0] * patch_size[1] * patch_size[2]
+            )
+            mu = calculate_shift(
+                image_seq_len,
+                self.scheduler.config.get("base_image_seq_len", 256),
+                self.scheduler.config.get("max_image_seq_len", 4096),
+                self.scheduler.config.get("base_shift", 0.5),
+                self.scheduler.config.get("max_shift", 1.15),
+            )
+            self.scheduler.set_timesteps(
+                pyramid_num_inference_steps_list[i_s],
+                i_s,
+                device=device,
+                mu=mu,
+                is_amplify_first_chunk=is_amplify_first_chunk,
+            )
+            timesteps = self.scheduler.timesteps
+
+            if i_s > 0:
+                height *= 2
+                width *= 2
+                num_frames = latents.shape[2]
+                latents = latents.permute(0, 2, 1, 3, 4).reshape(
+                    batch_size * num_frames, num_channel, height // 2, width // 2
+                )
+                latents = F.interpolate(latents, size=(height, width), mode="nearest")
+                latents = latents.reshape(batch_size, num_frames, num_channel, height, width).permute(0, 2, 1, 3, 4)
+                # Fix the stage
+                ori_sigma = 1 - self.scheduler.ori_start_sigmas[i_s]  # the original coeff of signal
+                gamma = self.scheduler.config.gamma
+                alpha = 1 / (math.sqrt(1 + (1 / gamma)) * (1 - ori_sigma) + ori_sigma)
+                beta = alpha * (1 - ori_sigma) / math.sqrt(gamma)
+
+                batch_size, channel, num_frames, height, width = latents.shape
+                noise = self.sample_block_noise(
+                    batch_size, channel, num_frames, height, width, patch_size, device, generator
+                )
+                noise = noise.to(device=device, dtype=transformer_dtype)
+                latents = alpha * latents + beta * noise  # To fix the block artifact
+
+                if self.config.is_distilled:
+                    start_point_list.append(latents)
+
+            for idx, t in enumerate(timesteps):
+                timestep = t.expand(latents.shape[0]).to(torch.int64)
+
+                self.transformer.set_short_attn_debug_context(
+                    chunk_index=chunk_index,
+                    stage="stage2",
+                    stage_index=i_s,
+                    step_index=i,
+                    total_steps=total_stage2_steps,
+                    pass_name="cond",
+                    timestep=float(t.detach().cpu().item()) if torch.is_tensor(t) else float(t),
+                )
+                with self.transformer.cache_context("cond"):
+                    noise_pred = self.transformer(
+                        hidden_states=latents.to(transformer_dtype),
+                        timestep=timestep,
+                        encoder_hidden_states=prompt_embeds,
+                        attention_kwargs=attention_kwargs,
+                        return_dict=False,
+                        indices_hidden_states=indices_hidden_states,
+                        indices_latents_history_short=indices_latents_history_short,
+                        indices_latents_history_mid=indices_latents_history_mid,
+                        indices_latents_history_long=indices_latents_history_long,
+                        latents_history_short=latents_history_short.to(transformer_dtype),
+                        latents_history_mid=latents_history_mid.to(transformer_dtype),
+                        latents_history_long=latents_history_long.to(transformer_dtype),
+                    )[0]
+
+                if self.do_classifier_free_guidance:
+                    self.transformer.set_short_attn_debug_context(
+                        chunk_index=chunk_index,
+                        stage="stage2",
+                        stage_index=i_s,
+                        step_index=i,
+                        total_steps=total_stage2_steps,
+                        pass_name="uncond",
+                        timestep=float(t.detach().cpu().item()) if torch.is_tensor(t) else float(t),
+                    )
+                    with self.transformer.cache_context("uncond"):
+                        noise_uncond = self.transformer(
+                            hidden_states=latents.to(transformer_dtype),
+                            timestep=timestep,
+                            encoder_hidden_states=negative_prompt_embeds,
+                            attention_kwargs=attention_kwargs,
+                            return_dict=False,
+                            indices_hidden_states=indices_hidden_states,
+                            indices_latents_history_short=indices_latents_history_short,
+                            indices_latents_history_mid=indices_latents_history_mid,
+                            indices_latents_history_long=indices_latents_history_long,
+                            latents_history_short=latents_history_short.to(transformer_dtype),
+                            latents_history_mid=latents_history_mid.to(transformer_dtype),
+                            latents_history_long=latents_history_long.to(transformer_dtype),
+                        )[0]
+
+                    if self.config.is_cfg_zero_star:
+                        noise_pred_text = noise_pred
+                        positive_flat = noise_pred_text.view(batch_size, -1)
+                        negative_flat = noise_uncond.view(batch_size, -1)
+
+                        alpha = optimized_scale(positive_flat, negative_flat)
+                        alpha = alpha.view(batch_size, *([1] * (len(noise_pred_text.shape) - 1)))
+                        alpha = alpha.to(noise_pred_text.dtype)
+
+                        if (i_s == 0 and idx <= zero_steps) and use_zero_init:
+                            noise_pred = noise_pred_text * 0.0
+                        else:
+                            noise_pred = noise_uncond * alpha + guidance_scale * (
+                                noise_pred_text - noise_uncond * alpha
+                            )
+                    else:
+                        noise_pred = noise_uncond + guidance_scale * (noise_pred - noise_uncond)
+
+                latents_t = latents
+                latents = self.scheduler.step(
+                    noise_pred,
+                    t,
+                    latents,
+                    generator=generator,
+                    return_dict=False,
+                    cur_sampling_step=idx,
+                    dmd_noisy_tensor=start_point_list[i_s] if start_point_list is not None else None,
+                    dmd_sigmas=self.scheduler.sigmas,
+                    dmd_timesteps=self.scheduler.timesteps,
+                    all_timesteps=timesteps,
+                )[0]
+                self.record_relative_l1(relative_l1_records, chunk_index, i_s, i, t, latents_t, latents)
+
+                if callback_on_step_end is not None:
+                    callback_kwargs = {}
+                    for k in callback_on_step_end_tensor_inputs:
+                        callback_kwargs[k] = locals()[k]
+                    callback_outputs = callback_on_step_end(self, i, t, callback_kwargs)
+
+                    latents = callback_outputs.pop("latents", latents)
+                    prompt_embeds = callback_outputs.pop("prompt_embeds", prompt_embeds)
+                    negative_prompt_embeds = callback_outputs.pop("negative_prompt_embeds", negative_prompt_embeds)
+
+                progress_bar.update()
+
+                if XLA_AVAILABLE:
+                    xm.mark_step()
+
+                i += 1
+
+        return latents
+
+    @property
+    def guidance_scale(self):
+        return self._guidance_scale
+
+    @property
+    def do_classifier_free_guidance(self):
+        return self._guidance_scale > 1.0
+
+    @property
+    def num_timesteps(self):
+        return self._num_timesteps
+
+    @property
+    def current_timestep(self):
+        return self._current_timestep
+
+    @property
+    def interrupt(self):
+        return self._interrupt
+
+    @property
+    def attention_kwargs(self):
+        return self._attention_kwargs
+
+    @torch.no_grad()
+    @replace_example_docstring(EXAMPLE_DOC_STRING)
+    def __call__(
+        self,
+        prompt: str | list[str] = None,
+        negative_prompt: str | list[str] = None,
+        height: int = 384,
+        width: int = 640,
+        num_frames: int = 132,
+        num_inference_steps: int = 50,
+        sigmas: list[float] = None,
+        guidance_scale: float = 5.0,
+        num_videos_per_prompt: int | None = 1,
+        generator: torch.Generator | list[torch.Generator] | None = None,
+        latents: torch.Tensor | None = None,
+        prompt_embeds: torch.Tensor | None = None,
+        negative_prompt_embeds: torch.Tensor | None = None,
+        output_type: str | None = "np",
+        return_dict: bool = True,
+        attention_kwargs: dict[str, Any] | None = None,
+        callback_on_step_end: Callable[[int, int], None] | PipelineCallback | MultiPipelineCallbacks | None = None,
+        callback_on_step_end_tensor_inputs: list[str] = ["latents"],
+        max_sequence_length: int = 512,
+        # ------------ I2V ------------
+        image: PipelineImageInput | None = None,
+        image_latents: torch.Tensor | None = None,
+        fake_image_latents: torch.Tensor | None = None,
+        add_noise_to_image_latents: bool = True,
+        image_noise_sigma_min: float = 0.111,
+        image_noise_sigma_max: float = 0.135,
+        # ------------ V2V ------------
+        video: PipelineImageInput | None = None,
+        video_latents: torch.Tensor | None = None,
+        add_noise_to_video_latents: bool = True,
+        video_noise_sigma_min: float = 0.111,
+        video_noise_sigma_max: float = 0.135,
+        # ------------ Interactive ------------
+        use_interpolate_prompt: bool = False,
+        interpolate_time_list: list = [7, 7, 7],
+        interpolation_steps: int = 3,
+        # ------------ Stage 1 ------------
+        history_sizes: list = [16, 2, 1],
+        num_latent_frames_per_chunk: int = 9,
+        keep_first_frame: bool = True,
+        is_skip_first_chunk: bool = False,
+        # ------------ Stage 2 ------------
+        is_enable_stage2: bool = False,
+        pyramid_num_stages: int = 3,
+        pyramid_num_inference_steps_list: list = [10, 10, 10],
+        # ------------ CFG Zero ------------
+        use_zero_init: bool | None = True,
+        zero_steps: int | None = 1,
+        # ------------ DMD ------------
+        is_amplify_first_chunk: bool = False,
+        # ------------ Debug ------------
+        output_relative_l1: bool = False,
+        short_attn_debug: dict[str, Any] | None = None,
+    ):
+        r"""
+        The call function to the pipeline for generation.
+
+        Args:
+            prompt (`str` or `list[str]`, *optional*):
+                The prompt or prompts to guide the image generation. If not defined, pass `prompt_embeds` instead.
+            negative_prompt (`str` or `list[str]`, *optional*):
+                The prompt or prompts to avoid during image generation. If not defined, pass `negative_prompt_embeds`
+                instead. Ignored when not using guidance (`guidance_scale` < `1`).
+            height (`int`, defaults to `384`):
+                The height in pixels of the generated image.
+            width (`int`, defaults to `640`):
+                The width in pixels of the generated image.
+            num_frames (`int`, defaults to `132`):
+                The number of frames in the generated video.
+            num_inference_steps (`int`, defaults to `50`):
+                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
+                expense of slower inference.
+            guidance_scale (`float`, defaults to `5.0`):
+                Guidance scale as defined in [Classifier-Free Diffusion
+                Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` is defined as `w` of equation 2.
+                of [Imagen Paper](https://huggingface.co/papers/2205.11487). Guidance scale is enabled by setting
+                `guidance_scale > 1`. Higher guidance scale encourages to generate images that are closely linked to
+                the text `prompt`, usually at the expense of lower image quality.
+            num_videos_per_prompt (`int`, *optional*, defaults to 1):
+                The number of images to generate per prompt.
+            generator (`torch.Generator` or `list[torch.Generator]`, *optional*):
+                A [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) to make
+                generation deterministic.
+            latents (`torch.Tensor`, *optional*):
+                Pre-generated noisy latents sampled from a Gaussian distribution, to be used as inputs for image
+                generation. Can be used to tweak the same generation with different prompts. If not provided, a latents
+                tensor is generated by sampling using the supplied random `generator`.
+            prompt_embeds (`torch.Tensor`, *optional*):
+                Pre-generated text embeddings. Can be used to easily tweak text inputs (prompt weighting). If not
+                provided, text embeddings are generated from the `prompt` input argument.
+            output_type (`str`, *optional*, defaults to `"np"`):
+                The output format of the generated image. Choose between `PIL.Image` or `np.array`.
+            return_dict (`bool`, *optional*, defaults to `True`):
+                Whether or not to return a [`HeliosPipelineOutput`] instead of a plain tuple.
+            attention_kwargs (`dict`, *optional*):
+                A kwargs dictionary that if specified is passed along to the `AttentionProcessor` as defined under
+                `self.processor` in
+                [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
+            callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *optional*):
+                A function or a subclass of `PipelineCallback` or `MultiPipelineCallbacks` that is called at the end of
+                each denoising step during the inference. with the following arguments: `callback_on_step_end(self:
+                DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` will include a
+                list of all tensors as specified by `callback_on_step_end_tensor_inputs`.
+            callback_on_step_end_tensor_inputs (`list`, *optional*):
+                The list of tensor inputs for the `callback_on_step_end` function. The tensors specified in the list
+                will be passed as `callback_kwargs` argument. You will only be able to include variables listed in the
+                `._callback_tensor_inputs` attribute of your pipeline class.
+            max_sequence_length (`int`, defaults to `512`):
+                The maximum sequence length of the text encoder. If the prompt is longer than this, it will be
+                truncated. If the prompt is shorter, it will be padded to this length.
+
+        Examples:
+
+        Returns:
+            [`~HeliosPipelineOutput`] or `tuple`:
+                If `return_dict` is `True`, [`HeliosPipelineOutput`] is returned, otherwise a `tuple` is returned where
+                the first element is a list with the generated images and the second element is a list of `bool`s
+                indicating whether the corresponding generated image contains "not-safe-for-work" (nsfw) content.
+        """
+
+        if image is not None and video is not None:
+            raise ValueError("image and video cannot be provided simultaneously")
+
+        history_sizes = sorted(history_sizes, reverse=True)  # From big to small
+
+        if isinstance(callback_on_step_end, (PipelineCallback, MultiPipelineCallbacks)):
+            callback_on_step_end_tensor_inputs = callback_on_step_end.tensor_inputs
+
+        # 1. Check inputs. Raise error if not correct
+        self.check_inputs(
+            prompt,
+            negative_prompt,
+            height,
+            width,
+            prompt_embeds,
+            negative_prompt_embeds,
+            callback_on_step_end_tensor_inputs,
+            image,
+            video,
+            use_interpolate_prompt,
+            num_videos_per_prompt,
+            interpolate_time_list,
+            interpolation_steps,
+            guidance_scale,
+        )
+
+        num_frames = max(num_frames, 1)
+
+        self._guidance_scale = guidance_scale
+        self._attention_kwargs = attention_kwargs
+        self._current_timestep = None
+        self._interrupt = False
+        relative_l1_records = [] if output_relative_l1 else None
+
+        device = self._execution_device
+        vae_dtype = self.vae.dtype
+
+        if short_attn_debug:
+            short_attn_debug = dict(short_attn_debug)
+            patch_size = self.transformer.config.patch_size
+            short_attn_debug.setdefault(
+                "grid",
+                (
+                    height // self.vae_scale_factor_spatial // patch_size[1],
+                    width // self.vae_scale_factor_spatial // patch_size[2],
+                ),
+            )
+            self.transformer.configure_short_attn_debug(short_attn_debug)
+        else:
+            self.transformer.configure_short_attn_debug(None)
+
+        latents_mean = (
+            torch.tensor(self.vae.config.latents_mean)
+            .view(1, self.vae.config.z_dim, 1, 1, 1)
+            .to(device, self.vae.dtype)
+        )
+        latents_std = 1.0 / torch.tensor(self.vae.config.latents_std).view(1, self.vae.config.z_dim, 1, 1, 1).to(
+            device, self.vae.dtype
+        )
+
+        # 2. Define call parameters
+        if use_interpolate_prompt or (prompt is not None and isinstance(prompt, str)):
+            batch_size = 1
+        elif prompt is not None and isinstance(prompt, list):
+            batch_size = len(prompt)
+        else:
+            batch_size = prompt_embeds.shape[0]
+
+        # 3. Encode input prompt
+        if use_interpolate_prompt:
+            interpolate_interval_idx = None
+            interpolate_embeds = None
+            interpolate_cumulative_list = list(accumulate(interpolate_time_list))
+
+        all_prompt_embeds, negative_prompt_embeds = self.encode_prompt(
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            do_classifier_free_guidance=self.do_classifier_free_guidance,
+            num_videos_per_prompt=num_videos_per_prompt,
+            prompt_embeds=prompt_embeds,
+            negative_prompt_embeds=negative_prompt_embeds,
+            max_sequence_length=max_sequence_length,
+            device=device,
+        )
+
+        transformer_dtype = self.transformer.dtype
+        all_prompt_embeds = all_prompt_embeds.to(transformer_dtype)
+        if negative_prompt_embeds is not None:
+            if use_interpolate_prompt:
+                negative_prompt_embeds = negative_prompt_embeds[0].unsqueeze(0)
+            negative_prompt_embeds = negative_prompt_embeds.to(transformer_dtype)
+
+        # 4. Prepare image or video
+        if image is not None:
+            image = self.video_processor.preprocess(image, height=height, width=width)
+            image_latents, fake_image_latents = self.prepare_image_latents(
+                image,
+                latents_mean=latents_mean,
+                latents_std=latents_std,
+                num_latent_frames_per_chunk=num_latent_frames_per_chunk,
+                dtype=torch.float32,
+                device=device,
+                generator=generator,
+                latents=image_latents,
+                fake_latents=fake_image_latents,
+            )
+
+        if image_latents is not None and add_noise_to_image_latents:
+            image_noise_sigma = (
+                torch.rand(1, device=device, generator=generator) * (image_noise_sigma_max - image_noise_sigma_min)
+                + image_noise_sigma_min
+            )
+            image_latents = (
+                image_noise_sigma * randn_tensor(image_latents.shape, generator=generator, device=device)
+                + (1 - image_noise_sigma) * image_latents
+            )
+            fake_image_noise_sigma = (
+                torch.rand(1, device=device, generator=generator) * (video_noise_sigma_max - video_noise_sigma_min)
+                + video_noise_sigma_min
+            )
+            fake_image_latents = (
+                fake_image_noise_sigma * randn_tensor(fake_image_latents.shape, generator=generator, device=device)
+                + (1 - fake_image_noise_sigma) * fake_image_latents
+            )
+
+        if video is not None:
+            video = self.video_processor.preprocess_video(video, height=height, width=width)
+            image_latents, video_latents = self.prepare_video_latents(
+                video,
+                latents_mean=latents_mean,
+                latents_std=latents_std,
+                num_latent_frames_per_chunk=num_latent_frames_per_chunk,
+                dtype=torch.float32,
+                device=device,
+                generator=generator,
+                latents=video_latents,
+            )
+
+        if video_latents is not None and add_noise_to_video_latents:
+            image_noise_sigma = (
+                torch.rand(1, device=device, generator=generator) * (image_noise_sigma_max - image_noise_sigma_min)
+                + image_noise_sigma_min
+            )
+            image_latents = (
+                image_noise_sigma * randn_tensor(image_latents.shape, generator=generator, device=device)
+                + (1 - image_noise_sigma) * image_latents
+            )
+
+            noisy_latents_chunks = []
+            num_latent_chunks = video_latents.shape[2] // num_latent_frames_per_chunk
+            for i in range(num_latent_chunks):
+                chunk_start = i * num_latent_frames_per_chunk
+                chunk_end = chunk_start + num_latent_frames_per_chunk
+                latent_chunk = video_latents[:, :, chunk_start:chunk_end, :, :]
+
+                chunk_frames = latent_chunk.shape[2]
+                frame_sigmas = (
+                    torch.rand(chunk_frames, device=device, generator=generator)
+                    * (video_noise_sigma_max - video_noise_sigma_min)
+                    + video_noise_sigma_min
+                )
+                frame_sigmas = frame_sigmas.view(1, 1, chunk_frames, 1, 1)
+
+                noisy_chunk = (
+                    frame_sigmas * randn_tensor(latent_chunk.shape, generator=generator, device=device)
+                    + (1 - frame_sigmas) * latent_chunk
+                )
+                noisy_latents_chunks.append(noisy_chunk)
+            video_latents = torch.cat(noisy_latents_chunks, dim=2)
+
+        # 5. Prepare latent variables
+        num_channels_latents = self.transformer.config.in_channels
+        window_num_frames = (num_latent_frames_per_chunk - 1) * self.vae_scale_factor_temporal + 1
+        num_latent_chunk = max(1, (num_frames + window_num_frames - 1) // window_num_frames)
+        num_history_latent_frames = sum(history_sizes)
+        history_video = None
+        total_generated_latent_frames = 0
+
+        if not keep_first_frame:
+            history_sizes[-1] = history_sizes[-1] + 1
+        history_latents = torch.zeros(
+            batch_size,
+            num_channels_latents,
+            num_history_latent_frames,
+            height // self.vae_scale_factor_spatial,
+            width // self.vae_scale_factor_spatial,
+            device=device,
+            dtype=torch.float32,
+        )
+        if fake_image_latents is not None:
+            history_latents = torch.cat([history_latents[:, :, :-1, :, :], fake_image_latents], dim=2)
+            total_generated_latent_frames += 1
+        if video_latents is not None:
+            history_frames = history_latents.shape[2]
+            video_frames = video_latents.shape[2]
+            if video_frames < history_frames:
+                keep_frames = history_frames - video_frames
+                history_latents = torch.cat([history_latents[:, :, :keep_frames, :, :], video_latents], dim=2)
+            else:
+                history_latents = video_latents
+            total_generated_latent_frames += video_latents.shape[2]
+
+        if keep_first_frame:
+            indices = torch.arange(0, sum([1, *history_sizes, num_latent_frames_per_chunk]))
+            (
+                indices_prefix,
+                indices_latents_history_long,
+                indices_latents_history_mid,
+                indices_latents_history_1x,
+                indices_hidden_states,
+            ) = indices.split([1, *history_sizes, num_latent_frames_per_chunk], dim=0)
+            indices_latents_history_short = torch.cat([indices_prefix, indices_latents_history_1x], dim=0)
+        else:
+            indices = torch.arange(0, sum([*history_sizes, num_latent_frames_per_chunk]))
+            (
+                indices_latents_history_long,
+                indices_latents_history_mid,
+                indices_latents_history_short,
+                indices_hidden_states,
+            ) = indices.split([*history_sizes, num_latent_frames_per_chunk], dim=0)
+        indices_hidden_states = indices_hidden_states.unsqueeze(0)
+        indices_latents_history_short = indices_latents_history_short.unsqueeze(0)
+        indices_latents_history_mid = indices_latents_history_mid.unsqueeze(0)
+        indices_latents_history_long = indices_latents_history_long.unsqueeze(0)
+
+        # 6. Denoising loop
+        if use_interpolate_prompt:
+            if num_latent_chunk < max(interpolate_cumulative_list):
+                num_latent_chunk = sum(interpolate_cumulative_list)
+                print(f"Update num_latent_chunk to: {num_latent_chunk}")
+
+        if not is_enable_stage2:
+            patch_size = self.transformer.config.patch_size
+            image_seq_len = (
+                num_latent_frames_per_chunk
+                * (height // self.vae_scale_factor_spatial)
+                * (width // self.vae_scale_factor_spatial)
+                // (patch_size[0] * patch_size[1] * patch_size[2])
+            )
+            sigmas = np.linspace(0.999, 0.0, num_inference_steps + 1)[:-1] if sigmas is None else sigmas
+            mu = calculate_shift(
+                image_seq_len,
+                self.scheduler.config.get("base_image_seq_len", 256),
+                self.scheduler.config.get("max_image_seq_len", 4096),
+                self.scheduler.config.get("base_shift", 0.5),
+                self.scheduler.config.get("max_shift", 1.15),
+            )
+
+        for k in range(num_latent_chunk):
+            if use_interpolate_prompt:
+                assert num_latent_chunk >= max(interpolate_cumulative_list)
+
+                current_interval_idx = 0
+                for idx, cumulative_val in enumerate(interpolate_cumulative_list):
+                    if k < cumulative_val:
+                        current_interval_idx = idx
+                        break
+
+                if current_interval_idx == 0:
+                    prompt_embeds = all_prompt_embeds[0].unsqueeze(0)
+                else:
+                    interval_start = interpolate_cumulative_list[current_interval_idx - 1]
+                    position_in_interval = k - interval_start
+
+                    if position_in_interval < interpolation_steps:
+                        if interpolate_embeds is None or interpolate_interval_idx != current_interval_idx:
+                            interpolate_embeds = self.interpolate_prompt_embeds(
+                                prompt_embeds_1=all_prompt_embeds[current_interval_idx - 1].unsqueeze(0),
+                                prompt_embeds_2=all_prompt_embeds[current_interval_idx].unsqueeze(0),
+                                interpolation_steps=interpolation_steps,
+                            )
+                            interpolate_interval_idx = current_interval_idx
+
+                        prompt_embeds = interpolate_embeds[position_in_interval]
+                    else:
+                        prompt_embeds = all_prompt_embeds[current_interval_idx].unsqueeze(0)
+            else:
+                prompt_embeds = all_prompt_embeds
+
+            is_first_chunk = k == 0
+            is_second_chunk = k == 1
+            if keep_first_frame:
+                latents_history_long, latents_history_mid, latents_history_1x = history_latents[
+                    :, :, -num_history_latent_frames:
+                ].split(history_sizes, dim=2)
+                if image_latents is None and is_first_chunk:
+                    latents_prefix = torch.zeros(
+                        (
+                            batch_size,
+                            num_channels_latents,
+                            1,
+                            latents_history_1x.shape[-2],
+                            latents_history_1x.shape[-1],
+                        ),
+                        device=device,
+                        dtype=latents_history_1x.dtype,
+                    )
+                else:
+                    latents_prefix = image_latents
+                latents_history_short = torch.cat([latents_prefix, latents_history_1x], dim=2)
+            else:
+                latents_history_long, latents_history_mid, latents_history_short = history_latents[
+                    :, :, -num_history_latent_frames:
+                ].split(history_sizes, dim=2)
+
+            latents = self.prepare_latents(
+                batch_size,
+                num_channels_latents,
+                height,
+                width,
+                window_num_frames,
+                dtype=torch.float32,
+                device=device,
+                generator=generator,
+                latents=None,
+            )
+
+            if not is_enable_stage2:
+                self.scheduler.set_timesteps(num_inference_steps, device=device, sigmas=sigmas, mu=mu)
+                timesteps = self.scheduler.timesteps
+                num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order
+                self._num_timesteps = len(timesteps)
+            else:
+                num_inference_steps = (
+                    sum(pyramid_num_inference_steps_list) * 2
+                    if is_amplify_first_chunk and self.config.is_distilled and is_first_chunk
+                    else sum(pyramid_num_inference_steps_list)
+                )
+
+            with self.progress_bar(total=num_inference_steps) as progress_bar:
+                if is_enable_stage2:
+                    latents = self.stage2_sample(
+                        latents=latents,
+                        pyramid_num_stages=pyramid_num_stages,
+                        pyramid_num_inference_steps_list=pyramid_num_inference_steps_list,
+                        prompt_embeds=prompt_embeds,
+                        negative_prompt_embeds=negative_prompt_embeds,
+                        guidance_scale=guidance_scale,
+                        indices_hidden_states=indices_hidden_states,
+                        indices_latents_history_short=indices_latents_history_short,
+                        indices_latents_history_mid=indices_latents_history_mid,
+                        indices_latents_history_long=indices_latents_history_long,
+                        latents_history_short=latents_history_short,
+                        latents_history_mid=latents_history_mid,
+                        latents_history_long=latents_history_long,
+                        attention_kwargs=attention_kwargs,
+                        device=device,
+                        transformer_dtype=transformer_dtype,
+                        # ------------ CFG Zero ------------
+                        use_zero_init=use_zero_init,
+                        zero_steps=zero_steps,
+                        # -------------- DMD --------------
+                        is_amplify_first_chunk=is_amplify_first_chunk and is_first_chunk,
+                        # ------------ Callback ------------
+                        callback_on_step_end=callback_on_step_end,
+                        callback_on_step_end_tensor_inputs=callback_on_step_end_tensor_inputs,
+                        progress_bar=progress_bar,
+                        chunk_index=k,
+                        relative_l1_records=relative_l1_records,
+                    )
+                else:
+                    latents = self.stage1_sample(
+                        latents=latents,
+                        prompt_embeds=prompt_embeds,
+                        negative_prompt_embeds=negative_prompt_embeds,
+                        timesteps=timesteps,
+                        guidance_scale=guidance_scale,
+                        indices_hidden_states=indices_hidden_states,
+                        indices_latents_history_short=indices_latents_history_short,
+                        indices_latents_history_mid=indices_latents_history_mid,
+                        indices_latents_history_long=indices_latents_history_long,
+                        latents_history_short=latents_history_short,
+                        latents_history_mid=latents_history_mid,
+                        latents_history_long=latents_history_long,
+                        attention_kwargs=attention_kwargs,
+                        device=device,
+                        transformer_dtype=transformer_dtype,
+                        generator=generator,
+                        num_warmup_steps=num_warmup_steps,
+                        # ------------ CFG Zero ------------
+                        use_zero_init=use_zero_init,
+                        zero_steps=zero_steps,
+                        # ------------ Callback ------------
+                        callback_on_step_end=callback_on_step_end,
+                        callback_on_step_end_tensor_inputs=callback_on_step_end_tensor_inputs,
+                        progress_bar=progress_bar,
+                        chunk_index=k,
+                        relative_l1_records=relative_l1_records,
+                    )
+
+                if keep_first_frame and (
+                    (is_first_chunk and image_latents is None) or (is_skip_first_chunk and is_second_chunk)
+                ):
+                    image_latents = latents[:, :, 0:1, :, :]
+
+                total_generated_latent_frames += latents.shape[2]
+                history_latents = torch.cat([history_latents, latents], dim=2)
+                real_history_latents = history_latents[:, :, -total_generated_latent_frames:]
+                current_latents = (
+                    real_history_latents[:, :, -num_latent_frames_per_chunk:].to(vae_dtype) / latents_std
+                    + latents_mean
+                )
+                current_video = self.vae.decode(current_latents, return_dict=False)[0]
+
+                if history_video is None:
+                    history_video = current_video
+                else:
+                    history_video = torch.cat([history_video, current_video], dim=2)
+
+        self._current_timestep = None
+
+        if output_type != "latent":
+            generated_frames = history_video.size(2)
+            generated_frames = (
+                generated_frames - 1
+            ) // self.vae_scale_factor_temporal * self.vae_scale_factor_temporal + 1
+            history_video = history_video[:, :, :generated_frames]
+            video = self.video_processor.postprocess_video(history_video, output_type=output_type)
+        else:
+            video = real_history_latents
+
+        self.transformer.configure_short_attn_debug(None)
+
+        # Offload all models
+        self.maybe_free_model_hooks()
+
+        if not return_dict:
+            return (video,)
+
+        return HeliosPipelineOutput(frames=video, relative_l1=relative_l1_records)

Helios/_DEV2/helios/diffusers_version/scheduling_helios_diffusers.py

@@ -0,0 +1,947 @@
+# Copyright 2025 The Helios Team and The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import math
+from dataclasses import dataclass
+from typing import Literal
+
+import numpy as np
+import torch
+
+from diffusers.configuration_utils import ConfigMixin, register_to_config
+from diffusers.schedulers.scheduling_utils import SchedulerMixin
+from diffusers.utils import BaseOutput, deprecate
+
+
+@dataclass
+class HeliosSchedulerOutput(BaseOutput):
+    prev_sample: torch.FloatTensor
+    model_outputs: torch.FloatTensor | None = None
+    last_sample: torch.FloatTensor | None = None
+    this_order: int | None = None
+
+
+class HeliosScheduler(SchedulerMixin, ConfigMixin):
+    _compatibles = []
+    order = 1
+
+    @register_to_config
+    def __init__(
+        self,
+        num_train_timesteps: int = 1000,
+        shift: float = 1.0,  # Following Stable diffusion 3,
+        stages: int = 3,
+        stage_range: list = [0, 1 / 3, 2 / 3, 1],
+        gamma: float = 1 / 3,
+        # For UniPC
+        thresholding: bool = False,
+        prediction_type: str = "flow_prediction",
+        solver_order: int = 2,
+        predict_x0: bool = True,
+        solver_type: str = "bh2",
+        lower_order_final: bool = True,
+        disable_corrector: list[int] = [],
+        solver_p: SchedulerMixin = None,
+        use_flow_sigmas: bool = True,
+        scheduler_type: str = "unipc",  # ["euler", "unipc", "dmd"]
+        use_dynamic_shifting: bool = False,
+        time_shift_type: Literal["exponential", "linear"] = "linear",
+    ):
+        self.timestep_ratios = {}  # The timestep ratio for each stage
+        self.timesteps_per_stage = {}  # The detailed timesteps per stage (fix max and min per stage)
+        self.sigmas_per_stage = {}  # always uniform [1000, 0]
+        self.start_sigmas = {}  # for start point / upsample renoise
+        self.end_sigmas = {}  # for end point
+        self.ori_start_sigmas = {}
+
+        # self.init_sigmas()
+        self.init_sigmas_for_each_stage()
+        self.sigma_min = self.sigmas[-1].item()
+        self.sigma_max = self.sigmas[0].item()
+        self.gamma = gamma
+
+        if solver_type not in ["bh1", "bh2"]:
+            if solver_type in ["midpoint", "heun", "logrho"]:
+                self.register_to_config(solver_type="bh2")
+            else:
+                raise NotImplementedError(f"{solver_type} is not implemented for {self.__class__}")
+
+        self.predict_x0 = predict_x0
+        self.model_outputs = [None] * solver_order
+        self.timestep_list = [None] * solver_order
+        self.lower_order_nums = 0
+        self.disable_corrector = disable_corrector
+        self.solver_p = solver_p
+        self.last_sample = None
+        self._step_index = None
+        self._begin_index = None
+
+    def init_sigmas(self):
+        """
+        initialize the global timesteps and sigmas
+        """
+        num_train_timesteps = self.config.num_train_timesteps
+        shift = self.config.shift
+
+        alphas = np.linspace(1, 1 / num_train_timesteps, num_train_timesteps + 1)
+        sigmas = 1.0 - alphas
+        sigmas = np.flip(shift * sigmas / (1 + (shift - 1) * sigmas))[:-1].copy()
+        sigmas = torch.from_numpy(sigmas)
+        timesteps = (sigmas * num_train_timesteps).clone()
+
+        self._step_index = None
+        self._begin_index = None
+        self.timesteps = timesteps
+        self.sigmas = sigmas.to("cpu")  # to avoid too much CPU/GPU communication
+
+    def init_sigmas_for_each_stage(self):
+        """
+        Init the timesteps for each stage
+        """
+        self.init_sigmas()
+
+        stage_distance = []
+        stages = self.config.stages
+        training_steps = self.config.num_train_timesteps
+        stage_range = self.config.stage_range
+
+        # Init the start and end point of each stage
+        for i_s in range(stages):
+            # To decide the start and ends point
+            start_indice = int(stage_range[i_s] * training_steps)
+            start_indice = max(start_indice, 0)
+            end_indice = int(stage_range[i_s + 1] * training_steps)
+            end_indice = min(end_indice, training_steps)
+            start_sigma = self.sigmas[start_indice].item()
+            end_sigma = self.sigmas[end_indice].item() if end_indice < training_steps else 0.0
+            self.ori_start_sigmas[i_s] = start_sigma
+
+            if i_s != 0:
+                ori_sigma = 1 - start_sigma
+                gamma = self.config.gamma
+                corrected_sigma = (1 / (math.sqrt(1 + (1 / gamma)) * (1 - ori_sigma) + ori_sigma)) * ori_sigma
+                # corrected_sigma = 1 / (2 - ori_sigma) * ori_sigma
+                start_sigma = 1 - corrected_sigma
+
+            stage_distance.append(start_sigma - end_sigma)
+            self.start_sigmas[i_s] = start_sigma
+            self.end_sigmas[i_s] = end_sigma
+
+        # Determine the ratio of each stage according to flow length
+        tot_distance = sum(stage_distance)
+        for i_s in range(stages):
+            if i_s == 0:
+                start_ratio = 0.0
+            else:
+                start_ratio = sum(stage_distance[:i_s]) / tot_distance
+            if i_s == stages - 1:
+                end_ratio = 0.9999999999999999
+            else:
+                end_ratio = sum(stage_distance[: i_s + 1]) / tot_distance
+
+            self.timestep_ratios[i_s] = (start_ratio, end_ratio)
+
+        # Determine the timesteps and sigmas for each stage
+        for i_s in range(stages):
+            timestep_ratio = self.timestep_ratios[i_s]
+            # timestep_max = self.timesteps[int(timestep_ratio[0] * training_steps)]
+            timestep_max = min(self.timesteps[int(timestep_ratio[0] * training_steps)], 999)
+            timestep_min = self.timesteps[min(int(timestep_ratio[1] * training_steps), training_steps - 1)]
+            timesteps = np.linspace(timestep_max, timestep_min, training_steps + 1)
+            self.timesteps_per_stage[i_s] = (
+                timesteps[:-1] if isinstance(timesteps, torch.Tensor) else torch.from_numpy(timesteps[:-1])
+            )
+            stage_sigmas = np.linspace(0.999, 0, training_steps + 1)
+            self.sigmas_per_stage[i_s] = torch.from_numpy(stage_sigmas[:-1])
+
+    @property
+    def step_index(self):
+        """
+        The index counter for current timestep. It will increase 1 after each scheduler step.
+        """
+        return self._step_index
+
+    @property
+    def begin_index(self):
+        """
+        The index for the first timestep. It should be set from pipeline with `set_begin_index` method.
+        """
+        return self._begin_index
+
+    def set_begin_index(self, begin_index: int = 0):
+        """
+        Sets the begin index for the scheduler. This function should be run from pipeline before the inference.
+
+        Args:
+            begin_index (`int`):
+                The begin index for the scheduler.
+        """
+        self._begin_index = begin_index
+
+    def _sigma_to_t(self, sigma):
+        return sigma * self.config.num_train_timesteps
+
+    def set_timesteps(
+        self,
+        num_inference_steps: int,
+        stage_index: int | None = None,
+        device: str | torch.device = None,
+        sigmas: bool | None = None,
+        mu: bool | None = None,
+        is_amplify_first_chunk: bool = False,
+    ):
+        """
+        Setting the timesteps and sigmas for each stage
+        """
+        if self.config.scheduler_type == "dmd":
+            if is_amplify_first_chunk:
+                num_inference_steps = num_inference_steps * 2 + 1
+            else:
+                num_inference_steps = num_inference_steps + 1
+
+        self.num_inference_steps = num_inference_steps
+        self.init_sigmas()
+
+        if self.config.stages == 1:
+            if sigmas is None:
+                sigmas = np.linspace(1, 1 / self.config.num_train_timesteps, num_inference_steps + 1)[:-1].astype(
+                    np.float32
+                )
+                if self.config.shift != 1.0:
+                    assert not self.config.use_dynamic_shifting
+                    sigmas = self.time_shift(self.config.shift, 1.0, sigmas)
+            timesteps = (sigmas * self.config.num_train_timesteps).copy()
+            sigmas = torch.from_numpy(sigmas)
+        else:
+            stage_timesteps = self.timesteps_per_stage[stage_index]
+            timesteps = np.linspace(
+                stage_timesteps[0].item(),
+                stage_timesteps[-1].item(),
+                num_inference_steps,
+            )
+
+            stage_sigmas = self.sigmas_per_stage[stage_index]
+            ratios = np.linspace(stage_sigmas[0].item(), stage_sigmas[-1].item(), num_inference_steps)
+            sigmas = torch.from_numpy(ratios)
+
+        self.timesteps = torch.from_numpy(timesteps).to(device=device)
+        self.sigmas = torch.cat([sigmas, torch.zeros(1)]).to(device=device)
+
+        self._step_index = None
+        self.reset_scheduler_history()
+
+        if self.config.scheduler_type == "dmd":
+            self.timesteps = self.timesteps[:-1]
+            self.sigmas = torch.cat([self.sigmas[:-2], self.sigmas[-1:]])
+
+        if self.config.use_dynamic_shifting:
+            assert self.config.shift == 1.0
+            self.sigmas = self.time_shift(mu, 1.0, self.sigmas)
+            if self.config.stages == 1:
+                self.timesteps = self.sigmas[:-1] * self.config.num_train_timesteps
+            else:
+                self.timesteps = self.timesteps_per_stage[stage_index].min() + self.sigmas[:-1] * (
+                    self.timesteps_per_stage[stage_index].max() - self.timesteps_per_stage[stage_index].min()
+                )
+
+    # Copied from diffusers.schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteScheduler.time_shift
+    def time_shift(self, mu: float, sigma: float, t: torch.Tensor):
+        """
+        Apply time shifting to the sigmas.
+
+        Args:
+            mu (`float`):
+                The mu parameter for the time shift.
+            sigma (`float`):
+                The sigma parameter for the time shift.
+            t (`torch.Tensor`):
+                The input timesteps.
+
+        Returns:
+            `torch.Tensor`:
+                The time-shifted timesteps.
+        """
+        if self.config.time_shift_type == "exponential":
+            return self._time_shift_exponential(mu, sigma, t)
+        elif self.config.time_shift_type == "linear":
+            return self._time_shift_linear(mu, sigma, t)
+
+    # Copied from diffusers.schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteScheduler._time_shift_exponential
+    def _time_shift_exponential(self, mu, sigma, t):
+        return math.exp(mu) / (math.exp(mu) + (1 / t - 1) ** sigma)
+
+    # Copied from diffusers.schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteScheduler._time_shift_linear
+    def _time_shift_linear(self, mu, sigma, t):
+        return mu / (mu + (1 / t - 1) ** sigma)
+
+    # ---------------------------------- Euler ----------------------------------
+    def index_for_timestep(self, timestep, schedule_timesteps=None):
+        if schedule_timesteps is None:
+            schedule_timesteps = self.timesteps
+
+        indices = (schedule_timesteps == timestep).nonzero()
+
+        # The sigma index that is taken for the **very** first `step`
+        # is always the second index (or the last index if there is only 1)
+        # This way we can ensure we don't accidentally skip a sigma in
+        # case we start in the middle of the denoising schedule (e.g. for image-to-image)
+        pos = 1 if len(indices) > 1 else 0
+
+        return indices[pos].item()
+
+    def _init_step_index(self, timestep):
+        if self.begin_index is None:
+            if isinstance(timestep, torch.Tensor):
+                timestep = timestep.to(self.timesteps.device)
+            self._step_index = self.index_for_timestep(timestep)
+        else:
+            self._step_index = self._begin_index
+
+    def step_euler(
+        self,
+        model_output: torch.FloatTensor,
+        timestep: float | torch.FloatTensor = None,
+        sample: torch.FloatTensor = None,
+        generator: torch.Generator | None = None,
+        sigma: torch.FloatTensor | None = None,
+        sigma_next: torch.FloatTensor | None = None,
+        return_dict: bool = True,
+    ) -> HeliosSchedulerOutput | tuple:
+        assert (sigma is None) == (sigma_next is None), "sigma and sigma_next must both be None or both be not None"
+
+        if sigma is None and sigma_next is None:
+            if (
+                isinstance(timestep, int)
+                or isinstance(timestep, torch.IntTensor)
+                or isinstance(timestep, torch.LongTensor)
+            ):
+                raise ValueError(
+                    (
+                        "Passing integer indices (e.g. from `enumerate(timesteps)`) as timesteps to"
+                        " `EulerDiscreteScheduler.step()` is not supported. Make sure to pass"
+                        " one of the `scheduler.timesteps` as a timestep."
+                    ),
+                )
+
+        if self.step_index is None:
+            self._step_index = 0
+
+        # Upcast to avoid precision issues when computing prev_sample
+        sample = sample.to(torch.float32)
+
+        if sigma is None and sigma_next is None:
+            sigma = self.sigmas[self.step_index]
+            sigma_next = self.sigmas[self.step_index + 1]
+
+        prev_sample = sample + (sigma_next - sigma) * model_output
+
+        # Cast sample back to model compatible dtype
+        prev_sample = prev_sample.to(model_output.dtype)
+
+        # upon completion increase step index by one
+        self._step_index += 1
+
+        if not return_dict:
+            return (prev_sample,)
+
+        return HeliosSchedulerOutput(prev_sample=prev_sample)
+
+    # ---------------------------------- UniPC ----------------------------------
+    def _sigma_to_alpha_sigma_t(self, sigma):
+        if self.config.use_flow_sigmas:
+            alpha_t = 1 - sigma
+            sigma_t = torch.clamp(sigma, min=1e-8)
+        else:
+            alpha_t = 1 / ((sigma**2 + 1) ** 0.5)
+            sigma_t = sigma * alpha_t
+
+        return alpha_t, sigma_t
+
+    def convert_model_output(
+        self,
+        model_output: torch.Tensor,
+        *args,
+        sample: torch.Tensor = None,
+        sigma: torch.Tensor = None,
+        **kwargs,
+    ) -> torch.Tensor:
+        r"""
+        Convert the model output to the corresponding type the UniPC algorithm needs.
+
+        Args:
+            model_output (`torch.Tensor`):
+                The direct output from the learned diffusion model.
+            timestep (`int`):
+                The current discrete timestep in the diffusion chain.
+            sample (`torch.Tensor`):
+                A current instance of a sample created by the diffusion process.
+
+        Returns:
+            `torch.Tensor`:
+                The converted model output.
+        """
+        timestep = args[0] if len(args) > 0 else kwargs.pop("timestep", None)
+        if sample is None:
+            if len(args) > 1:
+                sample = args[1]
+            else:
+                raise ValueError("missing `sample` as a required keyword argument")
+        if timestep is not None:
+            deprecate(
+                "timesteps",
+                "1.0.0",
+                "Passing `timesteps` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`",
+            )
+
+        flag = False
+        if sigma is None:
+            flag = True
+            sigma = self.sigmas[self.step_index]
+        alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma)
+
+        if self.predict_x0:
+            if self.config.prediction_type == "epsilon":
+                x0_pred = (sample - sigma_t * model_output) / alpha_t
+            elif self.config.prediction_type == "sample":
+                x0_pred = model_output
+            elif self.config.prediction_type == "v_prediction":
+                x0_pred = alpha_t * sample - sigma_t * model_output
+            elif self.config.prediction_type == "flow_prediction":
+                if flag:
+                    sigma_t = self.sigmas[self.step_index]
+                else:
+                    sigma_t = sigma
+                x0_pred = sample - sigma_t * model_output
+            else:
+                raise ValueError(
+                    f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, "
+                    "`v_prediction`, or `flow_prediction` for the UniPCMultistepScheduler."
+                )
+
+            if self.config.thresholding:
+                x0_pred = self._threshold_sample(x0_pred)
+
+            return x0_pred
+        else:
+            if self.config.prediction_type == "epsilon":
+                return model_output
+            elif self.config.prediction_type == "sample":
+                epsilon = (sample - alpha_t * model_output) / sigma_t
+                return epsilon
+            elif self.config.prediction_type == "v_prediction":
+                epsilon = alpha_t * model_output + sigma_t * sample
+                return epsilon
+            else:
+                raise ValueError(
+                    f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, or"
+                    " `v_prediction` for the UniPCMultistepScheduler."
+                )
+
+    def multistep_uni_p_bh_update(
+        self,
+        model_output: torch.Tensor,
+        *args,
+        sample: torch.Tensor = None,
+        order: int = None,
+        sigma: torch.Tensor = None,
+        sigma_next: torch.Tensor = None,
+        **kwargs,
+    ) -> torch.Tensor:
+        """
+        One step for the UniP (B(h) version). Alternatively, `self.solver_p` is used if is specified.
+
+        Args:
+            model_output (`torch.Tensor`):
+                The direct output from the learned diffusion model at the current timestep.
+            prev_timestep (`int`):
+                The previous discrete timestep in the diffusion chain.
+            sample (`torch.Tensor`):
+                A current instance of a sample created by the diffusion process.
+            order (`int`):
+                The order of UniP at this timestep (corresponds to the *p* in UniPC-p).
+
+        Returns:
+            `torch.Tensor`:
+                The sample tensor at the previous timestep.
+        """
+        prev_timestep = args[0] if len(args) > 0 else kwargs.pop("prev_timestep", None)
+        if sample is None:
+            if len(args) > 1:
+                sample = args[1]
+            else:
+                raise ValueError("missing `sample` as a required keyword argument")
+        if order is None:
+            if len(args) > 2:
+                order = args[2]
+            else:
+                raise ValueError("missing `order` as a required keyword argument")
+        if prev_timestep is not None:
+            deprecate(
+                "prev_timestep",
+                "1.0.0",
+                "Passing `prev_timestep` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`",
+            )
+        model_output_list = self.model_outputs
+
+        s0 = self.timestep_list[-1]
+        m0 = model_output_list[-1]
+        x = sample
+
+        if self.solver_p:
+            x_t = self.solver_p.step(model_output, s0, x).prev_sample
+            return x_t
+
+        if sigma_next is None and sigma is None:
+            sigma_t, sigma_s0 = self.sigmas[self.step_index + 1], self.sigmas[self.step_index]
+        else:
+            sigma_t, sigma_s0 = sigma_next, sigma
+        alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma_t)
+        alpha_s0, sigma_s0 = self._sigma_to_alpha_sigma_t(sigma_s0)
+
+        lambda_t = torch.log(alpha_t) - torch.log(sigma_t)
+        lambda_s0 = torch.log(alpha_s0) - torch.log(sigma_s0)
+
+        h = lambda_t - lambda_s0
+        device = sample.device
+
+        rks = []
+        D1s = []
+        for i in range(1, order):
+            si = self.step_index - i
+            mi = model_output_list[-(i + 1)]
+            alpha_si, sigma_si = self._sigma_to_alpha_sigma_t(self.sigmas[si])
+            lambda_si = torch.log(alpha_si) - torch.log(sigma_si)
+            rk = (lambda_si - lambda_s0) / h
+            rks.append(rk)
+            D1s.append((mi - m0) / rk)
+
+        rks.append(1.0)
+        rks = torch.tensor(rks, device=device)
+
+        R = []
+        b = []
+
+        hh = -h if self.predict_x0 else h
+        h_phi_1 = torch.expm1(hh)  # h\phi_1(h) = e^h - 1
+        h_phi_k = h_phi_1 / hh - 1
+
+        factorial_i = 1
+
+        if self.config.solver_type == "bh1":
+            B_h = hh
+        elif self.config.solver_type == "bh2":
+            B_h = torch.expm1(hh)
+        else:
+            raise NotImplementedError()
+
+        for i in range(1, order + 1):
+            R.append(torch.pow(rks, i - 1))
+            b.append(h_phi_k * factorial_i / B_h)
+            factorial_i *= i + 1
+            h_phi_k = h_phi_k / hh - 1 / factorial_i
+
+        R = torch.stack(R)
+        b = torch.tensor(b, device=device)
+
+        if len(D1s) > 0:
+            D1s = torch.stack(D1s, dim=1)  # (B, K)
+            # for order 2, we use a simplified version
+            if order == 2:
+                rhos_p = torch.tensor([0.5], dtype=x.dtype, device=device)
+            else:
+                rhos_p = torch.linalg.solve(R[:-1, :-1], b[:-1]).to(device).to(x.dtype)
+        else:
+            D1s = None
+
+        if self.predict_x0:
+            x_t_ = sigma_t / sigma_s0 * x - alpha_t * h_phi_1 * m0
+            if D1s is not None:
+                pred_res = torch.einsum("k,bkc...->bc...", rhos_p, D1s)
+            else:
+                pred_res = 0
+            x_t = x_t_ - alpha_t * B_h * pred_res
+        else:
+            x_t_ = alpha_t / alpha_s0 * x - sigma_t * h_phi_1 * m0
+            if D1s is not None:
+                pred_res = torch.einsum("k,bkc...->bc...", rhos_p, D1s)
+            else:
+                pred_res = 0
+            x_t = x_t_ - sigma_t * B_h * pred_res
+
+        x_t = x_t.to(x.dtype)
+        return x_t
+
+    def multistep_uni_c_bh_update(
+        self,
+        this_model_output: torch.Tensor,
+        *args,
+        last_sample: torch.Tensor = None,
+        this_sample: torch.Tensor = None,
+        order: int = None,
+        sigma_before: torch.Tensor = None,
+        sigma: torch.Tensor = None,
+        **kwargs,
+    ) -> torch.Tensor:
+        """
+        One step for the UniC (B(h) version).
+
+        Args:
+            this_model_output (`torch.Tensor`):
+                The model outputs at `x_t`.
+            this_timestep (`int`):
+                The current timestep `t`.
+            last_sample (`torch.Tensor`):
+                The generated sample before the last predictor `x_{t-1}`.
+            this_sample (`torch.Tensor`):
+                The generated sample after the last predictor `x_{t}`.
+            order (`int`):
+                The `p` of UniC-p at this step. The effective order of accuracy should be `order + 1`.
+
+        Returns:
+            `torch.Tensor`:
+                The corrected sample tensor at the current timestep.
+        """
+        this_timestep = args[0] if len(args) > 0 else kwargs.pop("this_timestep", None)
+        if last_sample is None:
+            if len(args) > 1:
+                last_sample = args[1]
+            else:
+                raise ValueError("missing `last_sample` as a required keyword argument")
+        if this_sample is None:
+            if len(args) > 2:
+                this_sample = args[2]
+            else:
+                raise ValueError("missing `this_sample` as a required keyword argument")
+        if order is None:
+            if len(args) > 3:
+                order = args[3]
+            else:
+                raise ValueError("missing `order` as a required keyword argument")
+        if this_timestep is not None:
+            deprecate(
+                "this_timestep",
+                "1.0.0",
+                "Passing `this_timestep` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`",
+            )
+
+        model_output_list = self.model_outputs
+
+        m0 = model_output_list[-1]
+        x = last_sample
+        x_t = this_sample
+        model_t = this_model_output
+
+        if sigma_before is None and sigma is None:
+            sigma_t, sigma_s0 = self.sigmas[self.step_index], self.sigmas[self.step_index - 1]
+        else:
+            sigma_t, sigma_s0 = sigma, sigma_before
+        alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma_t)
+        alpha_s0, sigma_s0 = self._sigma_to_alpha_sigma_t(sigma_s0)
+
+        lambda_t = torch.log(alpha_t) - torch.log(sigma_t)
+        lambda_s0 = torch.log(alpha_s0) - torch.log(sigma_s0)
+
+        h = lambda_t - lambda_s0
+        device = this_sample.device
+
+        rks = []
+        D1s = []
+        for i in range(1, order):
+            si = self.step_index - (i + 1)
+            mi = model_output_list[-(i + 1)]
+            alpha_si, sigma_si = self._sigma_to_alpha_sigma_t(self.sigmas[si])
+            lambda_si = torch.log(alpha_si) - torch.log(sigma_si)
+            rk = (lambda_si - lambda_s0) / h
+            rks.append(rk)
+            D1s.append((mi - m0) / rk)
+
+        rks.append(1.0)
+        rks = torch.tensor(rks, device=device)
+
+        R = []
+        b = []
+
+        hh = -h if self.predict_x0 else h
+        h_phi_1 = torch.expm1(hh)  # h\phi_1(h) = e^h - 1
+        h_phi_k = h_phi_1 / hh - 1
+
+        factorial_i = 1
+
+        if self.config.solver_type == "bh1":
+            B_h = hh
+        elif self.config.solver_type == "bh2":
+            B_h = torch.expm1(hh)
+        else:
+            raise NotImplementedError()
+
+        for i in range(1, order + 1):
+            R.append(torch.pow(rks, i - 1))
+            b.append(h_phi_k * factorial_i / B_h)
+            factorial_i *= i + 1
+            h_phi_k = h_phi_k / hh - 1 / factorial_i
+
+        R = torch.stack(R)
+        b = torch.tensor(b, device=device)
+
+        if len(D1s) > 0:
+            D1s = torch.stack(D1s, dim=1)
+        else:
+            D1s = None
+
+        # for order 1, we use a simplified version
+        if order == 1:
+            rhos_c = torch.tensor([0.5], dtype=x.dtype, device=device)
+        else:
+            rhos_c = torch.linalg.solve(R, b).to(device).to(x.dtype)
+
+        if self.predict_x0:
+            x_t_ = sigma_t / sigma_s0 * x - alpha_t * h_phi_1 * m0
+            if D1s is not None:
+                corr_res = torch.einsum("k,bkc...->bc...", rhos_c[:-1], D1s)
+            else:
+                corr_res = 0
+            D1_t = model_t - m0
+            x_t = x_t_ - alpha_t * B_h * (corr_res + rhos_c[-1] * D1_t)
+        else:
+            x_t_ = alpha_t / alpha_s0 * x - sigma_t * h_phi_1 * m0
+            if D1s is not None:
+                corr_res = torch.einsum("k,bkc...->bc...", rhos_c[:-1], D1s)
+            else:
+                corr_res = 0
+            D1_t = model_t - m0
+            x_t = x_t_ - sigma_t * B_h * (corr_res + rhos_c[-1] * D1_t)
+        x_t = x_t.to(x.dtype)
+        return x_t
+
+    def step_unipc(
+        self,
+        model_output: torch.Tensor,
+        timestep: int | torch.Tensor = None,
+        sample: torch.Tensor = None,
+        return_dict: bool = True,
+        model_outputs: list = None,
+        timestep_list: list = None,
+        sigma_before: torch.Tensor = None,
+        sigma: torch.Tensor = None,
+        sigma_next: torch.Tensor = None,
+        cus_step_index: int = None,
+        cus_lower_order_num: int = None,
+        cus_this_order: int = None,
+        cus_last_sample: torch.Tensor = None,
+    ) -> HeliosSchedulerOutput | tuple:
+        if self.num_inference_steps is None:
+            raise ValueError(
+                "Number of inference steps is 'None', you need to run 'set_timesteps' after creating the scheduler"
+            )
+
+        if cus_step_index is None:
+            if self.step_index is None:
+                self._step_index = 0
+        else:
+            self._step_index = cus_step_index
+
+        if cus_lower_order_num is not None:
+            self.lower_order_nums = cus_lower_order_num
+
+        if cus_this_order is not None:
+            self.this_order = cus_this_order
+
+        if cus_last_sample is not None:
+            self.last_sample = cus_last_sample
+
+        use_corrector = (
+            self.step_index > 0 and self.step_index - 1 not in self.disable_corrector and self.last_sample is not None
+        )
+
+        # Convert model output using the proper conversion method
+        model_output_convert = self.convert_model_output(model_output, sample=sample, sigma=sigma)
+
+        if model_outputs is not None and timestep_list is not None:
+            self.model_outputs = model_outputs[:-1]
+            self.timestep_list = timestep_list[:-1]
+
+        if use_corrector:
+            sample = self.multistep_uni_c_bh_update(
+                this_model_output=model_output_convert,
+                last_sample=self.last_sample,
+                this_sample=sample,
+                order=self.this_order,
+                sigma_before=sigma_before,
+                sigma=sigma,
+            )
+
+        if model_outputs is not None and timestep_list is not None:
+            model_outputs[-1] = model_output_convert
+            self.model_outputs = model_outputs[1:]
+            self.timestep_list = timestep_list[1:]
+        else:
+            for i in range(self.config.solver_order - 1):
+                self.model_outputs[i] = self.model_outputs[i + 1]
+                self.timestep_list[i] = self.timestep_list[i + 1]
+            self.model_outputs[-1] = model_output_convert
+            self.timestep_list[-1] = timestep
+
+        if self.config.lower_order_final:
+            this_order = min(self.config.solver_order, len(self.timesteps) - self.step_index)
+        else:
+            this_order = self.config.solver_order
+        self.this_order = min(this_order, self.lower_order_nums + 1)  # warmup for multistep
+        assert self.this_order > 0
+
+        self.last_sample = sample
+        prev_sample = self.multistep_uni_p_bh_update(
+            model_output=model_output,  # pass the original non-converted model output, in case solver-p is used
+            sample=sample,
+            order=self.this_order,
+            sigma=sigma,
+            sigma_next=sigma_next,
+        )
+
+        if cus_lower_order_num is None:
+            if self.lower_order_nums < self.config.solver_order:
+                self.lower_order_nums += 1
+
+        # upon completion increase step index by one
+        if cus_step_index is None:
+            self._step_index += 1
+
+        if not return_dict:
+            return (prev_sample, model_outputs, self.last_sample, self.this_order)
+
+        return HeliosSchedulerOutput(
+            prev_sample=prev_sample,
+            model_outputs=model_outputs,
+            last_sample=self.last_sample,
+            this_order=self.this_order,
+        )
+
+    # ---------------------------------- For DMD ----------------------------------
+    def add_noise(self, original_samples, noise, timestep, sigmas, timesteps):
+        sigmas = sigmas.to(noise.device)
+        timesteps = timesteps.to(noise.device)
+        timestep_id = torch.argmin((timesteps.unsqueeze(0) - timestep.unsqueeze(1)).abs(), dim=1)
+        sigma = sigmas[timestep_id].reshape(-1, 1, 1, 1, 1)
+        sample = (1 - sigma) * original_samples + sigma * noise
+        return sample.type_as(noise)
+
+    def convert_flow_pred_to_x0(self, flow_pred, xt, timestep, sigmas, timesteps):
+        # use higher precision for calculations
+        original_dtype = flow_pred.dtype
+        device = flow_pred.device
+        flow_pred, xt, sigmas, timesteps = (x.double().to(device) for x in (flow_pred, xt, sigmas, timesteps))
+
+        timestep_id = torch.argmin((timesteps.unsqueeze(0) - timestep.unsqueeze(1)).abs(), dim=1)
+        sigma_t = sigmas[timestep_id].reshape(-1, 1, 1, 1, 1)
+        x0_pred = xt - sigma_t * flow_pred
+        return x0_pred.to(original_dtype)
+
+    def step_dmd(
+        self,
+        model_output: torch.FloatTensor,
+        timestep: float | torch.FloatTensor = None,
+        sample: torch.FloatTensor = None,
+        generator: torch.Generator | None = None,
+        return_dict: bool = True,
+        cur_sampling_step: int = 0,
+        dmd_noisy_tensor: torch.FloatTensor | None = None,
+        dmd_sigmas: torch.FloatTensor | None = None,
+        dmd_timesteps: torch.FloatTensor | None = None,
+        all_timesteps: torch.FloatTensor | None = None,
+    ):
+        pred_image_or_video = self.convert_flow_pred_to_x0(
+            flow_pred=model_output,
+            xt=sample,
+            timestep=torch.full((model_output.shape[0],), timestep, dtype=torch.long, device=model_output.device),
+            sigmas=dmd_sigmas,
+            timesteps=dmd_timesteps,
+        )
+        if cur_sampling_step < len(all_timesteps) - 1:
+            prev_sample = self.add_noise(
+                pred_image_or_video,
+                dmd_noisy_tensor,
+                torch.full(
+                    (model_output.shape[0],),
+                    all_timesteps[cur_sampling_step + 1],
+                    dtype=torch.long,
+                    device=model_output.device,
+                ),
+                sigmas=dmd_sigmas,
+                timesteps=dmd_timesteps,
+            )
+        else:
+            prev_sample = pred_image_or_video
+
+        if not return_dict:
+            return (prev_sample,)
+
+        return HeliosSchedulerOutput(prev_sample=prev_sample)
+
+    # ---------------------------------- Merge ----------------------------------
+    def step(
+        self,
+        model_output: torch.FloatTensor,
+        timestep: float | torch.FloatTensor = None,
+        sample: torch.FloatTensor = None,
+        generator: torch.Generator | None = None,
+        return_dict: bool = True,
+        # For DMD
+        cur_sampling_step: int = 0,
+        dmd_noisy_tensor: torch.FloatTensor | None = None,
+        dmd_sigmas: torch.FloatTensor | None = None,
+        dmd_timesteps: torch.FloatTensor | None = None,
+        all_timesteps: torch.FloatTensor | None = None,
+    ) -> HeliosSchedulerOutput | tuple:
+        if self.config.scheduler_type == "euler":
+            return self.step_euler(
+                model_output=model_output,
+                timestep=timestep,
+                sample=sample,
+                generator=generator,
+                return_dict=return_dict,
+            )
+        elif self.config.scheduler_type == "unipc":
+            return self.step_unipc(
+                model_output=model_output,
+                timestep=timestep,
+                sample=sample,
+                return_dict=return_dict,
+            )
+        elif self.config.scheduler_type == "dmd":
+            return self.step_dmd(
+                model_output=model_output,
+                timestep=timestep,
+                sample=sample,
+                generator=generator,
+                return_dict=return_dict,
+                cur_sampling_step=cur_sampling_step,
+                dmd_noisy_tensor=dmd_noisy_tensor,
+                dmd_sigmas=dmd_sigmas,
+                dmd_timesteps=dmd_timesteps,
+                all_timesteps=all_timesteps,
+            )
+        else:
+            raise NotImplementedError
+
+    def reset_scheduler_history(self):
+        self.model_outputs = [None] * self.config.solver_order
+        self.timestep_list = [None] * self.config.solver_order
+        self.lower_order_nums = 0
+        self.disable_corrector = self.config.disable_corrector
+        self.solver_p = self.config.solver_p
+        self.last_sample = None
+        self._step_index = None
+        self._begin_index = None
+
+    def __len__(self):
+        return self.config.num_train_timesteps

Helios/_DEV2/helios/diffusers_version/transformer_helios_diffusers.py

@@ -0,0 +1,1005 @@
+# Copyright 2025 The Helios Team and The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import math
+import os
+from functools import lru_cache
+from typing import Any
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from diffusers.configuration_utils import ConfigMixin, register_to_config
+from diffusers.loaders import FromOriginalModelMixin, PeftAdapterMixin
+from diffusers.models._modeling_parallel import ContextParallelInput, ContextParallelOutput
+from diffusers.models.attention import AttentionMixin, AttentionModuleMixin, FeedForward
+from diffusers.models.attention_dispatch import dispatch_attention_fn
+from diffusers.models.cache_utils import CacheMixin
+from diffusers.models.embeddings import PixArtAlphaTextProjection, TimestepEmbedding, Timesteps
+from diffusers.models.modeling_outputs import Transformer2DModelOutput
+from diffusers.models.modeling_utils import ModelMixin
+from diffusers.models.normalization import FP32LayerNorm
+from diffusers.utils import apply_lora_scale, logging
+from diffusers.utils.torch_utils import maybe_allow_in_graph
+
+
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
+
+
+def _short_attn_debug_target_matches(value, targets, total=None):
+    if targets is None:
+        return True
+    if not isinstance(targets, (list, tuple, set)):
+        targets = [targets]
+    for target in targets:
+        if target == "last" and total is not None and value == total - 1:
+            return True
+        if target == "first" and value == 0:
+            return True
+        if isinstance(target, int) and value == target:
+            return True
+    return False
+
+
+@torch.no_grad()
+def _save_short_attn_debug(attn, query, key, original_context_length, original_context_length_list=None):
+    config = getattr(attn, "_short_attn_debug_config", None)
+    state = getattr(attn, "_short_attn_debug_state", None)
+    if not config or not config.get("enabled", True) or attn.is_cross_attention:
+        return
+    if original_context_length_list is not None and len(original_context_length_list) != 1:
+        return
+
+    block_idx = getattr(attn, "_helios_block_idx", None)
+    if not _short_attn_debug_target_matches(block_idx, config.get("blocks")):
+        return
+    if state is None:
+        state = {}
+    if not _short_attn_debug_target_matches(state.get("chunk_index", 0), config.get("chunks")):
+        return
+    if not _short_attn_debug_target_matches(
+        state.get("step_index", 0), config.get("steps"), state.get("total_steps")
+    ):
+        return
+    pass_names = config.get("pass_names", ["cond"])
+    if state.get("pass_name", "cond") not in pass_names:
+        return
+
+    if original_context_length is None:
+        return
+    history_seq_len = key.shape[1] - original_context_length
+    if history_seq_len <= 0:
+        return
+
+    grid_h, grid_w = config.get("grid", (24, 40))
+    grid_tokens = int(grid_h) * int(grid_w)
+    if grid_tokens <= 0 or original_context_length % grid_tokens != 0:
+        return
+
+    current_frames = original_context_length // grid_tokens
+    current_frame = int(config.get("current_frame", current_frames - 1))
+    if current_frame < 0:
+        current_frame += current_frames
+    if current_frame < 0 or current_frame >= current_frames:
+        return
+
+    short_history_frames = int(config.get("short_history_frames", 2))
+    prev_short_frame = int(config.get("prev_short_frame", short_history_frames - 1))
+    if prev_short_frame < 0:
+        prev_short_frame += short_history_frames
+    short_len = short_history_frames * grid_tokens
+    if history_seq_len < short_len or prev_short_frame < 0 or prev_short_frame >= short_history_frames:
+        return
+
+    short_start = history_seq_len - short_len
+    prev_start = short_start + prev_short_frame * grid_tokens
+    if query.shape[1] == history_seq_len + original_context_length:
+        current_start = history_seq_len + current_frame * grid_tokens
+    elif query.shape[1] == original_context_length:
+        current_start = current_frame * grid_tokens
+    else:
+        return
+
+    batch_index = int(config.get("batch_index", 0))
+    if batch_index < 0 or batch_index >= query.shape[0]:
+        return
+
+    q_frame = query[batch_index, current_start : current_start + grid_tokens].float()
+    k_prev = key[batch_index, prev_start : prev_start + grid_tokens].float()
+    if q_frame.shape[0] != grid_tokens or k_prev.shape[0] != grid_tokens:
+        return
+
+    topk = max(2, int(config.get("topk", 2)))
+    query_chunk_size = int(config.get("query_chunk_size", 128))
+    scale = 1.0 / math.sqrt(q_frame.shape[-1])
+    top_scores = []
+    top_indices = []
+    for start in range(0, grid_tokens, query_chunk_size):
+        q_chunk = q_frame[start : start + query_chunk_size]
+        scores = torch.einsum("qhd,khd->hqk", q_chunk, k_prev) * scale
+        scores = scores.mean(dim=0)
+        values, indices = scores.topk(topk, dim=-1)
+        top_scores.append(values.cpu())
+        top_indices.append(indices.cpu())
+
+    top_scores = torch.cat(top_scores, dim=0)
+    top_indices = torch.cat(top_indices, dim=0)
+    top1 = top_indices[:, 0]
+    match_y = torch.div(top1, grid_w, rounding_mode="floor")
+    match_x = top1 % grid_w
+    query_positions = torch.arange(grid_tokens)
+    query_y = torch.div(query_positions, grid_w, rounding_mode="floor")
+    query_x = query_positions % grid_w
+    match_yx = torch.stack([match_y, match_x], dim=-1).reshape(grid_h, grid_w, 2)
+    query_yx = torch.stack([query_y, query_x], dim=-1).reshape(grid_h, grid_w, 2)
+    displacement_yx = match_yx - query_yx
+
+    artifact = {
+        "block": block_idx,
+        "chunk_index": state.get("chunk_index"),
+        "stage": state.get("stage"),
+        "stage_index": state.get("stage_index"),
+        "step_index": state.get("step_index"),
+        "total_steps": state.get("total_steps"),
+        "pass_name": state.get("pass_name"),
+        "timestep": state.get("timestep"),
+        "current_frame": current_frame,
+        "prev_short_frame": prev_short_frame,
+        "grid": (grid_h, grid_w),
+        "match_yx": match_yx,
+        "query_yx": query_yx,
+        "displacement_yx": displacement_yx,
+        "topk_indices": top_indices.reshape(grid_h, grid_w, topk),
+        "topk_scores": top_scores.reshape(grid_h, grid_w, topk),
+        "top1_score": top_scores[:, 0].reshape(grid_h, grid_w),
+        "top2_score": top_scores[:, 1].reshape(grid_h, grid_w),
+        "margin": (top_scores[:, 0] - top_scores[:, 1]).reshape(grid_h, grid_w),
+    }
+
+    output_dir = config.get("output_dir", "short_attn_debug")
+    os.makedirs(output_dir, exist_ok=True)
+    filename = (
+        f"short_attn_chunk{state.get('chunk_index', 0)}"
+        f"_step{state.get('step_index', 0)}"
+        f"_block{block_idx}"
+        f"_frame{current_frame}"
+        f"_{state.get('pass_name', 'cond')}.pt"
+    )
+    path = os.path.join(output_dir, filename)
+    if os.path.exists(path) and not config.get("overwrite", True):
+        return
+    torch.save(artifact, path)
+
+
+def pad_for_3d_conv(x, kernel_size):
+    b, c, t, h, w = x.shape
+    pt, ph, pw = kernel_size
+    pad_t = (pt - (t % pt)) % pt
+    pad_h = (ph - (h % ph)) % ph
+    pad_w = (pw - (w % pw)) % pw
+    return torch.nn.functional.pad(x, (0, pad_w, 0, pad_h, 0, pad_t), mode="replicate")
+
+
+def center_down_sample_3d(x, kernel_size):
+    return torch.nn.functional.avg_pool3d(x, kernel_size, stride=kernel_size)
+
+
+def apply_rotary_emb_transposed(
+    hidden_states: torch.Tensor,
+    freqs_cis: torch.Tensor,
+):
+    x_1, x_2 = hidden_states.unflatten(-1, (-1, 2)).unbind(-1)
+    cos, sin = freqs_cis.unsqueeze(-2).chunk(2, dim=-1)
+    out = torch.empty_like(hidden_states)
+    out[..., 0::2] = x_1 * cos[..., 0::2] - x_2 * sin[..., 1::2]
+    out[..., 1::2] = x_1 * sin[..., 1::2] + x_2 * cos[..., 0::2]
+    return out.type_as(hidden_states)
+
+
+def _get_qkv_projections(attn: "HeliosAttention", hidden_states: torch.Tensor, encoder_hidden_states: torch.Tensor):
+    # encoder_hidden_states is only passed for cross-attention
+    if encoder_hidden_states is None:
+        encoder_hidden_states = hidden_states
+
+    if attn.fused_projections:
+        if not attn.is_cross_attention:
+            # In self-attention layers, we can fuse the entire QKV projection into a single linear
+            query, key, value = attn.to_qkv(hidden_states).chunk(3, dim=-1)
+        else:
+            # In cross-attention layers, we can only fuse the KV projections into a single linear
+            query = attn.to_q(hidden_states)
+            key, value = attn.to_kv(encoder_hidden_states).chunk(2, dim=-1)
+    else:
+        query = attn.to_q(hidden_states)
+        key = attn.to_k(encoder_hidden_states)
+        value = attn.to_v(encoder_hidden_states)
+    return query, key, value
+
+
+class HeliosOutputNorm(nn.Module):
+    def __init__(self, dim: int, eps: float = 1e-6, elementwise_affine: bool = False):
+        super().__init__()
+        self.scale_shift_table = nn.Parameter(torch.randn(1, 2, dim) / dim**0.5)
+        self.norm = FP32LayerNorm(dim, eps, elementwise_affine=False)
+
+    def forward(self, hidden_states: torch.Tensor, temb: torch.Tensor, original_context_length: int):
+        temb = temb[:, -original_context_length:, :]
+        shift, scale = (self.scale_shift_table.unsqueeze(0).to(temb.device) + temb.unsqueeze(2)).chunk(2, dim=2)
+        shift, scale = shift.squeeze(2).to(hidden_states.device), scale.squeeze(2).to(hidden_states.device)
+        hidden_states = hidden_states[:, -original_context_length:, :]
+        hidden_states = (self.norm(hidden_states.float()) * (1 + scale) + shift).type_as(hidden_states)
+        return hidden_states
+
+
+class HeliosAttnProcessor:
+    _attention_backend = None
+    _parallel_config = None
+
+    def __init__(self):
+        if not hasattr(F, "scaled_dot_product_attention"):
+            raise ImportError(
+                "HeliosAttnProcessor requires PyTorch 2.0. To use it, please upgrade PyTorch to version 2.0 or higher."
+            )
+
+    def __call__(
+        self,
+        attn: "HeliosAttention",
+        hidden_states: torch.Tensor,
+        encoder_hidden_states: torch.Tensor | None = None,
+        attention_mask: torch.Tensor | None = None,
+        rotary_emb: tuple[torch.Tensor, torch.Tensor] | None = None,
+        original_context_length: int = None,
+    ) -> torch.Tensor:
+        query, key, value = _get_qkv_projections(attn, hidden_states, encoder_hidden_states)
+
+        query = attn.norm_q(query)
+        key = attn.norm_k(key)
+
+        query = query.unflatten(2, (attn.heads, -1))
+        key = key.unflatten(2, (attn.heads, -1))
+        value = value.unflatten(2, (attn.heads, -1))
+
+        if rotary_emb is not None:
+            query = apply_rotary_emb_transposed(query, rotary_emb)
+            key = apply_rotary_emb_transposed(key, rotary_emb)
+
+        if not attn.is_cross_attention and attn.is_amplify_history:
+            history_seq_len = hidden_states.shape[1] - original_context_length
+
+            if history_seq_len > 0:
+                scale_key = 1.0 + torch.sigmoid(attn.history_key_scale) * (attn.max_scale - 1.0)
+                if attn.history_scale_mode == "per_head":
+                    scale_key = scale_key.view(1, 1, -1, 1)
+                key = torch.cat([key[:, :history_seq_len] * scale_key, key[:, history_seq_len:]], dim=1)
+
+        _save_short_attn_debug(attn, query, key, original_context_length)
+
+        hidden_states = dispatch_attention_fn(
+            query,
+            key,
+            value,
+            attn_mask=attention_mask,
+            dropout_p=0.0,
+            is_causal=False,
+            backend=self._attention_backend,
+            # Reference: https://github.com/huggingface/diffusers/pull/12909
+            parallel_config=(self._parallel_config if encoder_hidden_states is None else None),
+        )
+        hidden_states = hidden_states.flatten(2, 3)
+        hidden_states = hidden_states.type_as(query)
+
+        hidden_states = attn.to_out[0](hidden_states)
+        hidden_states = attn.to_out[1](hidden_states)
+        return hidden_states
+
+
+class HeliosAttention(torch.nn.Module, AttentionModuleMixin):
+    _default_processor_cls = HeliosAttnProcessor
+    _available_processors = [HeliosAttnProcessor]
+
+    def __init__(
+        self,
+        dim: int,
+        heads: int = 8,
+        dim_head: int = 64,
+        eps: float = 1e-5,
+        dropout: float = 0.0,
+        added_kv_proj_dim: int | None = None,
+        cross_attention_dim_head: int | None = None,
+        processor=None,
+        is_cross_attention=None,
+        is_amplify_history=False,
+        history_scale_mode="per_head",  # [scalar, per_head]
+    ):
+        super().__init__()
+
+        self.inner_dim = dim_head * heads
+        self.heads = heads
+        self.added_kv_proj_dim = added_kv_proj_dim
+        self.cross_attention_dim_head = cross_attention_dim_head
+        self.kv_inner_dim = self.inner_dim if cross_attention_dim_head is None else cross_attention_dim_head * heads
+
+        self.to_q = torch.nn.Linear(dim, self.inner_dim, bias=True)
+        self.to_k = torch.nn.Linear(dim, self.kv_inner_dim, bias=True)
+        self.to_v = torch.nn.Linear(dim, self.kv_inner_dim, bias=True)
+        self.to_out = torch.nn.ModuleList(
+            [
+                torch.nn.Linear(self.inner_dim, dim, bias=True),
+                torch.nn.Dropout(dropout),
+            ]
+        )
+        self.norm_q = torch.nn.RMSNorm(dim_head * heads, eps=eps, elementwise_affine=True)
+        self.norm_k = torch.nn.RMSNorm(dim_head * heads, eps=eps, elementwise_affine=True)
+
+        self.add_k_proj = self.add_v_proj = None
+        if added_kv_proj_dim is not None:
+            self.add_k_proj = torch.nn.Linear(added_kv_proj_dim, self.inner_dim, bias=True)
+            self.add_v_proj = torch.nn.Linear(added_kv_proj_dim, self.inner_dim, bias=True)
+            self.norm_added_k = torch.nn.RMSNorm(dim_head * heads, eps=eps)
+
+        if is_cross_attention is not None:
+            self.is_cross_attention = is_cross_attention
+        else:
+            self.is_cross_attention = cross_attention_dim_head is not None
+
+        self.set_processor(processor)
+
+        self.is_amplify_history = is_amplify_history
+        if is_amplify_history:
+            if history_scale_mode == "scalar":
+                self.history_key_scale = nn.Parameter(torch.ones(1))
+            elif history_scale_mode == "per_head":
+                self.history_key_scale = nn.Parameter(torch.ones(heads))
+            else:
+                raise ValueError(f"Unknown history_scale_mode: {history_scale_mode}")
+            self.history_scale_mode = history_scale_mode
+            self.max_scale = 10.0
+
+    def fuse_projections(self):
+        if getattr(self, "fused_projections", False):
+            return
+
+        if not self.is_cross_attention:
+            concatenated_weights = torch.cat([self.to_q.weight.data, self.to_k.weight.data, self.to_v.weight.data])
+            concatenated_bias = torch.cat([self.to_q.bias.data, self.to_k.bias.data, self.to_v.bias.data])
+            out_features, in_features = concatenated_weights.shape
+            with torch.device("meta"):
+                self.to_qkv = nn.Linear(in_features, out_features, bias=True)
+            self.to_qkv.load_state_dict(
+                {"weight": concatenated_weights, "bias": concatenated_bias}, strict=True, assign=True
+            )
+        else:
+            concatenated_weights = torch.cat([self.to_k.weight.data, self.to_v.weight.data])
+            concatenated_bias = torch.cat([self.to_k.bias.data, self.to_v.bias.data])
+            out_features, in_features = concatenated_weights.shape
+            with torch.device("meta"):
+                self.to_kv = nn.Linear(in_features, out_features, bias=True)
+            self.to_kv.load_state_dict(
+                {"weight": concatenated_weights, "bias": concatenated_bias}, strict=True, assign=True
+            )
+
+        if self.added_kv_proj_dim is not None:
+            concatenated_weights = torch.cat([self.add_k_proj.weight.data, self.add_v_proj.weight.data])
+            concatenated_bias = torch.cat([self.add_k_proj.bias.data, self.add_v_proj.bias.data])
+            out_features, in_features = concatenated_weights.shape
+            with torch.device("meta"):
+                self.to_added_kv = nn.Linear(in_features, out_features, bias=True)
+            self.to_added_kv.load_state_dict(
+                {"weight": concatenated_weights, "bias": concatenated_bias}, strict=True, assign=True
+            )
+
+        self.fused_projections = True
+
+    @torch.no_grad()
+    def unfuse_projections(self):
+        if not getattr(self, "fused_projections", False):
+            return
+
+        if hasattr(self, "to_qkv"):
+            delattr(self, "to_qkv")
+        if hasattr(self, "to_kv"):
+            delattr(self, "to_kv")
+        if hasattr(self, "to_added_kv"):
+            delattr(self, "to_added_kv")
+
+        self.fused_projections = False
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        encoder_hidden_states: torch.Tensor | None = None,
+        attention_mask: torch.Tensor | None = None,
+        rotary_emb: tuple[torch.Tensor, torch.Tensor] | None = None,
+        original_context_length: int = None,
+        **kwargs,
+    ) -> torch.Tensor:
+        return self.processor(
+            self,
+            hidden_states,
+            encoder_hidden_states,
+            attention_mask,
+            rotary_emb,
+            original_context_length,
+            **kwargs,
+        )
+
+
+class HeliosTimeTextEmbedding(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        time_freq_dim: int,
+        time_proj_dim: int,
+        text_embed_dim: int,
+    ):
+        super().__init__()
+
+        self.timesteps_proj = Timesteps(num_channels=time_freq_dim, flip_sin_to_cos=True, downscale_freq_shift=0)
+        self.time_embedder = TimestepEmbedding(in_channels=time_freq_dim, time_embed_dim=dim)
+        self.act_fn = nn.SiLU()
+        self.time_proj = nn.Linear(dim, time_proj_dim)
+        self.text_embedder = PixArtAlphaTextProjection(text_embed_dim, dim, act_fn="gelu_tanh")
+
+    def forward(
+        self,
+        timestep: torch.Tensor,
+        encoder_hidden_states: torch.Tensor | None = None,
+        is_return_encoder_hidden_states: bool = True,
+    ):
+        timestep = self.timesteps_proj(timestep)
+
+        time_embedder_dtype = next(iter(self.time_embedder.parameters())).dtype
+        if timestep.dtype != time_embedder_dtype and time_embedder_dtype != torch.int8:
+            timestep = timestep.to(time_embedder_dtype)
+        temb = self.time_embedder(timestep).type_as(encoder_hidden_states)
+        timestep_proj = self.time_proj(self.act_fn(temb))
+
+        if encoder_hidden_states is not None and is_return_encoder_hidden_states:
+            encoder_hidden_states = self.text_embedder(encoder_hidden_states)
+
+        return temb, timestep_proj, encoder_hidden_states
+
+
+class HeliosRotaryPosEmbed(nn.Module):
+    def __init__(self, rope_dim, theta):
+        super().__init__()
+        self.DT, self.DY, self.DX = rope_dim
+        self.theta = theta
+        self.register_buffer("freqs_base_t", self._get_freqs_base(self.DT), persistent=False)
+        self.register_buffer("freqs_base_y", self._get_freqs_base(self.DY), persistent=False)
+        self.register_buffer("freqs_base_x", self._get_freqs_base(self.DX), persistent=False)
+
+    def _get_freqs_base(self, dim):
+        return 1.0 / (self.theta ** (torch.arange(0, dim, 2, dtype=torch.float32)[: (dim // 2)] / dim))
+
+    @torch.no_grad()
+    def get_frequency_batched(self, freqs_base, pos):
+        freqs = torch.einsum("d,bthw->dbthw", freqs_base, pos)
+        freqs = freqs.repeat_interleave(2, dim=0)
+        return freqs.cos(), freqs.sin()
+
+    @torch.no_grad()
+    @lru_cache(maxsize=32)
+    def _get_spatial_meshgrid(self, height, width, device_str):
+        device = torch.device(device_str)
+        grid_y_coords = torch.arange(height, device=device, dtype=torch.float32)
+        grid_x_coords = torch.arange(width, device=device, dtype=torch.float32)
+        grid_y, grid_x = torch.meshgrid(grid_y_coords, grid_x_coords, indexing="ij")
+        return grid_y, grid_x
+
+    @torch.no_grad()
+    def forward(self, frame_indices, height, width, device):
+        batch_size = frame_indices.shape[0]
+        num_frames = frame_indices.shape[1]
+
+        frame_indices = frame_indices.to(device=device, dtype=torch.float32)
+        grid_y, grid_x = self._get_spatial_meshgrid(height, width, str(device))
+
+        grid_t = frame_indices[:, :, None, None].expand(batch_size, num_frames, height, width)
+        grid_y_batch = grid_y[None, None, :, :].expand(batch_size, num_frames, -1, -1)
+        grid_x_batch = grid_x[None, None, :, :].expand(batch_size, num_frames, -1, -1)
+
+        freqs_cos_t, freqs_sin_t = self.get_frequency_batched(self.freqs_base_t, grid_t)
+        freqs_cos_y, freqs_sin_y = self.get_frequency_batched(self.freqs_base_y, grid_y_batch)
+        freqs_cos_x, freqs_sin_x = self.get_frequency_batched(self.freqs_base_x, grid_x_batch)
+
+        result = torch.cat([freqs_cos_t, freqs_cos_y, freqs_cos_x, freqs_sin_t, freqs_sin_y, freqs_sin_x], dim=0)
+
+        return result.permute(1, 0, 2, 3, 4)
+
+
+@maybe_allow_in_graph
+class HeliosTransformerBlock(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        ffn_dim: int,
+        num_heads: int,
+        qk_norm: str = "rms_norm_across_heads",
+        cross_attn_norm: bool = False,
+        eps: float = 1e-6,
+        added_kv_proj_dim: int | None = None,
+        guidance_cross_attn: bool = False,
+        is_amplify_history: bool = False,
+        history_scale_mode: str = "per_head",  # [scalar, per_head]
+    ):
+        super().__init__()
+
+        # 1. Self-attention
+        self.norm1 = FP32LayerNorm(dim, eps, elementwise_affine=False)
+        self.attn1 = HeliosAttention(
+            dim=dim,
+            heads=num_heads,
+            dim_head=dim // num_heads,
+            eps=eps,
+            cross_attention_dim_head=None,
+            processor=HeliosAttnProcessor(),
+            is_amplify_history=is_amplify_history,
+            history_scale_mode=history_scale_mode,
+        )
+
+        # 2. Cross-attention
+        self.attn2 = HeliosAttention(
+            dim=dim,
+            heads=num_heads,
+            dim_head=dim // num_heads,
+            eps=eps,
+            added_kv_proj_dim=added_kv_proj_dim,
+            cross_attention_dim_head=dim // num_heads,
+            processor=HeliosAttnProcessor(),
+        )
+        self.norm2 = FP32LayerNorm(dim, eps, elementwise_affine=True) if cross_attn_norm else nn.Identity()
+
+        # 3. Feed-forward
+        self.ffn = FeedForward(dim, inner_dim=ffn_dim, activation_fn="gelu-approximate")
+        self.norm3 = FP32LayerNorm(dim, eps, elementwise_affine=False)
+
+        self.scale_shift_table = nn.Parameter(torch.randn(1, 6, dim) / dim**0.5)
+
+        # 4. Guidance cross-attention
+        self.guidance_cross_attn = guidance_cross_attn
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        encoder_hidden_states: torch.Tensor,
+        temb: torch.Tensor,
+        rotary_emb: torch.Tensor,
+        original_context_length: int = None,
+    ) -> torch.Tensor:
+        if temb.ndim == 4:
+            shift_msa, scale_msa, gate_msa, c_shift_msa, c_scale_msa, c_gate_msa = (
+                self.scale_shift_table.unsqueeze(0) + temb.float()
+            ).chunk(6, dim=2)
+            # batch_size, seq_len, 1, inner_dim
+            shift_msa = shift_msa.squeeze(2)
+            scale_msa = scale_msa.squeeze(2)
+            gate_msa = gate_msa.squeeze(2)
+            c_shift_msa = c_shift_msa.squeeze(2)
+            c_scale_msa = c_scale_msa.squeeze(2)
+            c_gate_msa = c_gate_msa.squeeze(2)
+        else:
+            shift_msa, scale_msa, gate_msa, c_shift_msa, c_scale_msa, c_gate_msa = (
+                self.scale_shift_table + temb.float()
+            ).chunk(6, dim=1)
+
+        # 1. Self-attention
+        norm_hidden_states = (self.norm1(hidden_states.float()) * (1 + scale_msa) + shift_msa).type_as(hidden_states)
+        attn_output = self.attn1(
+            norm_hidden_states,
+            None,
+            None,
+            rotary_emb,
+            original_context_length,
+        )
+        hidden_states = (hidden_states.float() + attn_output * gate_msa).type_as(hidden_states)
+
+        # 2. Cross-attention
+        if self.guidance_cross_attn:
+            history_seq_len = hidden_states.shape[1] - original_context_length
+
+            history_hidden_states, hidden_states = torch.split(
+                hidden_states, [history_seq_len, original_context_length], dim=1
+            )
+            norm_hidden_states = self.norm2(hidden_states.float()).type_as(hidden_states)
+            attn_output = self.attn2(
+                norm_hidden_states,
+                encoder_hidden_states,
+                None,
+                None,
+                original_context_length,
+            )
+            hidden_states = hidden_states + attn_output
+            hidden_states = torch.cat([history_hidden_states, hidden_states], dim=1)
+        else:
+            norm_hidden_states = self.norm2(hidden_states.float()).type_as(hidden_states)
+            attn_output = self.attn2(
+                norm_hidden_states,
+                encoder_hidden_states,
+                None,
+                None,
+                original_context_length,
+            )
+            hidden_states = hidden_states + attn_output
+
+        # 3. Feed-forward
+        norm_hidden_states = (self.norm3(hidden_states.float()) * (1 + c_scale_msa) + c_shift_msa).type_as(
+            hidden_states
+        )
+        ff_output = self.ffn(norm_hidden_states)
+        hidden_states = (hidden_states.float() + ff_output.float() * c_gate_msa).type_as(hidden_states)
+
+        return hidden_states
+
+
+class HeliosTransformer3DModel(
+    ModelMixin, ConfigMixin, PeftAdapterMixin, FromOriginalModelMixin, CacheMixin, AttentionMixin
+):
+    r"""
+    A Transformer model for video-like data used in the Helios model.
+
+    Args:
+        patch_size (`tuple[int]`, defaults to `(1, 2, 2)`):
+            3D patch dimensions for video embedding (t_patch, h_patch, w_patch).
+        num_attention_heads (`int`, defaults to `40`):
+            Fixed length for text embeddings.
+        attention_head_dim (`int`, defaults to `128`):
+            The number of channels in each head.
+        in_channels (`int`, defaults to `16`):
+            The number of channels in the input.
+        out_channels (`int`, defaults to `16`):
+            The number of channels in the output.
+        text_dim (`int`, defaults to `512`):
+            Input dimension for text embeddings.
+        freq_dim (`int`, defaults to `256`):
+            Dimension for sinusoidal time embeddings.
+        ffn_dim (`int`, defaults to `13824`):
+            Intermediate dimension in feed-forward network.
+        num_layers (`int`, defaults to `40`):
+            The number of layers of transformer blocks to use.
+        window_size (`tuple[int]`, defaults to `(-1, -1)`):
+            Window size for local attention (-1 indicates global attention).
+        cross_attn_norm (`bool`, defaults to `True`):
+            Enable cross-attention normalization.
+        qk_norm (`bool`, defaults to `True`):
+            Enable query/key normalization.
+        eps (`float`, defaults to `1e-6`):
+            Epsilon value for normalization layers.
+        add_img_emb (`bool`, defaults to `False`):
+            Whether to use img_emb.
+        added_kv_proj_dim (`int`, *optional*, defaults to `None`):
+            The number of channels to use for the added key and value projections. If `None`, no projection is used.
+    """
+
+    _supports_gradient_checkpointing = True
+    _skip_layerwise_casting_patterns = [
+        "patch_embedding",
+        "patch_short",
+        "patch_mid",
+        "patch_long",
+        "condition_embedder",
+        "norm",
+    ]
+    _no_split_modules = ["HeliosTransformerBlock", "HeliosOutputNorm"]
+    _keep_in_fp32_modules = [
+        "time_embedder",
+        "scale_shift_table",
+        "norm1",
+        "norm2",
+        "norm3",
+        "history_key_scale",
+    ]
+    _keys_to_ignore_on_load_unexpected = ["norm_added_q"]
+    _repeated_blocks = ["HeliosTransformerBlock"]
+    _cp_plan = {
+        # Input split at attn level and ffn level.
+        "blocks.*.attn1": {
+            "hidden_states": ContextParallelInput(split_dim=1, expected_dims=3, split_output=False),
+            "rotary_emb": ContextParallelInput(split_dim=1, expected_dims=3, split_output=False),
+        },
+        "blocks.*.attn2": {
+            "hidden_states": ContextParallelInput(split_dim=1, expected_dims=3, split_output=False),
+        },
+        "blocks.*.ffn": {
+            "hidden_states": ContextParallelInput(split_dim=1, expected_dims=3, split_output=False),
+        },
+        # Output gather at attn level and ffn level.
+        **{f"blocks.{i}.attn1": ContextParallelOutput(gather_dim=1, expected_dims=3) for i in range(40)},
+        **{f"blocks.{i}.attn2": ContextParallelOutput(gather_dim=1, expected_dims=3) for i in range(40)},
+        **{f"blocks.{i}.ffn": ContextParallelOutput(gather_dim=1, expected_dims=3) for i in range(40)},
+    }
+
+    @register_to_config
+    def __init__(
+        self,
+        patch_size: tuple[int, ...] = (1, 2, 2),
+        num_attention_heads: int = 40,
+        attention_head_dim: int = 128,
+        in_channels: int = 16,
+        out_channels: int = 16,
+        text_dim: int = 4096,
+        freq_dim: int = 256,
+        ffn_dim: int = 13824,
+        num_layers: int = 40,
+        cross_attn_norm: bool = True,
+        qk_norm: str | None = "rms_norm_across_heads",
+        eps: float = 1e-6,
+        added_kv_proj_dim: int | None = None,
+        rope_dim: tuple[int, ...] = (44, 42, 42),
+        rope_theta: float = 10000.0,
+        guidance_cross_attn: bool = True,
+        zero_history_timestep: bool = True,
+        has_multi_term_memory_patch: bool = True,
+        is_amplify_history: bool = False,
+        history_scale_mode: str = "per_head",  # [scalar, per_head]
+    ) -> None:
+        super().__init__()
+
+        inner_dim = num_attention_heads * attention_head_dim
+        out_channels = out_channels or in_channels
+
+        # 1. Patch & position embedding
+        self.rope = HeliosRotaryPosEmbed(rope_dim=rope_dim, theta=rope_theta)
+        self.patch_embedding = nn.Conv3d(in_channels, inner_dim, kernel_size=patch_size, stride=patch_size)
+
+        # 2. Initial Multi Term Memory Patch
+        self.zero_history_timestep = zero_history_timestep
+        self.inner_dim = inner_dim
+        if has_multi_term_memory_patch:
+            self.patch_short = nn.Conv3d(in_channels, self.inner_dim, kernel_size=patch_size, stride=patch_size)
+            self.patch_mid = nn.Conv3d(
+                in_channels,
+                self.inner_dim,
+                kernel_size=tuple(2 * p for p in patch_size),
+                stride=tuple(2 * p for p in patch_size),
+            )
+            self.patch_long = nn.Conv3d(
+                in_channels,
+                self.inner_dim,
+                kernel_size=tuple(4 * p for p in patch_size),
+                stride=tuple(4 * p for p in patch_size),
+            )
+
+        # 3. Condition embeddings
+        self.condition_embedder = HeliosTimeTextEmbedding(
+            dim=inner_dim,
+            time_freq_dim=freq_dim,
+            time_proj_dim=inner_dim * 6,
+            text_embed_dim=text_dim,
+        )
+
+        # 4. Transformer blocks
+        self.blocks = nn.ModuleList(
+            [
+                HeliosTransformerBlock(
+                    inner_dim,
+                    ffn_dim,
+                    num_attention_heads,
+                    qk_norm,
+                    cross_attn_norm,
+                    eps,
+                    added_kv_proj_dim,
+                    guidance_cross_attn=guidance_cross_attn,
+                    is_amplify_history=is_amplify_history,
+                    history_scale_mode=history_scale_mode,
+                )
+                for _ in range(num_layers)
+            ]
+        )
+        self.short_attn_debug_config = None
+        self.short_attn_debug_state = {}
+        self._refresh_short_attn_debug_hooks()
+
+        # 5. Output norm & projection
+        self.norm_out = HeliosOutputNorm(inner_dim, eps, elementwise_affine=False)
+        self.proj_out = nn.Linear(inner_dim, out_channels * math.prod(patch_size))
+
+        self.gradient_checkpointing = False
+
+    def _refresh_short_attn_debug_hooks(self):
+        for block_idx, block in enumerate(self.blocks):
+            block.attn1._helios_block_idx = block_idx
+            block.attn1._short_attn_debug_config = self.short_attn_debug_config
+            block.attn1._short_attn_debug_state = self.short_attn_debug_state
+            block.attn2._short_attn_debug_config = None
+            block.attn2._short_attn_debug_state = None
+
+    def configure_short_attn_debug(self, config: dict[str, Any] | None = None):
+        self.short_attn_debug_config = dict(config) if config else None
+        if self.short_attn_debug_config is not None:
+            self.short_attn_debug_config.setdefault("enabled", True)
+            self.short_attn_debug_config.setdefault("blocks", [30])
+            self.short_attn_debug_config.setdefault("steps", ["last"])
+            self.short_attn_debug_config.setdefault("current_frame", -1)
+            self.short_attn_debug_config.setdefault("prev_short_frame", 1)
+            self.short_attn_debug_config.setdefault("short_history_frames", 2)
+            self.short_attn_debug_config.setdefault("pass_names", ["cond"])
+            self.short_attn_debug_config.setdefault("topk", 2)
+            self.short_attn_debug_config.setdefault("query_chunk_size", 128)
+        self.short_attn_debug_state = {}
+        self._refresh_short_attn_debug_hooks()
+
+    def set_short_attn_debug_context(self, **state):
+        if self.short_attn_debug_config is None:
+            return
+        self.short_attn_debug_state.clear()
+        self.short_attn_debug_state.update(state)
+
+    @apply_lora_scale("attention_kwargs")
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        timestep: torch.LongTensor,
+        encoder_hidden_states: torch.Tensor,
+        # ------------ Stage 1 ------------
+        indices_hidden_states=None,
+        indices_latents_history_short=None,
+        indices_latents_history_mid=None,
+        indices_latents_history_long=None,
+        latents_history_short=None,
+        latents_history_mid=None,
+        latents_history_long=None,
+        return_dict: bool = True,
+        attention_kwargs: dict[str, Any] | None = None,
+    ) -> torch.Tensor | dict[str, torch.Tensor]:
+        # 1. Input
+        batch_size = hidden_states.shape[0]
+        p_t, p_h, p_w = self.config.patch_size
+
+        # 2. Process noisy latents
+        hidden_states = self.patch_embedding(hidden_states)
+        _, _, post_patch_num_frames, post_patch_height, post_patch_width = hidden_states.shape
+
+        if indices_hidden_states is None:
+            indices_hidden_states = torch.arange(0, post_patch_num_frames).unsqueeze(0).expand(batch_size, -1)
+
+        hidden_states = hidden_states.flatten(2).transpose(1, 2)
+        rotary_emb = self.rope(
+            frame_indices=indices_hidden_states,
+            height=post_patch_height,
+            width=post_patch_width,
+            device=hidden_states.device,
+        )
+        rotary_emb = rotary_emb.flatten(2).transpose(1, 2)
+        original_context_length = hidden_states.shape[1]
+
+        # 3. Process short history latents
+        if latents_history_short is not None and indices_latents_history_short is not None:
+            latents_history_short = latents_history_short.to(hidden_states)
+            latents_history_short = self.patch_short(latents_history_short)
+            _, _, _, H1, W1 = latents_history_short.shape
+            latents_history_short = latents_history_short.flatten(2).transpose(1, 2)
+
+            rotary_emb_history_short = self.rope(
+                frame_indices=indices_latents_history_short,
+                height=H1,
+                width=W1,
+                device=latents_history_short.device,
+            )
+            rotary_emb_history_short = rotary_emb_history_short.flatten(2).transpose(1, 2)
+
+            hidden_states = torch.cat([latents_history_short, hidden_states], dim=1)
+            rotary_emb = torch.cat([rotary_emb_history_short, rotary_emb], dim=1)
+
+        # 4. Process mid history latents
+        if latents_history_mid is not None and indices_latents_history_mid is not None:
+            latents_history_mid = latents_history_mid.to(hidden_states)
+            latents_history_mid = pad_for_3d_conv(latents_history_mid, (2, 4, 4))
+            latents_history_mid = self.patch_mid(latents_history_mid)
+            latents_history_mid = latents_history_mid.flatten(2).transpose(1, 2)
+
+            rotary_emb_history_mid = self.rope(
+                frame_indices=indices_latents_history_mid,
+                height=H1,
+                width=W1,
+                device=latents_history_mid.device,
+            )
+            rotary_emb_history_mid = pad_for_3d_conv(rotary_emb_history_mid, (2, 2, 2))
+            rotary_emb_history_mid = center_down_sample_3d(rotary_emb_history_mid, (2, 2, 2))
+            rotary_emb_history_mid = rotary_emb_history_mid.flatten(2).transpose(1, 2)
+
+            hidden_states = torch.cat([latents_history_mid, hidden_states], dim=1)
+            rotary_emb = torch.cat([rotary_emb_history_mid, rotary_emb], dim=1)
+
+        # 5. Process long history latents
+        if latents_history_long is not None and indices_latents_history_long is not None:
+            latents_history_long = latents_history_long.to(hidden_states)
+            latents_history_long = pad_for_3d_conv(latents_history_long, (4, 8, 8))
+            latents_history_long = self.patch_long(latents_history_long)
+            latents_history_long = latents_history_long.flatten(2).transpose(1, 2)
+
+            rotary_emb_history_long = self.rope(
+                frame_indices=indices_latents_history_long,
+                height=H1,
+                width=W1,
+                device=latents_history_long.device,
+            )
+            rotary_emb_history_long = pad_for_3d_conv(rotary_emb_history_long, (4, 4, 4))
+            rotary_emb_history_long = center_down_sample_3d(rotary_emb_history_long, (4, 4, 4))
+            rotary_emb_history_long = rotary_emb_history_long.flatten(2).transpose(1, 2)
+
+            hidden_states = torch.cat([latents_history_long, hidden_states], dim=1)
+            rotary_emb = torch.cat([rotary_emb_history_long, rotary_emb], dim=1)
+
+        history_context_length = hidden_states.shape[1] - original_context_length
+
+        if indices_hidden_states is not None and self.zero_history_timestep:
+            timestep_t0 = torch.zeros((1), dtype=timestep.dtype, device=timestep.device)
+            temb_t0, timestep_proj_t0, _ = self.condition_embedder(
+                timestep_t0, encoder_hidden_states, is_return_encoder_hidden_states=False
+            )
+            temb_t0 = temb_t0.unsqueeze(1).expand(batch_size, history_context_length, -1)
+            timestep_proj_t0 = (
+                timestep_proj_t0.unflatten(-1, (6, -1))
+                .view(1, 6, 1, -1)
+                .expand(batch_size, -1, history_context_length, -1)
+            )
+
+        temb, timestep_proj, encoder_hidden_states = self.condition_embedder(timestep, encoder_hidden_states)
+        timestep_proj = timestep_proj.unflatten(-1, (6, -1))
+
+        if indices_hidden_states is not None and not self.zero_history_timestep:
+            main_repeat_size = hidden_states.shape[1]
+        else:
+            main_repeat_size = original_context_length
+        temb = temb.view(batch_size, 1, -1).expand(batch_size, main_repeat_size, -1)
+        timestep_proj = timestep_proj.view(batch_size, 6, 1, -1).expand(batch_size, 6, main_repeat_size, -1)
+
+        if indices_hidden_states is not None and self.zero_history_timestep:
+            temb = torch.cat([temb_t0, temb], dim=1)
+            timestep_proj = torch.cat([timestep_proj_t0, timestep_proj], dim=2)
+
+        if timestep_proj.ndim == 4:
+            timestep_proj = timestep_proj.permute(0, 2, 1, 3)
+
+        # 6. Transformer blocks
+        hidden_states = hidden_states.contiguous()
+        encoder_hidden_states = encoder_hidden_states.contiguous()
+        rotary_emb = rotary_emb.contiguous()
+        if torch.is_grad_enabled() and self.gradient_checkpointing:
+            for block in self.blocks:
+                hidden_states = self._gradient_checkpointing_func(
+                    block,
+                    hidden_states,
+                    encoder_hidden_states,
+                    timestep_proj,
+                    rotary_emb,
+                    original_context_length,
+                )
+        else:
+            for block in self.blocks:
+                hidden_states = block(
+                    hidden_states,
+                    encoder_hidden_states,
+                    timestep_proj,
+                    rotary_emb,
+                    original_context_length,
+                )
+
+        # 7. Normalization
+        hidden_states = self.norm_out(hidden_states, temb, original_context_length)
+        hidden_states = self.proj_out(hidden_states)
+
+        # 8. Unpatchify
+        hidden_states = hidden_states.reshape(
+            batch_size, post_patch_num_frames, post_patch_height, post_patch_width, p_t, p_h, p_w, -1
+        )
+        hidden_states = hidden_states.permute(0, 7, 1, 4, 2, 5, 3, 6)
+        output = hidden_states.flatten(6, 7).flatten(4, 5).flatten(2, 3)
+
+        if not return_dict:
+            return (output,)
+
+        return Transformer2DModelOutput(sample=output)

Helios/_DEV2/helios/modules/helios_kernels/__init__.py

@@ -0,0 +1,5 @@
+from .attention_dispatch import attn_varlen_func, create_navit_attention_masks
+from .fp32_rmsnorm import replace_rmsnorm_with_fp32
+from .tiled_linear import replace_linear_with_tiled_linear
+from .triton_norm import replace_all_norms_with_flash_norms
+from .triton_rope import replace_rope_with_flash_rope