first commit

README.md

@@ -1,5 +1,5 @@
 ---
-title: Cosmos Transfer1
+title: Cosmos Transfer1 AV
 emoji: 🦀
 colorFrom: yellow
 colorTo: gray

app.py

@@ -0,0 +1,331 @@
+import os
+from typing import List, Tuple
+
+PWD = os.path.dirname(__file__)
+
+import subprocess
+
+subprocess.run("pip install flash-attn --no-build-isolation", env={"FLASH_ATTENTION_SKIP_CUDA_BUILD": "TRUE"}, shell=True)
+
+try:
+    import os
+
+    from huggingface_hub import login
+
+    # Try to login with token from environment variable
+    hf_token = os.environ["HF_TOKEN"]
+    if hf_token:
+        login(token=hf_token)
+        print("✅ Authenticated with Hugging Face")
+    else:
+        print("No HF_TOKEN found, trying without authentication...")
+except Exception as e:
+    print(f"Authentication failed: {e}")
+
+# download checkpoints
+from download_checkpoints import main as download_checkpoints
+
+os.makedirs("./checkpoints", exist_ok=True)
+download_checkpoints(hf_token="", output_dir="./checkpoints", model="7b_av")
+
+os.environ["TOKENIZERS_PARALLELISM"] = "false"  # Workaround to suppress MP warning
+
+import copy
+import json
+import random
+from io import BytesIO
+
+import gradio as gr
+import torch
+from cosmos_transfer1.checkpoints import (
+    BASE_7B_CHECKPOINT_AV_SAMPLE_PATH,
+    BASE_7B_CHECKPOINT_PATH,
+    EDGE2WORLD_CONTROLNET_DISTILLED_CHECKPOINT_PATH,
+)
+from cosmos_transfer1.diffusion.inference.inference_utils import (
+    validate_controlnet_specs,
+)
+from cosmos_transfer1.diffusion.inference.preprocessors import Preprocessors
+from cosmos_transfer1.diffusion.inference.world_generation_pipeline import (
+    DiffusionControl2WorldGenerationPipeline,
+    DistilledControl2WorldGenerationPipeline,
+)
+from cosmos_transfer1.utils import log, misc
+from cosmos_transfer1.utils.io import read_prompts_from_file, save_video
+
+from helper import parse_arguments
+
+torch.enable_grad(False)
+torch.serialization.add_safe_globals([BytesIO])
+
+
+def inference(cfg, control_inputs) -> Tuple[List[str], List[str]]:
+    video_paths = []
+    prompt_paths = []
+
+    control_inputs = validate_controlnet_specs(cfg, control_inputs)
+    misc.set_random_seed(cfg.seed)
+
+    device_rank = 0
+    process_group = None
+    if cfg.num_gpus > 1:
+        from cosmos_transfer1.utils import distributed
+        from megatron.core import parallel_state
+
+        distributed.init()
+        parallel_state.initialize_model_parallel(context_parallel_size=cfg.num_gpus)
+        process_group = parallel_state.get_context_parallel_group()
+
+        device_rank = distributed.get_rank(process_group)
+
+    preprocessors = Preprocessors()
+
+    if cfg.use_distilled:
+        assert not cfg.is_av_sample
+        checkpoint = EDGE2WORLD_CONTROLNET_DISTILLED_CHECKPOINT_PATH
+        pipeline = DistilledControl2WorldGenerationPipeline(
+            checkpoint_dir=cfg.checkpoint_dir,
+            checkpoint_name=checkpoint,
+            offload_network=cfg.offload_diffusion_transformer,
+            offload_text_encoder_model=cfg.offload_text_encoder_model,
+            offload_guardrail_models=cfg.offload_guardrail_models,
+            guidance=cfg.guidance,
+            num_steps=cfg.num_steps,
+            fps=cfg.fps,
+            seed=cfg.seed,
+            num_input_frames=cfg.num_input_frames,
+            control_inputs=control_inputs,
+            sigma_max=cfg.sigma_max,
+            blur_strength=cfg.blur_strength,
+            canny_threshold=cfg.canny_threshold,
+            upsample_prompt=cfg.upsample_prompt,
+            offload_prompt_upsampler=cfg.offload_prompt_upsampler,
+            process_group=process_group,
+        )
+    else:
+        checkpoint = BASE_7B_CHECKPOINT_AV_SAMPLE_PATH if cfg.is_av_sample else BASE_7B_CHECKPOINT_PATH
+
+        # Initialize transfer generation model pipeline
+        pipeline = DiffusionControl2WorldGenerationPipeline(
+            checkpoint_dir=cfg.checkpoint_dir,
+            checkpoint_name=checkpoint,
+            offload_network=cfg.offload_diffusion_transformer,
+            offload_text_encoder_model=cfg.offload_text_encoder_model,
+            offload_guardrail_models=cfg.offload_guardrail_models,
+            guidance=cfg.guidance,
+            num_steps=cfg.num_steps,
+            fps=cfg.fps,
+            seed=cfg.seed,
+            num_input_frames=cfg.num_input_frames,
+            control_inputs=control_inputs,
+            sigma_max=cfg.sigma_max,
+            blur_strength=cfg.blur_strength,
+            canny_threshold=cfg.canny_threshold,
+            upsample_prompt=cfg.upsample_prompt,
+            offload_prompt_upsampler=cfg.offload_prompt_upsampler,
+            process_group=process_group,
+        )
+
+    if cfg.batch_input_path:
+        log.info(f"Reading batch inputs from path: {cfg.batch_input_path}")
+        prompts = read_prompts_from_file(cfg.batch_input_path)
+    else:
+        # Single prompt case
+        prompts = [{"prompt": cfg.prompt, "visual_input": cfg.input_video_path}]
+
+    batch_size = cfg.batch_size if hasattr(cfg, "batch_size") else 1
+    if any("upscale" in control_input for control_input in control_inputs) and batch_size > 1:
+        batch_size = 1
+        log.info("Setting batch_size=1 as upscale does not support batch generation")
+    os.makedirs(cfg.video_save_folder, exist_ok=True)
+    for batch_start in range(0, len(prompts), batch_size):
+        # Get current batch
+        batch_prompts = prompts[batch_start : batch_start + batch_size]
+        actual_batch_size = len(batch_prompts)
+        # Extract batch data
+        batch_prompt_texts = [p.get("prompt", None) for p in batch_prompts]
+        batch_video_paths = [p.get("visual_input", None) for p in batch_prompts]
+
+        batch_control_inputs = []
+        for i, input_dict in enumerate(batch_prompts):
+            current_prompt = input_dict.get("prompt", None)
+            current_video_path = input_dict.get("visual_input", None)
+
+            if cfg.batch_input_path:
+                video_save_subfolder = os.path.join(cfg.video_save_folder, f"video_{batch_start+i}")
+                os.makedirs(video_save_subfolder, exist_ok=True)
+            else:
+                video_save_subfolder = cfg.video_save_folder
+
+            current_control_inputs = copy.deepcopy(control_inputs)
+            if "control_overrides" in input_dict:
+                for hint_key, override in input_dict["control_overrides"].items():
+                    if hint_key in current_control_inputs:
+                        current_control_inputs[hint_key].update(override)
+                    else:
+                        log.warning(f"Ignoring unknown control key in override: {hint_key}")
+
+            # if control inputs are not provided, run respective preprocessor (for seg and depth)
+            log.info("running preprocessor")
+            preprocessors(
+                current_video_path,
+                current_prompt,
+                current_control_inputs,
+                video_save_subfolder,
+                cfg.regional_prompts if hasattr(cfg, "regional_prompts") else None,
+            )
+            batch_control_inputs.append(current_control_inputs)
+
+        regional_prompts = []
+        region_definitions = []
+        if hasattr(cfg, "regional_prompts") and cfg.regional_prompts:
+            log.info(f"regional_prompts: {cfg.regional_prompts}")
+            for regional_prompt in cfg.regional_prompts:
+                regional_prompts.append(regional_prompt["prompt"])
+                if "region_definitions_path" in regional_prompt:
+                    log.info(f"region_definitions_path: {regional_prompt['region_definitions_path']}")
+                    region_definition_path = regional_prompt["region_definitions_path"]
+                    if isinstance(region_definition_path, str) and region_definition_path.endswith(".json"):
+                        with open(region_definition_path, "r") as f:
+                            region_definitions_json = json.load(f)
+                        region_definitions.extend(region_definitions_json)
+                    else:
+                        region_definitions.append(region_definition_path)
+
+        if hasattr(pipeline, "regional_prompts"):
+            pipeline.regional_prompts = regional_prompts
+        if hasattr(pipeline, "region_definitions"):
+            pipeline.region_definitions = region_definitions
+
+        # Generate videos in batch
+        batch_outputs = pipeline.generate(
+            prompt=batch_prompt_texts,
+            video_path=batch_video_paths,
+            negative_prompt=cfg.negative_prompt,
+            control_inputs=batch_control_inputs,
+            save_folder=video_save_subfolder,
+            batch_size=actual_batch_size,
+        )
+        if batch_outputs is None:
+            log.critical("Guardrail blocked generation for entire batch.")
+            continue
+
+        videos, final_prompts = batch_outputs
+        for i, (video, prompt) in enumerate(zip(videos, final_prompts)):
+            if cfg.batch_input_path:
+                video_save_subfolder = os.path.join(cfg.video_save_folder, f"video_{batch_start+i}")
+                video_save_path = os.path.join(video_save_subfolder, "output.mp4")
+                prompt_save_path = os.path.join(video_save_subfolder, "prompt.txt")
+            else:
+                video_save_path = os.path.join(cfg.video_save_folder, f"{cfg.video_save_name}.mp4")
+                prompt_save_path = os.path.join(cfg.video_save_folder, f"{cfg.video_save_name}.txt")
+            # Save video and prompt
+            if device_rank == 0:
+                os.makedirs(os.path.dirname(video_save_path), exist_ok=True)
+                save_video(
+                    video=video,
+                    fps=cfg.fps,
+                    H=video.shape[1],
+                    W=video.shape[2],
+                    video_save_quality=5,
+                    video_save_path=video_save_path,
+                )
+                video_paths.append(video_save_path)
+
+                # Save prompt to text file alongside video
+                with open(prompt_save_path, "wb") as f:
+                    f.write(prompt.encode("utf-8"))
+
+                prompt_paths.append(prompt_save_path)
+
+                log.info(f"Saved video to {video_save_path}")
+                log.info(f"Saved prompt to {prompt_save_path}")
+
+    # clean up properly
+    if cfg.num_gpus > 1:
+        parallel_state.destroy_model_parallel()
+        import torch.distributed as dist
+
+        dist.destroy_process_group()
+
+    return video_paths, prompt_paths
+
+
+def generate_video(
+    hdmap_video_input,
+    lidar_video_input,
+    prompt,
+    negative_prompt="The video captures a series of frames showing ugly scenes, static with no motion, motion blur, over-saturation, shaky footage, low resolution, grainy texture, pixelated images, poorly lit areas, underexposed and overexposed scenes, poor color balance, washed out colors, choppy sequences, jerky movements, low frame rate, artifacting, color banding, unnatural transitions, outdated special effects, fake elements, unconvincing visuals, poorly edited content, jump cuts, visual noise, and flickering. Overall, the video is of poor quality.",  # noqa: E501
+    seed=42,
+    randomize_seed=False,
+    progress=gr.Progress(track_tqdm=True),
+):
+    if randomize_seed:
+        actual_seed = random.randint(0, 1000000)
+    else:
+        actual_seed = seed
+
+    args, control_inputs = parse_arguments(
+        controlnet_specs_in={
+            "hdmap": {"control_weight": 0.3, "input_control": hdmap_video_input},
+            "lidar": {"control_weight": 0.7, "input_control": lidar_video_input},
+        },
+        checkpoint_dir="./cosmos-transfer1/checkpoints",
+        prompt=prompt,
+        negative_prompt=negative_prompt,
+        sigma_max=80,
+        offload_text_encoder_model=True,
+        is_av_sample=True,
+        num_gpus=1,
+        seed=seed,
+    )
+    videos, prompts = inference(args, control_inputs)
+
+    video = videos[0]
+    return video, video, actual_seed
+
+
+# Define the Gradio Blocks interface
+with gr.Blocks() as demo:
+    gr.Markdown(
+        """
+        # Cosmos-Transfer1-7B-Sample-AV
+        """
+    )
+    with gr.Row():
+        with gr.Column():
+            hdmap_input = gr.Video(label="Input HD Map Video", format="mp4")
+            lidar_input = gr.Video(label="Input LiDAR Video", format="mp4")
+
+            prompt_input = gr.Textbox(
+                label="Prompt",
+                lines=5,
+                value="A close-up shot captures a vibrant yellow scrubber vigorously working on a grimy plate, its bristles moving in circular motions to lift stubborn grease and food residue. The dish, once covered in remnants of a hearty meal, gradually reveals its original glossy surface. Suds form and bubble around the scrubber, creating a satisfying visual of cleanliness in progress. The sound of scrubbing fills the air, accompanied by the gentle clinking of the dish against the sink. As the scrubber continues its task, the dish transforms, gleaming under the bright kitchen lights, symbolizing the triumph of cleanliness over mess.",  # noqa: E501
+                placeholder="Enter your descriptive prompt here...",
+            )
+
+            negative_prompt_input = gr.Textbox(
+                label="Negative Prompt",
+                lines=3,
+                value="The video captures a series of frames showing ugly scenes, static with no motion, motion blur, over-saturation, shaky footage, low resolution, grainy texture, pixelated images, poorly lit areas, underexposed and overexposed scenes, poor color balance, washed out colors, choppy sequences, jerky movements, low frame rate, artifacting, color banding, unnatural transitions, outdated special effects, fake elements, unconvincing visuals, poorly edited content, jump cuts, visual noise, and flickering. Overall, the video is of poor quality.",  # noqa: E501
+                placeholder="Enter what you DON'T want to see in the image...",
+            )
+
+            with gr.Row():
+                randomize_seed_checkbox = gr.Checkbox(label="Randomize Seed", value=True)
+                seed_input = gr.Slider(minimum=0, maximum=1000000, value=1, step=1, label="Seed")
+
+            generate_button = gr.Button("Generate Image")
+
+        with gr.Column():
+            output_video = gr.Video(label="Generated Video", format="mp4")
+            output_file = gr.File(label="Download Video")
+
+    generate_button.click(
+        fn=generate_video,
+        inputs=[hdmap_input, lidar_input, prompt_input, negative_prompt_input, seed_input, randomize_seed_checkbox],
+        outputs=[output_video, output_file, seed_input],
+    )
+
+if __name__ == "__main__":
+    demo.launch()

