Helios/_DEV2/infer_helios.py

import importlib
import os


os.environ["HF_ENABLE_PARALLEL_LOADING"] = "yes"
os.environ["HF_PARALLEL_LOADING_WORKERS"] = "8"

import argparse
import time
from pathlib import Path

import pandas as pd
import torch
import torch.distributed as dist
from tqdm import tqdm


if importlib.util.find_spec("torch_npu") is not None:
    import torch_npu
else:
    torch_npu = None

from helios.diffusers_version.pipeline_helios_diffusers import HeliosPipeline
from helios.diffusers_version.scheduling_helios_diffusers import HeliosScheduler
from helios.diffusers_version.transformer_helios_diffusers import HeliosTransformer3DModel
from helios.modules.helios_kernels import (
    replace_all_norms_with_flash_norms,
    replace_rmsnorm_with_fp32,
    replace_rope_with_flash_rope,
)
from helios.utils.utils_base import load_extra_components

from diffusers import ContextParallelConfig
from diffusers.models import AutoencoderKLWan
from diffusers.utils import export_to_video, load_image, load_video

PROJECT_ROOT = Path(__file__).resolve().parent
DEFAULT_BASE_MODEL_PATH = str(PROJECT_ROOT / "checkpoints" / "Helios-Base")


def parse_args():
    parser = argparse.ArgumentParser(description="Generate video with model")

    # === Model paths ===
    parser.add_argument("--base_model_path", type=str, default=DEFAULT_BASE_MODEL_PATH)
    parser.add_argument(
        "--transformer_path",
        type=str,
        default=DEFAULT_BASE_MODEL_PATH,
    )
    parser.add_argument(
        "--lora_path",
        type=str,
        default=None,
    )
    parser.add_argument(
        "--partial_path",
        type=str,
        default=None,
    )
    parser.add_argument("--output_folder", type=str, default="./output_helios")
    parser.add_argument("--enable_compile", action="store_true")

    # === Generation parameters ===
    # environment
    parser.add_argument(
        "--sample_type",
        type=str,
        default="t2v",
        choices=["t2v", "i2v", "v2v"],
    )
    parser.add_argument(
        "--weight_dtype",
        type=str,
        default="bf16",
        choices=["bf16", "fp16", "fp32"],
        help="Data type for model weights.",
    )
    parser.add_argument("--seed", type=int, default=42, help="Seed for random number generator.")
    # base
    parser.add_argument("--height", type=int, default=384)
    parser.add_argument("--width", type=int, default=640)
    parser.add_argument("--num_frames", type=int, default=99)
    parser.add_argument("--fps", type=int, default=24)
    parser.add_argument("--num_inference_steps", type=int, default=50)
    parser.add_argument("--guidance_scale", type=float, default=5.0)
    # cfg zero
    parser.add_argument("--use_zero_init", action="store_true")
    parser.add_argument("--zero_steps", type=int, default=1)
    # stage 1
    parser.add_argument("--num_latent_frames_per_chunk", type=int, default=9)
    # stage 2
    parser.add_argument("--is_enable_stage2", action="store_true")
    parser.add_argument("--pyramid_num_inference_steps_list", type=int, nargs="+", default=[20, 20, 20])
    # stage 3
    parser.add_argument("--is_skip_first_chunk", action="store_true")
    parser.add_argument("--is_amplify_first_chunk", action="store_true")
    parser.add_argument(
        "--visualize_relative_l1",
        action="store_true",
        help="Save per-chunk denoising relative L1 records and a timestep plot.",
    )
    parser.add_argument(
        "--relative_l1_output_folder",
        type=str,
        default=None,
        help="Deprecated. Relative L1 files are saved next to the mp4 in each prompt timestamp folder.",
    )

    # === Prompts ===
    parser.add_argument("--use_interpolate_prompt", action="store_true")
    parser.add_argument("--interpolation_steps", type=int, default=3)
    parser.add_argument("--interpolate_time", type=int, default=7)
    parser.add_argument(
        "--image_path",
        type=str,
        default=None,
    )
    parser.add_argument(
        "--image_noise_sigma_min", type=float, default=0.111, help="Balance motion amplitude and visual consistency"
    )
    parser.add_argument(
        "--image_noise_sigma_max", type=float, default=0.135, help="Balance motion amplitude and visual consistency"
    )
    parser.add_argument(
        "--video_path",
        type=str,
        default=None,
    )
    parser.add_argument(
        "--video_noise_sigma_min", type=float, default=0.111, help="Balance motion amplitude and visual consistency"
    )
    parser.add_argument(
        "--video_noise_sigma_max", type=float, default=0.135, help="Balance motion amplitude and visual consistency"
    )
    parser.add_argument(
        "--prompt",
        type=str,
        default="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.",
    )
    parser.add_argument(
        "--negative_prompt",
        type=str,
        default="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",
    )
    parser.add_argument(
        "--prompt_txt_path",
        type=str,
        default=None,
    )
    parser.add_argument(
        "--base_image_prompt_path",
        type=str,
        default=None,
    )
    parser.add_argument(
        "--image_prompt_csv_path",
        type=str,
        default=None,
    )
    parser.add_argument(
        "--interactive_prompt_csv_path",
        type=str,
        default=None,
    )

    # === Context parallelism ===
    # Please refer to https://huggingface.co/docs/diffusers/main/en/training/distributed_inference#context-parallelism
    parser.add_argument("--enable_parallelism", action="store_true")
    parser.add_argument(
        "--cp_backend",
        type=str,
        choices=["ring", "ulysses", "unified", "ulysses_anything"],
        default="ulysses",
        help="Context parallel backend to use.",
    )

    # === Group-Offloading ===
    # Please refer to https://huggingface.co/docs/diffusers/main/en/optimization/memory#group-offloading
    parser.add_argument("--enable_low_vram_mode", action="store_true")
    parser.add_argument(
        "--group_offloading_type",
        type=str,
        choices=["leaf_level", "block_level"],
        default="leaf_level",
        help="Specifies the granularity for group CPU offloading. Choose between 'leaf_level' (individual modules) or 'block_level' (entire blocks).",
    )
    parser.add_argument(
        "--num_blocks_per_group",
        type=str,
        default="4",
        help="The number of blocks to bundle together in each offloading group. Only relevant when using block-level offloading.",
    )

    return parser.parse_args()