download_checkpoints.py

@@ -0,0 +1,120 @@
+import hashlib
+import os
+import pathlib
+from typing import Literal
+
+# Import the checkpoint paths
+from cosmos_transfer1 import checkpoints
+from cosmos_transfer1.utils import log
+from huggingface_hub import login, snapshot_download
+
+
+def download_checkpoint(checkpoint: str, output_dir: str) -> None:
+    """Download a single checkpoint from HuggingFace Hub."""
+    try:
+        # Parse the checkpoint path to get repo_id and filename
+        checkpoint, revision = checkpoint.split(":") if ":" in checkpoint else (checkpoint, None)
+        checkpoint_dir = os.path.join(output_dir, checkpoint)
+        if get_md5_checksum(output_dir, checkpoint):
+            log.warning(f"Checkpoint {checkpoint_dir} EXISTS, skipping download... ")
+            return
+        else:
+            print(f"Downloading {checkpoint} to {checkpoint_dir}")
+        # Create the output directory if it doesn't exist
+        os.makedirs(checkpoint_dir, exist_ok=True)
+        print(f"Downloading {checkpoint}...")
+        # Download the files
+        snapshot_download(repo_id=checkpoint, local_dir=checkpoint_dir, revision=revision)
+        print(f"Successfully downloaded {checkpoint}")
+
+    except Exception as e:
+        print(f"Error downloading {checkpoint}: {str(e)}")
+
+
+MD5_CHECKSUM_LOOKUP = {
+    f"{checkpoints.GROUNDING_DINO_MODEL_CHECKPOINT}/pytorch_model.bin": "0fcf0d965ca9baec14bb1607005e2512",
+    f"{checkpoints.GROUNDING_DINO_MODEL_CHECKPOINT}/model.safetensors": "0739b040bb51f92464b4cd37f23405f9",
+    f"{checkpoints.T5_MODEL_CHECKPOINT}/pytorch_model.bin": "f890878d8a162e0045a25196e27089a3",
+    f"{checkpoints.T5_MODEL_CHECKPOINT}/tf_model.h5": "e081fc8bd5de5a6a9540568241ab8973",
+    f"{checkpoints.SAM2_MODEL_CHECKPOINT}/sam2_hiera_large.pt": "08083462423be3260cd6a5eef94dc01c",
+    f"{checkpoints.DEPTH_ANYTHING_MODEL_CHECKPOINT}/model.safetensors": "14e97d7ed2146d548c873623cdc965de",
+    checkpoints.BASE_7B_CHECKPOINT_AV_SAMPLE_PATH: "2006e158f8a17a3b801c661f0c01e9f2",
+    checkpoints.HDMAP2WORLD_CONTROLNET_7B_CHECKPOINT_PATH: "2ddd781560d221418c2ed9258b6ca829",
+    checkpoints.LIDAR2WORLD_CONTROLNET_7B_CHECKPOINT_PATH: "184beee5414bcb6c0c5c0f09d8f8b481",
+    checkpoints.UPSCALER_CONTROLNET_7B_CHECKPOINT_PATH: "b28378d13f323b49445dc469dfbbc317",
+    checkpoints.BASE_7B_CHECKPOINT_PATH: "356497b415f3b0697f8bb034d22b6807",
+    checkpoints.VIS2WORLD_CONTROLNET_7B_CHECKPOINT_PATH: "69fdffc5006bc5d6acb29449bb3ffdca",
+    checkpoints.EDGE2WORLD_CONTROLNET_7B_CHECKPOINT_PATH: "a0642e300e9e184077d875e1b5920a61",
+    checkpoints.DEPTH2WORLD_CONTROLNET_7B_CHECKPOINT_PATH: "80999ed60d89a8dfee785c544e0ccd54",
+    checkpoints.SEG2WORLD_CONTROLNET_7B_CHECKPOINT_PATH: "3e4077a80c836bf102c7b2ac2cd5da8c",
+    checkpoints.KEYPOINT2WORLD_CONTROLNET_7B_CHECKPOINT_PATH: "26619fb1686cff0e69606a9c97cac68e",
+    "nvidia/Cosmos-Tokenize1-CV8x8x8-720p/autoencoder.jit": "7f658580d5cf617ee1a1da85b1f51f0d",
+    "nvidia/Cosmos-Tokenize1-CV8x8x8-720p/decoder.jit": "ff21a63ed817ffdbe4b6841111ec79a8",
+    "nvidia/Cosmos-Tokenize1-CV8x8x8-720p/encoder.jit": "f5834d03645c379bc0f8ad14b9bc0299",
+    f"{checkpoints.COSMOS_UPSAMPLER_CHECKPOINT}/consolidated.safetensors": "d06e6366e003126dcb351ce9b8bf3701",
+    f"{checkpoints.COSMOS_GUARDRAIL_CHECKPOINT}/video_content_safety_filter/safety_filter.pt": "b46dc2ad821fc3b0d946549d7ade19cf",
+    f"{checkpoints.LLAMA_GUARD_3_MODEL_CHECKPOINT}/model-00001-of-00004.safetensors": "5748060ae47b335dc19263060c921a54",
+    checkpoints.SV2MV_t2w_HDMAP2WORLD_CONTROLNET_7B_CHECKPOINT_PATH: "4f8a4340d48ebedaa9e7bab772e0203d",
+    checkpoints.SV2MV_v2w_HDMAP2WORLD_CONTROLNET_7B_CHECKPOINT_PATH: "89b82db1bc1dc859178154f88b6ca0f2",
+    checkpoints.SV2MV_t2w_LIDAR2WORLD_CONTROLNET_7B_CHECKPOINT_PATH: "a9592d232a7e5f7971f39918c18eaae0",
+    checkpoints.SV2MV_v2w_LIDAR2WORLD_CONTROLNET_7B_CHECKPOINT_PATH: "cb27af88ec7fb425faec32f4734d99cf",
+    checkpoints.BASE_t2w_7B_SV2MV_CHECKPOINT_AV_SAMPLE_PATH: "a3fb13e8418d8bb366b58e4092bd91df",
+    checkpoints.BASE_v2w_7B_SV2MV_CHECKPOINT_AV_SAMPLE_PATH: "48b2080ca5be66c05fac44dea4989a04",
+}
+
+
+def get_md5_checksum(output_dir, model_name):
+    print("---------------------")
+    for key, value in MD5_CHECKSUM_LOOKUP.items():
+        if key.startswith(model_name):
+            print(f"Verifying checkpoint {key}...")
+            file_path = os.path.join(output_dir, key)
+            # File must exist
+            if not pathlib.Path(file_path).exists():
+                print(f"Checkpoint {key} does not exist.")
+                return False
+            # File must match give MD5 checksum
+            with open(file_path, "rb") as f:
+                file_md5 = hashlib.md5(f.read()).hexdigest()
+            if file_md5 != value:
+                print(f"MD5 checksum of checkpoint {key} does not match.")
+                return False
+    return True
+
+
+def main(hf_token: str = os.environ.get("HF_TOKEN"), output_dir: str = "./checkpoints", model: Literal["all", "7b", "7b_av"] = "all"):
+    """
+    Download checkpoints from HuggingFace Hub
+
+    :param str hf_token: HuggingFace token
+    :param str output_dir: Directory to store the downloaded checkpoints
+    :param str model: Model type to download
+    """
+
+    if hf_token:
+        login(token=hf_token)
+
+    checkpoint_vars = []
+    # Get all variables from the checkpoints module
+    for name in dir(checkpoints):
+        obj = getattr(checkpoints, name)
+        if isinstance(obj, str) and "CHECKPOINT" in name and "PATH" not in name:
+            if model != "all" and name in [
+                "COSMOS_TRANSFER1_7B_CHECKPOINT",
+                "COSMOS_TRANSFER1_7B_SAMPLE_AV_CHECKPOINT",
+            ]:
+                if model == "7b" and name == "COSMOS_TRANSFER1_7B_CHECKPOINT":
+                    checkpoint_vars.append(obj)
+                elif model == "7b_av" and name in [
+                    "COSMOS_TRANSFER1_7B_SAMPLE_AV_CHECKPOINT",
+                    "COSMOS_TRANSFER1_7B_MV_SAMPLE_AV_CHECKPOINT",
+                ]:
+                    checkpoint_vars.append(obj)
+            else:
+                checkpoint_vars.append(obj)
+
+    print(f"Found {len(checkpoint_vars)} checkpoints to download")
+
+    # Download each checkpoint
+    for checkpoint in checkpoint_vars:
+        download_checkpoint(checkpoint, output_dir)