def build_sample_output_dir(output_folder, prompt_or_prompts):
    if isinstance(prompt_or_prompts, list):
        prompt_text = prompt_or_prompts[0] if prompt_or_prompts else "prompt"
    else:
        prompt_text = prompt_or_prompts or "prompt"

    prompt_text = str(prompt_text).strip()
    safe_chars = []
    previous_was_sep = False
    for char in prompt_text:
        if char.isalnum():
            safe_chars.append(char)
            previous_was_sep = False
        elif not previous_was_sep:
            safe_chars.append("_")
            previous_was_sep = True

    prompt_stem = "".join(safe_chars).strip("_")[:80] or "prompt"
    sample_dir = Path(output_folder) / f"{prompt_stem}_{int(time.time())}"

    suffix = 1
    base_sample_dir = sample_dir
    while sample_dir.exists():
        sample_dir = Path(f"{base_sample_dir}_{suffix}")
        suffix += 1

    sample_dir.mkdir(parents=True, exist_ok=False)
    return sample_dir


def save_relative_l1_outputs(records, output_folder):
    if not records:
        print(f"No relative L1 records for {output_folder}.")
        return

    metrics_dir = Path(output_folder)
    metrics_dir.mkdir(parents=True, exist_ok=True)
    df = pd.DataFrame(records).sort_values(["chunk_index", "step_index", "stage_index"])

    csv_path = metrics_dir / "relative_l1.csv"
    df.to_csv(csv_path, index=False)

    try:
        import matplotlib

        matplotlib.use("Agg")
        import matplotlib.pyplot as plt

        def save_metric_plot(metric_name, ylabel, title, plot_name):
            fig, ax = plt.subplots(figsize=(9, 5))
            for chunk_index, chunk_df in df.groupby("chunk_index"):
                chunk_df = chunk_df.sort_values(["step_index", "stage_index"])
                ax.plot(
                    chunk_df["timestep"],
                    chunk_df[metric_name],
                    marker="o",
                    linewidth=1.5,
                    markersize=3,
                    label=f"chunk {chunk_index}",
                )

            ax.set_xlabel("timestep")
            ax.set_ylabel(ylabel)
            ax.set_title(title)
            ax.grid(True, alpha=0.3)
            ax.invert_xaxis()
            ax.legend()
            fig.tight_layout()

            plot_path = metrics_dir / plot_name
            fig.savefig(plot_path, dpi=200)
            plt.close(fig)
            return plot_path

        plot_path = save_metric_plot(
            "relative_l1",
            "mean relative L1",
            "Denoising relative L1 per chunk",
            "relative_l1.png",
        )
        ratio_plot_path = None
        if "relative_l1_ratio" in df.columns:
            ratio_plot_path = save_metric_plot(
                "relative_l1_ratio",
                "mean(delta L1) / mean(latent L1)",
                "Denoising relative L1 ratio per chunk",
                "relative_l1_ratio.png",
            )

        if ratio_plot_path is None:
            print(f"Saved relative L1 CSV to {csv_path} and plot to {plot_path}")
        else:
            print(f"Saved relative L1 CSV to {csv_path} and plots to {plot_path}, {ratio_plot_path}")
    except Exception as exc:
        print(f"Saved relative L1 CSV to {csv_path}, but failed to save plot: {exc}")


def main():
    args = parse_args()

    assert not (args.enable_low_vram_mode and args.enable_compile), (
        "enable_low_vram_mode and enable_compile cannot be used together."
    )

    if args.weight_dtype == "fp32":
        args.weight_dtype = torch.float32
    elif args.weight_dtype == "fp16":
        args.weight_dtype = torch.float16
    else:
        args.weight_dtype = torch.bfloat16

    os.makedirs(args.output_folder, exist_ok=True)

    if dist.is_available() and "RANK" in os.environ:
        if args.cp_backend == "ulysses_anything":
            dist.init_process_group(backend="cpu:gloo,cuda:nccl")
        else:
            dist.init_process_group(backend="nccl")
        rank = dist.get_rank()
        device = torch.device("cuda", rank % torch.cuda.device_count())
        world_size = dist.get_world_size()
        torch.cuda.set_device(device)
        assert world_size == 1 or not args.enable_low_vram_mode, "enable_low_vram_mode is only for single GPU."
    else:
        rank = 0
        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        world_size = 1

    prompt = None
    image_path = None
    video_path = None
    interpolate_time_list = None
    if args.sample_type == "t2v" and args.prompt is None:
        prompt = "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."
    elif args.sample_type == "i2v" and (args.image_path is None and args.prompt is None):
        image_path = (
            "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg"
        )
        prompt = "An astronaut hatching from an egg, on the surface of the moon, the darkness and depth of space realised in the background. High quality, ultrarealistic detail and breath-taking movie-like camera shot."
    elif args.sample_type == "v2v" and (args.video_path is None and args.prompt is None):
        video_path = (
            "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/hiker.mp4"
        )
        prompt = "A robot standing on a mountain top. The sun is setting in the background."
    else:
        image_path = args.image_path
        video_path = args.video_path
        prompt = args.prompt

    transformer = HeliosTransformer3DModel.from_pretrained(
        args.transformer_path,
        subfolder="transformer",
        torch_dtype=args.weight_dtype,
    )
    if not args.enable_compile:
        transformer = replace_rmsnorm_with_fp32(transformer)
        transformer = replace_all_norms_with_flash_norms(transformer)
        replace_rope_with_flash_rope()
    cuda_major = torch.cuda.get_device_capability()[0]
    if cuda_major >= 9:
        # H100/H800 (SM90+) with FA3
        try:
            transformer.set_attention_backend("_flash_3_hub")
        except Exception:
            transformer.set_attention_backend("flash_hub")
    else:
        # 4090/A100 etc (SM89+) with FA2
        transformer.set_attention_backend("flash_hub")

    vae = AutoencoderKLWan.from_pretrained(
        args.base_model_path,
        subfolder="vae",
        torch_dtype=torch.float32,
    )
    scheduler = HeliosScheduler.from_pretrained(
        args.base_model_path,
        subfolder="scheduler",
    )
    pipe = HeliosPipeline.from_pretrained(
        args.base_model_path,
        transformer=transformer,
        vae=vae,
        scheduler=scheduler,
        torch_dtype=args.weight_dtype,
    )

    if args.lora_path is not None:
        pipe.load_lora_weights(args.lora_path, adapter_name="default")
        pipe.set_adapters(["default"], adapter_weights=[1.0])

        if args.partial_path is not None:
            if not hasattr(args, "training_config"):
                from argparse import Namespace

                args.training_config = Namespace()
            args.training_config.is_enable_stage1 = True
            args.training_config.restrict_self_attn = True
            args.training_config.is_amplify_history = True
            args.training_config.is_use_gan = True
            load_extra_components(args, transformer, args.partial_path)

    if args.enable_compile:
        torch.backends.cudnn.benchmark = True
        pipe.text_encoder.compile(mode="max-autotune-no-cudagraphs", dynamic=False)
        pipe.vae.compile(mode="max-autotune-no-cudagraphs", dynamic=False)
        pipe.transformer.compile(mode="max-autotune-no-cudagraphs", dynamic=False)

    if args.enable_low_vram_mode:
        pipe.enable_group_offload(
            onload_device=torch.device("cuda"),
            offload_device=torch.device("cpu"),
            offload_type=args.group_offloading_type,
            num_blocks_per_group=args.num_blocks_per_group if args.group_offloading_type == "block_level" else None,
            use_stream=True,
            record_stream=True,
        )
    else:
        pipe = pipe.to(device)

    if world_size > 1 and args.enable_parallelism:
        if args.cp_backend == "ring":
            cp_config = ContextParallelConfig(ring_degree=world_size)
        elif args.cp_backend == "unified":
            cp_config = ContextParallelConfig(ring_degree=world_size // 2, ulysses_degree=world_size // 2)
        elif args.cp_backend == "ulysses":
            cp_config = ContextParallelConfig(ulysses_degree=world_size)
        elif args.cp_backend == "ulysses_anything":
            cp_config = ContextParallelConfig(ulysses_degree=world_size, ulysses_anything=True)
        else:
            raise ValueError(f"Unsupported cp_backend: {args.cp_backend}")

        pipe.transformer.enable_parallelism(config=cp_config)

    if args.prompt_txt_path is not None:
        with open(args.prompt_txt_path, "r") as f:
            prompt_list = [line.strip() for line in f.readlines() if line.strip()]
        if not args.enable_parallelism:
            prompt_list_with_idx = [(i, prompt) for i, prompt in enumerate(prompt_list)]
            prompt_list_with_idx = prompt_list_with_idx[rank::world_size]
        else:
            prompt_list_with_idx = [(i, prompt) for i, prompt in enumerate(prompt_list)]

        for idx, prompt in tqdm(prompt_list_with_idx, desc="Processing prompts"):
            with torch.no_grad():
                try:
                    pipe_output = pipe(
                        prompt=prompt,
                        negative_prompt=args.negative_prompt,
                        height=args.height,
                        width=args.width,
                        num_frames=args.num_frames,
                        num_inference_steps=args.num_inference_steps,
                        guidance_scale=args.guidance_scale,
                        generator=torch.Generator(device="cuda").manual_seed(args.seed),
                        # stage 1
                        history_sizes=[16, 2, 1],
                        num_latent_frames_per_chunk=args.num_latent_frames_per_chunk,
                        keep_first_frame=True,
                        # stage 2
                        is_enable_stage2=args.is_enable_stage2,
                        pyramid_num_inference_steps_list=args.pyramid_num_inference_steps_list,
                        # stage 3
                        is_skip_first_chunk=args.is_skip_first_chunk,
                        is_amplify_first_chunk=args.is_amplify_first_chunk,
                        # cfg zero
                        use_zero_init=args.use_zero_init,
                        zero_steps=args.zero_steps,
                        # i2v
                        image=load_image(image_path).resize((args.width, args.height))
                        if image_path is not None
                        else None,
                        image_noise_sigma_min=args.image_noise_sigma_min,
                        image_noise_sigma_max=args.image_noise_sigma_max,
                        # v2v
                        video=load_video(video_path) if video_path is not None else None,
                        video_noise_sigma_min=args.video_noise_sigma_min,
                        video_noise_sigma_max=args.video_noise_sigma_max,
                        # interpolate_prompt
                        use_interpolate_prompt=args.use_interpolate_prompt,
                        interpolation_steps=args.interpolation_steps,
                        interpolate_time_list=interpolate_time_list,
                        output_relative_l1=args.visualize_relative_l1,
                    )
                    output = pipe_output.frames[0]
                except Exception:
                    continue
            if not args.enable_parallelism or rank == 0:
                sample_dir = build_sample_output_dir(args.output_folder, prompt)
                output_path = sample_dir / "video.mp4"
                export_to_video(output, str(output_path), fps=24)
                if args.visualize_relative_l1:
                    save_relative_l1_outputs(pipe_output.relative_l1, sample_dir)
    elif args.image_prompt_csv_path is not None:
        df = pd.read_csv(args.image_prompt_csv_path)
        if not args.enable_parallelism:
            df = df.iloc[rank::world_size]

        for idx, row in tqdm(df.iterrows(), total=len(df), desc="Processing prompts"):
            prompt = row.get("refined_prompt") or row["prompt"]
            image_path = os.path.join(args.base_image_prompt_path, row["image_name"])

            with torch.no_grad():
                try:
                    pipe_output = pipe(
                        prompt=prompt,
                        negative_prompt=args.negative_prompt,
                        height=args.height,
                        width=args.width,
                        num_frames=args.num_frames,
                        num_inference_steps=args.num_inference_steps,
                        guidance_scale=args.guidance_scale,
                        generator=torch.Generator(device="cuda").manual_seed(args.seed),
                        # stage 1
                        history_sizes=[16, 2, 1],
                        num_latent_frames_per_chunk=args.num_latent_frames_per_chunk,
                        keep_first_frame=True,
                        # stage 2
                        is_enable_stage2=args.is_enable_stage2,
                        pyramid_num_inference_steps_list=args.pyramid_num_inference_steps_list,
                        # stage 3
                        is_skip_first_chunk=args.is_skip_first_chunk,
                        is_amplify_first_chunk=args.is_amplify_first_chunk,
                        # cfg zero
                        use_zero_init=args.use_zero_init,
                        zero_steps=args.zero_steps,
                        # i2v
                        image=load_image(image_path).resize((args.width, args.height))
                        if image_path is not None
                        else None,
                        image_noise_sigma_min=args.image_noise_sigma_min,
                        image_noise_sigma_max=args.image_noise_sigma_max,
                        # v2v
                        video=load_video(video_path) if video_path is not None else None,
                        video_noise_sigma_min=args.video_noise_sigma_min,
                        video_noise_sigma_max=args.video_noise_sigma_max,
                        # interpolate_prompt
                        use_interpolate_prompt=args.use_interpolate_prompt,
                        interpolation_steps=args.interpolation_steps,
                        interpolate_time_list=interpolate_time_list,
                        output_relative_l1=args.visualize_relative_l1,
                    )
                    output = pipe_output.frames[0]
                except Exception:
                    continue
            if not args.enable_parallelism or rank == 0:
                sample_dir = build_sample_output_dir(args.output_folder, prompt)
                output_path = sample_dir / "video.mp4"
                export_to_video(output, str(output_path), fps=24)
                if args.visualize_relative_l1:
                    save_relative_l1_outputs(pipe_output.relative_l1, sample_dir)
    elif args.interactive_prompt_csv_path is not None:
        df = pd.read_csv(args.interactive_prompt_csv_path)

        df = df.sort_values(by=["id", "prompt_index"])
        all_video_ids = df["id"].unique()

        if not args.enable_parallelism:
            my_video_ids = all_video_ids[rank::world_size]
        else:
            my_video_ids = all_video_ids

        for video_id in tqdm(my_video_ids, desc="Processing prompts"):
            group_df = df[df["id"] == video_id]

            if "refined_prompt" in df.columns:
                prompt_list = group_df["refined_prompt"].fillna(group_df["prompt"]).tolist()
            else:
                prompt_list = group_df["prompt"].tolist()
            interpolate_time_list = [args.interpolate_time] * len(prompt_list)

            with torch.no_grad():
                try:
                    pipe_output = pipe(
                        prompt=prompt_list,
                        negative_prompt=args.negative_prompt,
                        height=args.height,
                        width=args.width,
                        num_frames=args.num_frames,
                        num_inference_steps=args.num_inference_steps,
                        guidance_scale=args.guidance_scale,
                        generator=torch.Generator(device="cuda").manual_seed(args.seed),
                        # stage 1
                        history_sizes=[16, 2, 1],
                        num_latent_frames_per_chunk=args.num_latent_frames_per_chunk,
                        keep_first_frame=True,
                        # stage 2
                        is_enable_stage2=args.is_enable_stage2,
                        pyramid_num_inference_steps_list=args.pyramid_num_inference_steps_list,
                        # stage 3
                        is_skip_first_chunk=args.is_skip_first_chunk,
                        is_amplify_first_chunk=args.is_amplify_first_chunk,
                        # cfg zero
                        use_zero_init=args.use_zero_init,
                        zero_steps=args.zero_steps,
                        # i2v
                        image=load_image(image_path).resize((args.width, args.height))
                        if image_path is not None
                        else None,
                        image_noise_sigma_min=args.image_noise_sigma_min,
                        image_noise_sigma_max=args.image_noise_sigma_max,
                        # v2v
                        video=load_video(video_path) if video_path is not None else None,
                        video_noise_sigma_min=args.video_noise_sigma_min,
                        video_noise_sigma_max=args.video_noise_sigma_max,
                        # interpolate_prompt
                        use_interpolate_prompt=args.use_interpolate_prompt,
                        interpolation_steps=args.interpolation_steps,
                        interpolate_time_list=interpolate_time_list,
                        output_relative_l1=args.visualize_relative_l1,
                    )
                    output = pipe_output.frames[0]
                except Exception:
                    continue
            if not args.enable_parallelism or rank == 0:
                sample_dir = build_sample_output_dir(args.output_folder, prompt_list)
                output_path = sample_dir / "video.mp4"
                export_to_video(output, str(output_path), fps=24)
                if args.visualize_relative_l1:
                    save_relative_l1_outputs(pipe_output.relative_l1, sample_dir)
    else:
        with torch.no_grad():
            # import time
            # for _ in range(20):
            #     start_time = time.time()
            pipe_output = pipe(
                prompt=prompt,
                negative_prompt=args.negative_prompt,
                height=args.height,
                width=args.width,
                num_frames=args.num_frames,
                num_inference_steps=args.num_inference_steps,
                guidance_scale=args.guidance_scale,
                generator=torch.Generator(device="cuda").manual_seed(args.seed),
                # stage 1
                history_sizes=[16, 2, 1],
                num_latent_frames_per_chunk=args.num_latent_frames_per_chunk,
                keep_first_frame=True,
                # stage 2
                is_enable_stage2=args.is_enable_stage2,
                pyramid_num_inference_steps_list=args.pyramid_num_inference_steps_list,
                # stage 3
                is_skip_first_chunk=args.is_skip_first_chunk,
                is_amplify_first_chunk=args.is_amplify_first_chunk,
                # cfg zero
                use_zero_init=args.use_zero_init,
                zero_steps=args.zero_steps,
                # i2v
                image=load_image(image_path).resize((args.width, args.height)) if image_path is not None else None,
                image_noise_sigma_min=args.image_noise_sigma_min,
                image_noise_sigma_max=args.image_noise_sigma_max,
                # v2v
                video=load_video(video_path) if video_path is not None else None,
                video_noise_sigma_min=args.video_noise_sigma_min,
                video_noise_sigma_max=args.video_noise_sigma_max,
                # interpolate_prompt
                use_interpolate_prompt=args.use_interpolate_prompt,
                interpolation_steps=args.interpolation_steps,
                interpolate_time_list=interpolate_time_list,
                output_relative_l1=args.visualize_relative_l1,
            )
            output = pipe_output.frames[0]
            # elapsed_time = time.time() - start_time
            # print(f"Inference time: {elapsed_time:.2f} seconds ({elapsed_time/60:.2f} minutes)")

        if not args.enable_parallelism or rank == 0:
            sample_dir = build_sample_output_dir(args.output_folder, prompt)
            output_path = sample_dir / "video.mp4"
            export_to_video(output, str(output_path), fps=24)
            if args.visualize_relative_l1:
                save_relative_l1_outputs(pipe_output.relative_l1, sample_dir)

    print(f"Max memory: {torch.cuda.max_memory_allocated() / 1024**3:.3f} GB")


if __name__ == "__main__":
    main()