helper.py

@@ -0,0 +1,123 @@
+import argparse
+import sys
+from typing import Any, Dict, Literal, Optional
+
+sys.path.append("./cosmos-transfer1")
+
+from cosmos_transfer1.diffusion.inference.inference_utils import valid_hint_keys
+
+
+def load_controlnet_specs(controlnet_specs_in: dict) -> Dict[str, Any]:
+    controlnet_specs = {}
+    args = {}
+
+    for hint_key, config in controlnet_specs_in.items():
+        if hint_key in valid_hint_keys:
+            controlnet_specs[hint_key] = config
+        else:
+            if isinstance(config, dict):
+                raise ValueError(f"Invalid hint_key: {hint_key}. Must be one of {valid_hint_keys}")
+            else:
+                args[hint_key] = config
+                continue
+    return controlnet_specs, args
+
+
+def parse_arguments(
+    controlnet_specs_in: dict,
+    prompt: str = "The video captures a stunning, photorealistic scene with remarkable attention to detail, giving it a lifelike appearance that is almost indistinguishable from reality. It appears to be from a high-budget 4K movie, showcasing ultra-high-definition quality with impeccable resolution.",  # noqa: E501
+    negative_prompt: str = "The video captures a game playing, with bad crappy graphics and cartoonish frames. It represents a recording of old outdated games. The lighting looks very fake. The textures are very raw and basic. The geometries are very primitive. The images are very pixelated and of poor CG quality. There are many subtitles in the footage. Overall, the video is unrealistic at all.",  # noqa: E501
+    input_video_path: str = "",
+    num_input_frames: int = 1,
+    sigma_max: float = 70.0,
+    blur_strength: Literal["very_low", "low", "medium", "high", "very_high"] = "medium",
+    canny_threshold: Literal["very_low", "low", "medium", "high", "very_high"] = "medium",
+    is_av_sample: bool = False,
+    checkpoint_dir: str = "checkpoints",
+    tokenizer_dir: str = "Cosmos-Tokenize1-CV8x8x8-720p",
+    video_save_name: str = "output",
+    video_save_folder: str = "outputs/",
+    batch_input_path: Optional[str] = None,
+    batch_size: int = 1,
+    num_steps: int = 35,
+    guidance: float = 5,
+    fps: int = 24,
+    seed: int = 1,
+    num_gpus: Literal[1] = 1,
+    offload_diffusion_transformer: bool = False,
+    offload_text_encoder_model: bool = False,
+    offload_guardrail_models: bool = False,
+    upsample_prompt: bool = False,
+    offload_prompt_upsampler: bool = False,
+    use_distilled: bool = False,
+) -> argparse.Namespace:
+    """
+    Parse input of control to world generation
+
+    :param str controlnet_specs_in: multicontrolnet configurations dict
+
+    :param str prompt: prompt which the sampled video condition on
+    :param str negative_prompt: negative prompt which the sampled video condition on
+    :param str input_video_path: Optional input RGB video path
+    :param int num_input_frames: Number of conditional frames for long video generation
+    :param float sigma_max: sigma_max for partial denoising
+    :param str blur_strength: blur strength
+    :param str canny_threshold: blur strength of canny threshold applied to input. Lower means less blur or more detected edges, which means higher fidelity to input
+    :param bool is_av_sample: Whether the model is an driving post-training model
+    :param str checkpoint_dir: Base directory containing model checkpoints
+    :param str tokenizer_dir: Tokenizer weights directory relative to checkpoint_dir
+    :param str video_save_name: Output filename for generating a single video
+    :param str video_save_folder: Output folder for generating a batch of videos
+    :param str batch_input_path: Path to a JSONL file of input prompts for generating a batch of videos
+    :param int batch_size: Batch size
+    :param int num_steps: Number of diffusion sampling steps
+    :param float guidance: Classifier-free guidance scale value
+    :param int fps: FPS of the output video
+    :param int seed: Random seed
+    :param int num_gpus: Number of GPUs used to run inference in parallel
+    :param bool offload_diffusion_transformer: Offload DiT after inference
+    :param bool offload_text_encoder_model: Offload text encoder model after inference
+    :param bool offload_guardrail_models: Offload guardrail models after inference
+    :param bool upsample_prompt: Upsample prompt using Pixtral upsampler model
+    :param bool offload_prompt_upsampler: Offload prompt upsampler model after inference
+    :param bool use_distilled: Use distilled ControlNet model variant
+    """
+
+    cmd_args = argparse.Namespace(
+        prompt=prompt,
+        negative_prompt=negative_prompt,
+        input_video_path=input_video_path,
+        num_input_frames=num_input_frames,
+        sigma_max=sigma_max,
+        blur_strength=blur_strength,
+        canny_threshold=canny_threshold,
+        is_av_sample=is_av_sample,
+        checkpoint_dir=checkpoint_dir,
+        tokenizer_dir=tokenizer_dir,
+        video_save_name=video_save_name,
+        video_save_folder=video_save_folder,
+        batch_input_path=batch_input_path,
+        batch_size=batch_size,
+        num_steps=num_steps,
+        guidance=guidance,
+        fps=fps,
+        seed=seed,
+        num_gpus=num_gpus,
+        offload_diffusion_transformer=offload_diffusion_transformer,
+        offload_text_encoder_model=offload_text_encoder_model,
+        offload_guardrail_models=offload_guardrail_models,
+        upsample_prompt=upsample_prompt,
+        offload_prompt_upsampler=offload_prompt_upsampler,
+        use_distilled=use_distilled,
+    )
+
+    # Load and parse JSON input
+    control_inputs, json_args = load_controlnet_specs(controlnet_specs_in)
+
+    # if parameters not set on command line, use the ones from the controlnet_specs
+    # if both not set use command line defaults
+    for key in json_args:
+        if f"--{key}" not in sys.argv:
+            setattr(cmd_args, key, json_args[key])
+
+    return cmd_args, control_inputs

requirements.txt

@@ -0,0 +1,10 @@
+git+https://github.com/huggingface/diffusers.git
+transformers
+accelerate
+sentencepiece
+safetensors
+torchvision
+git+https://github.com/yiyixuxu/cosmos-guardrail.git
+peft
+
+git+https://github.com/nvidia-cosmos/cosmos-transfer1