Update

.gitignore

@@ -0,0 +1,219 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#   you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml
+
+outputs/
+resources/

README.md

@@ -1,12 +1,57 @@
----
-title: Motion Latent Diffusion Standalone Demo
-emoji: 📊
-colorFrom: purple
-colorTo: indigo
-sdk: gradio
-sdk_version: 5.49.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Demo
+
+Command-line and web interfaces for motion-latent-diffusion-standalone.
+
+## Installation
+
+```bash
+cd demo
+pip install -e .
+```
+
+## Command Line
+
+```bash
+# Generate motion
+python cli.py --text "a person walks forward" --length 100
+
+# Options
+python cli.py --text "jumping" --length 120 --output ./outputs/ --no-video
+```
+
+Outputs:
+
+- `*.pt` - Motion tensor (frames, 22, 3)
+- `*.latent.pt` - Latent representation
+- `*.mp4` - Visualization video
+- `*.txt` - Text prompt
+
+## Web Interface
+
+```bash
+python app.py
+```
+
+Opens at `http://localhost:7860`
+
+## Visualization
+
+```bash
+# Create video from saved motion
+python visualize.py motion.pt --output video.mp4 --fps 20
+```
+
+## Python API
+
+```python
+from motion_latent_diffusion_standalone import MotionLatentDiffusionModel
+from visualize import create_video_from_joints
+
+model = MotionLatentDiffusionModel(
+    vae_repo_id="blanchon/motion-latent-diffusion-standalone-vae",
+    denoiser_repo_id="blanchon/motion-latent-diffusion-standalone-denoiser"
+)
+
+joints = model.generate("a person walks", length=100)  # (100, 22, 3)
+create_video_from_joints(joints, "output.mp4", fps=20)
+```

app.py

@@ -0,0 +1,204 @@
+from pathlib import Path
+import gradio as gr
+import torch
+from datetime import datetime
+import tempfile
+from tqdm import tqdm
+from textwrap import dedent
+import spaces
+
+
+from motion_latent_diffusion_standalone import MotionLatentDiffusionModel
+from visualize import create_video_from_joints
+
+
+model = MotionLatentDiffusionModel(
+    vae_repo_id="blanchon/motion-latent-diffusion-standalone-vae",
+    denoiser_repo_id="blanchon/motion-latent-diffusion-standalone-denoiser",
+    text_encoder_repo_id="openai/clip-vit-large-patch14",
+)
+model.to("cuda")
+model.eval()
+model.requires_grad_(False)
+
+
+@spaces.gpu()
+def generate_motion(
+    text_prompt: str, motion_length: int, progress=gr.Progress(track_tqdm=True)
+) -> tuple[Path, str, Path]:
+    try:
+        # Create temporary files
+        temp_dir = tempfile.gettempdir()
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"motion_{timestamp}"
+
+        pt_path = Path(temp_dir) / f"{filename}.pt"
+        video_path = Path(temp_dir) / f"{filename}.mp4"
+
+        print("🎬 Generating motion...")
+        with tqdm(
+            total=motion_length,
+            desc="Generating motion",
+            # disable=not progress.is_tracked(),
+        ) as pbar:
+
+            def callback_on_step_end(i: int, latents: torch.Tensor):
+                pbar.update(i)
+
+            # Generate motion (returns PyTorch tensor)
+            joints, latent = model.generate(
+                text_prompt,
+                motion_length,
+                return_latent=True,
+                callback_on_step_end=callback_on_step_end,
+            )
+
+        # Save motion data as PyTorch tensor
+        torch.save(joints, pt_path)
+
+        print("🎥 Creating visualization...")
+
+        # Create video visualization
+        video_path = create_video_from_joints(joints, video_path.as_posix(), fps=20)
+
+        print("✅ Done!")
+
+        # Generate info text
+        info_text = dedent("""
+            ✅ **Generation Complete!**
+
+            **Prompt:** {text_prompt}
+            **Motion Length:** {motion_length} frames ({motion_length / 20:.1f}s at 20fps)
+            **Output Shape:** {joints.shape} (frames × joints × coords)
+
+            The video shows a 3D skeleton performing the motion. 
+            You can download both the video and the raw motion data below.
+        """)
+
+        return video_path, info_text, pt_path.as_posix()
+
+    except Exception as e:
+        error_msg = f"Error during generation: {str(e)}"
+        import traceback
+
+        traceback.print_exc()
+        return None, error_msg, None
+
+
+def create_example_prompts():
+    """Return example prompts for the interface"""
+    return [
+        ["a person walks forward slowly", 80],
+        ["jumping up and down", 100],
+        ["a person waves hello", 60],
+        ["running in place", 100],
+        ["a person does jumping jacks", 120],
+        ["someone performs a cartwheel", 140],
+        ["walking backwards carefully", 90],
+        ["a person stretches their arms", 80],
+    ]
+
+
+with gr.Blocks(title="MLD Text-to-Motion Generator", theme=gr.themes.Soft()) as demo:
+    # Header
+    gr.Markdown("""
+    # 🎬 MLD Text-to-Motion Generator
+    
+    Generate realistic human motion animations from text descriptions! 
+    Powered by Motion Latent Diffusion (MLD).
+    
+    ### 💡 Tips for Best Results:
+    - Be specific: "a person walks forward slowly" works better than just "walking"
+    - Use present tense: "walks" or "is walking"
+    - Describe single continuous actions
+    - Recommended length: 40-60 frames for short actions, 80-120 for walking/running
+    """)
+
+    with gr.Row():
+        # Left column - Inputs
+        with gr.Column(scale=1):
+            gr.Markdown("## 📝 Input")
+
+            text_input = gr.Textbox(
+                label="Text Prompt",
+                placeholder="Enter motion description (e.g., 'a person walks forward slowly')",
+                lines=3,
+                value="a person walks forward",
+            )
+
+            with gr.Row():
+                length_slider = gr.Slider(
+                    minimum=16,
+                    maximum=196,
+                    value=100,
+                    step=1,
+                    label="Motion Length (frames)",
+                    info="20 frames = 1 second",
+                )
+
+            generate_btn = gr.Button("🎬 Generate Motion", variant="primary", size="lg")
+
+            gr.Markdown("### 📚 Example Prompts")
+            gr.Examples(
+                examples=create_example_prompts(),
+                inputs=[text_input, length_slider],
+                label=None,
+            )
+
+        # Right column - Outputs
+        with gr.Column(scale=1):
+            gr.Markdown("## 🎥 Output")
+
+            info_output = gr.Markdown(
+                "Generate a motion to see the results here.",
+                elem_classes=["output-info"],
+            )
+
+            video_output = gr.Video(
+                label="Generated Motion Video",
+                elem_classes=["output-video"],
+                autoplay=True,
+                show_share_button=True,
+            )
+
+            with gr.Row():
+                pt_download = gr.File(label="Download Motion Data (.pt)", visible=False)
+
+    # Footer
+    gr.Markdown(
+        dedent("""
+        ---
+        ### ℹ️ About
+        
+        **Motion Latent Diffusion (MLD)** generates 3D human motion by:
+        1. Encoding text with CLIP
+        2. Generating motion in latent space via diffusion (50 steps)
+        3. Decoding to 3D joint positions (22 joints)
+        4. Visualizing as a 3D skeleton animation
+        
+        **Citation:** Chen et al., "Executing your Commands via Motion Diffusion in Latent Space", CVPR 2023
+        
+        **Repository:** [motion-latent-diffusion](https://github.com/ChenFengYe/motion-latent-diffusion)
+        """)
+    )
+
+    # Event handlers
+    def generate_and_update(text, length):
+        video, info, pt = generate_motion(text, length)
+        if pt:
+            return video, info, gr.update(value=pt, visible=True)
+        return video, info, gr.update(visible=False)
+
+    generate_btn.click(
+        fn=generate_and_update,
+        inputs=[text_input, length_slider],
+        outputs=[video_output, info_output, pt_download],
+    )
+
+
+demo.launch(
+    server_name="0.0.0.0",  # Allow external access
+    server_port=7860,
+    share=False,
+    show_error=True,
+)

cli.py

@@ -0,0 +1,182 @@
+"""
+MLD Demo CLI - Generate human motion from text using the standalone MLD package.
+"""
+
+import argparse
+from pathlib import Path
+from datetime import datetime
+import torch
+from textwrap import dedent
+from tqdm import tqdm
+
+from motion_latent_diffusion_standalone import MotionLatentDiffusionModel
+from visualize import create_video_from_joints
+
+
+def parse_args() -> argparse.Namespace:
+    """Parse command line arguments"""
+    parser = argparse.ArgumentParser(
+        description="Generate human motion from text using MLD",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=dedent("""
+            Examples:
+            # Basic usage
+            python cli.py --text "a person walks forward slowly"
+            
+            # Custom length
+            python cli.py --text "jumping jacks" --length 120
+            
+            # Save to specific directory
+            python cli.py --text "dancing" --output ./motions/
+            
+            # Skip video generation (faster)
+            python cli.py --text "running" --no-video
+        """),
+    )
+
+    parser.add_argument(
+        "--text",
+        type=str,
+        required=True,
+        help="Text description of the motion to generate",
+    )
+
+    parser.add_argument(
+        "--length",
+        type=int,
+        default=100,
+        help="Motion length in frames (default: 100, range: 16-196 for 20fps)",
+    )
+
+    parser.add_argument(
+        "--output",
+        type=str,
+        default="./outputs",
+        help="Output directory for generated files (default: ./outputs)",
+    )
+
+    parser.add_argument(
+        "--no-video",
+        action="store_true",
+        help="Skip video generation, only save .pt file",
+    )
+
+    parser.add_argument(
+        "--device",
+        type=str,
+        default="cuda" if torch.cuda.is_available() else "cpu",
+        choices=["cuda", "cpu"],
+        help="Device to run on (default: cuda if available, else cpu)",
+    )
+
+    return parser.parse_args()
+
+
+def generate_filename(text: str) -> str:
+    """Generate a filename from text and timestamp"""
+    # Clean text for filename: remove special characters
+    text_clean = "".join(c if c.isalnum() or c.isspace() else "" for c in text)
+    text_clean = "_".join(text_clean.split()[:5])  # First 5 words
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    return f"{text_clean}_{timestamp}"
+
+
+def main() -> None:
+    """Main entry point for CLI"""
+    args = parse_args()
+
+    # Validate motion length
+    if args.length < 16 or args.length > 196:
+        print(f"Warning: Length {args.length} is outside recommended range (16-196)")
+        print("Proceeding anyway, but results may be suboptimal.")
+
+    # Setup output paths
+    output_dir = Path(args.output)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Generate output filenames
+    base_name = generate_filename(args.text)
+    pt_path = output_dir / f"{base_name}.pt"
+    mp4_path = output_dir / f"{base_name}.mp4"
+    txt_path = output_dir / f"{base_name}.txt"
+
+    print("=" * 70)
+    print("MLD Text-to-Motion Generator")
+    print("=" * 70)
+    print(f"Text prompt: {args.text}")
+    print(f"Motion length: {args.length} frames ({args.length / 20:.1f}s at 20fps)")
+    print(f"Output directory: {output_dir.absolute()}")
+    print(f"Device: {args.device}")
+    print("=" * 70)
+
+    # [1/4] Load model from HuggingFace Hub
+    print("\n[1/4] Loading model from HuggingFace Hub...")
+    print("This may take a minute on first run (downloads ~105MB)...")
+    model = MotionLatentDiffusionModel(
+        vae_repo_id="blanchon/motion-latent-diffusion-standalone-vae",
+        denoiser_repo_id="blanchon/motion-latent-diffusion-standalone-denoiser",
+        text_encoder_repo_id="openai/clip-vit-large-patch14",
+    ).to(args.device)
+
+    # [2/4] Generate motion
+    print("\n[2/4] Generating motion...")
+    print(f"Running diffusion sampling ({model.num_inference_timesteps} steps)...")
+
+    with tqdm(total=args.length, desc="Generating motion") as pbar:
+
+        def callback_on_step_end(i: int, latents: torch.Tensor):
+            pbar.update(i)
+
+        # Generate motion (returns PyTorch tensor)
+        joints, latent = model.generate(
+            args.text,
+            args.length,
+            return_latent=True,
+            callback_on_step_end=callback_on_step_end,
+        )
+
+    print(f"✓ Generated motion: {joints.shape}")
+    print(
+        f"  Shape: ({joints.shape[0]} frames, {joints.shape[1]} joints, {joints.shape[2]} coords)"
+    )
+
+    # [3/4] Save motion file as PyTorch tensor
+    print("\n[3/4] Saving files...")
+    torch.save(joints, pt_path)
+    print(f"✓ Saved motion: {pt_path}")
+
+    # Save latent representation
+    latent_path = output_dir / f"{base_name}.latent.pt"
+    torch.save(latent, latent_path)
+    print(f"✓ Saved latent: {latent_path}")
+
+    # Save text prompt for reference
+    with open(txt_path, "w") as f:
+        f.write(args.text)
+    print(f"✓ Saved prompt: {txt_path}")
+
+    # [4/4] Generate video if requested
+    if not args.no_video:
+        print("\n[4/4] Generating video visualization...")
+        video_path = create_video_from_joints(joints, str(mp4_path), fps=20)
+        print(f"✓ Generated video: {video_path}")
+    else:
+        print("\n[4/4] Skipping video generation (--no-video flag)")
+
+    # Print summary
+    print("\n" + "=" * 70)
+    print("✓ Generation complete!")
+    print("=" * 70)
+    print("Output files:")
+    print(f"  Motion data: {pt_path}")
+    print(f"  Latent repr: {latent_path}")
+    print(f"  Text prompt: {txt_path}")
+    if not args.no_video:
+        print(f"  Video:       {mp4_path}")
+    print("\nTo visualize the motion later:")
+    print(f"  python visualize.py {pt_path}")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    main()

notebooks/latent_analysis.ipynb

@@ -0,0 +1,903 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Motion Latent Analysis\n",
+    "\n",
+    "This notebook demonstrates how to work with motion latent representations from the MLD model:\n",
+    "\n",
+    "1. **Generate variations** - Create 10 similar \"jump\" motions\n",
+    "2. **Compute mean latent** - Average the latent representations\n",
+    "3. **Distance computation** - Compare motions using L2 distance\n",
+    "4. **Classification** - Distinguish jump from non-jump motions\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup and Imports\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/workspace/ai-toolkit/motion-latent-diffusion/standalone_demo/.venv/lib/python3.13/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import torch\n",
+    "from pathlib import Path\n",
+    "from standalone_demo import StandaloneConfig, load_model\n",
+    "\n",
+    "# Configuration\n",
+    "OUTPUT_DIR = Path(\"outputs/jump\")\n",
+    "NUM_VARIATIONS = 20\n",
+    "MOTION_LENGTH = 120  # frames (6 seconds at 20fps)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load Model\n",
+    "\n",
+    "Load the MLD model for motion generation. This will auto-download models if needed.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading MLD model...\n",
+      "Model initialized on cuda\n",
+      "Loading checkpoint from resources/checkpoints/model.ckpt\n",
+      "Checkpoint loaded successfully\n",
+      "✓ Model loaded successfully\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Loading MLD model...\")\n",
+    "config = StandaloneConfig()\n",
+    "config.resolve_paths(Path(\".\"))\n",
+    "model = load_model(config)\n",
+    "print(\"✓ Model loaded successfully\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 1: Generate jump Variations\n",
+    "\n",
+    "Generate 10 variations of \"jump\" motions using slightly different prompts.\n",
+    "Each generation saves:\n",
+    "- `.npy` - 3D joint positions\n",
+    "- `.latent.pt` - Latent representation\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating 20 jump variations...\n",
+      "\n",
+      "[1/20] a person does a jump\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/workspace/ai-toolkit/motion-latent-diffusion/standalone_demo/src/standalone_demo/models/utils.py:23: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.detach().clone() or sourceTensor.detach().clone().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  lengths = torch.tensor(lengths, device=device)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  ✓ Saved jump_var_00\n",
+      "    Joints: (120, 22, 3), Latent: torch.Size([1, 1, 256])\n",
+      "[2/20] someone performs a jump\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/workspace/ai-toolkit/motion-latent-diffusion/standalone_demo/src/standalone_demo/models/utils.py:23: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.detach().clone() or sourceTensor.detach().clone().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  lengths = torch.tensor(lengths, device=device)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  ✓ Saved jump_var_01\n",
+      "    Joints: (120, 22, 3), Latent: torch.Size([1, 1, 256])\n",
+      "[3/20] a person jumps in the air\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/workspace/ai-toolkit/motion-latent-diffusion/standalone_demo/src/standalone_demo/models/utils.py:23: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.detach().clone() or sourceTensor.detach().clone().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  lengths = torch.tensor(lengths, device=device)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  ✓ Saved jump_var_02\n",
+      "    Joints: (120, 22, 3), Latent: torch.Size([1, 1, 256])\n",
+      "[4/20] doing a jump\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/workspace/ai-toolkit/motion-latent-diffusion/standalone_demo/src/standalone_demo/models/utils.py:23: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.detach().clone() or sourceTensor.detach().clone().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  lengths = torch.tensor(lengths, device=device)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  ✓ Saved jump_var_03\n",
+      "    Joints: (120, 22, 3), Latent: torch.Size([1, 1, 256])\n",
+      "[5/20] performing a jump\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/workspace/ai-toolkit/motion-latent-diffusion/standalone_demo/src/standalone_demo/models/utils.py:23: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.detach().clone() or sourceTensor.detach().clone().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  lengths = torch.tensor(lengths, device=device)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  ✓ Saved jump_var_04\n",
+      "    Joints: (120, 22, 3), Latent: torch.Size([1, 1, 256])\n",
+      "[6/20] a person does a jump\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/workspace/ai-toolkit/motion-latent-diffusion/standalone_demo/src/standalone_demo/models/utils.py:23: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.detach().clone() or sourceTensor.detach().clone().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  lengths = torch.tensor(lengths, device=device)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  ✓ Saved jump_var_05\n",
+      "    Joints: (120, 22, 3), Latent: torch.Size([1, 1, 256])\n",
+      "[7/20] someone jumps backward\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/workspace/ai-toolkit/motion-latent-diffusion/standalone_demo/src/standalone_demo/models/utils.py:23: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.detach().clone() or sourceTensor.detach().clone().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  lengths = torch.tensor(lengths, device=device)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  ✓ Saved jump_var_06\n",
+      "    Joints: (120, 22, 3), Latent: torch.Size([1, 1, 256])\n",
+      "[8/20] a person executes a jump\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/workspace/ai-toolkit/motion-latent-diffusion/standalone_demo/src/standalone_demo/models/utils.py:23: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.detach().clone() or sourceTensor.detach().clone().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  lengths = torch.tensor(lengths, device=device)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  ✓ Saved jump_var_07\n",
+      "    Joints: (120, 22, 3), Latent: torch.Size([1, 1, 256])\n",
+      "[9/20] doing an acrobatic jump\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/workspace/ai-toolkit/motion-latent-diffusion/standalone_demo/src/standalone_demo/models/utils.py:23: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.detach().clone() or sourceTensor.detach().clone().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  lengths = torch.tensor(lengths, device=device)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  ✓ Saved jump_var_08\n",
+      "    Joints: (120, 22, 3), Latent: torch.Size([1, 1, 256])\n",
+      "[10/20] a person jumps forward\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/workspace/ai-toolkit/motion-latent-diffusion/standalone_demo/src/standalone_demo/models/utils.py:23: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.detach().clone() or sourceTensor.detach().clone().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  lengths = torch.tensor(lengths, device=device)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  ✓ Saved jump_var_09\n",
+      "    Joints: (120, 22, 3), Latent: torch.Size([1, 1, 256])\n",
+      "[11/20] a person does a jump\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/workspace/ai-toolkit/motion-latent-diffusion/standalone_demo/src/standalone_demo/models/utils.py:23: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.detach().clone() or sourceTensor.detach().clone().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  lengths = torch.tensor(lengths, device=device)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  ✓ Saved jump_var_10\n",
+      "    Joints: (120, 22, 3), Latent: torch.Size([1, 1, 256])\n",
+      "[12/20] someone performs a jump\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/workspace/ai-toolkit/motion-latent-diffusion/standalone_demo/src/standalone_demo/models/utils.py:23: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.detach().clone() or sourceTensor.detach().clone().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  lengths = torch.tensor(lengths, device=device)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  ✓ Saved jump_var_11\n",
+      "    Joints: (120, 22, 3), Latent: torch.Size([1, 1, 256])\n",
+      "[13/20] a person jumps in the air\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/workspace/ai-toolkit/motion-latent-diffusion/standalone_demo/src/standalone_demo/models/utils.py:23: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.detach().clone() or sourceTensor.detach().clone().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  lengths = torch.tensor(lengths, device=device)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  ✓ Saved jump_var_12\n",
+      "    Joints: (120, 22, 3), Latent: torch.Size([1, 1, 256])\n",
+      "[14/20] doing a jump\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/workspace/ai-toolkit/motion-latent-diffusion/standalone_demo/src/standalone_demo/models/utils.py:23: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.detach().clone() or sourceTensor.detach().clone().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  lengths = torch.tensor(lengths, device=device)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  ✓ Saved jump_var_13\n",
+      "    Joints: (120, 22, 3), Latent: torch.Size([1, 1, 256])\n",
+      "[15/20] performing a jump\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/workspace/ai-toolkit/motion-latent-diffusion/standalone_demo/src/standalone_demo/models/utils.py:23: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.detach().clone() or sourceTensor.detach().clone().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  lengths = torch.tensor(lengths, device=device)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  ✓ Saved jump_var_14\n",
+      "    Joints: (120, 22, 3), Latent: torch.Size([1, 1, 256])\n",
+      "[16/20] a person does a jump\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/workspace/ai-toolkit/motion-latent-diffusion/standalone_demo/src/standalone_demo/models/utils.py:23: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.detach().clone() or sourceTensor.detach().clone().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  lengths = torch.tensor(lengths, device=device)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  ✓ Saved jump_var_15\n",
+      "    Joints: (120, 22, 3), Latent: torch.Size([1, 1, 256])\n",
+      "[17/20] someone jumps backward\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/workspace/ai-toolkit/motion-latent-diffusion/standalone_demo/src/standalone_demo/models/utils.py:23: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.detach().clone() or sourceTensor.detach().clone().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  lengths = torch.tensor(lengths, device=device)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  ✓ Saved jump_var_16\n",
+      "    Joints: (120, 22, 3), Latent: torch.Size([1, 1, 256])\n",
+      "[18/20] a person executes a jump\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/workspace/ai-toolkit/motion-latent-diffusion/standalone_demo/src/standalone_demo/models/utils.py:23: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.detach().clone() or sourceTensor.detach().clone().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  lengths = torch.tensor(lengths, device=device)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  ✓ Saved jump_var_17\n",
+      "    Joints: (120, 22, 3), Latent: torch.Size([1, 1, 256])\n",
+      "[19/20] doing an acrobatic jump\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/workspace/ai-toolkit/motion-latent-diffusion/standalone_demo/src/standalone_demo/models/utils.py:23: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.detach().clone() or sourceTensor.detach().clone().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  lengths = torch.tensor(lengths, device=device)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  ✓ Saved jump_var_18\n",
+      "    Joints: (120, 22, 3), Latent: torch.Size([1, 1, 256])\n",
+      "[20/20] a person jumps forward\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/workspace/ai-toolkit/motion-latent-diffusion/standalone_demo/src/standalone_demo/models/utils.py:23: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.detach().clone() or sourceTensor.detach().clone().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  lengths = torch.tensor(lengths, device=device)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  ✓ Saved jump_var_19\n",
+      "    Joints: (120, 22, 3), Latent: torch.Size([1, 1, 256])\n",
+      "\n",
+      "✓ Generated 20 jump variations\n"
+     ]
+    }
+   ],
+   "source": [
+    "import shutil\n",
+    "\n",
+    "# Create output directory\n",
+    "OUTPUT_DIR.mkdir(parents=True, exist_ok=True)\n",
+    "\n",
+    "# Define prompt variations\n",
+    "jump_prompts = [\n",
+    "    \"a person does a jump\",\n",
+    "    \"someone performs a jump\",\n",
+    "    \"a person jumps in the air\",\n",
+    "    \"doing a jump\",\n",
+    "    \"performing a jump\",\n",
+    "    \"a person does a jump\",\n",
+    "    \"someone jumps backward\",\n",
+    "    \"a person executes a jump\",\n",
+    "    \"doing an acrobatic jump\",\n",
+    "    \"a person jumps forward\",\n",
+    "    \"a person does a jump\",\n",
+    "    \"someone performs a jump\",\n",
+    "    \"a person jumps in the air\",\n",
+    "    \"doing a jump\",\n",
+    "    \"performing a jump\",\n",
+    "    \"a person does a jump\",\n",
+    "    \"someone jumps backward\",\n",
+    "    \"a person executes a jump\",\n",
+    "    \"doing an acrobatic jump\",\n",
+    "    \"a person jumps forward\",\n",
+    "    \"a person does a jump\",\n",
+    "    \"someone performs a jump\",\n",
+    "    \"a person jumps in the air\",\n",
+    "    \"doing a jump\",\n",
+    "    \"performing a jump\",\n",
+    "    \"a person does a jump\",\n",
+    "    \"someone jumps backward\",\n",
+    "    \"a person executes a jump\",\n",
+    "    \"doing an acrobatic jump\",\n",
+    "    \"a person jumps forward\",\n",
+    "]\n",
+    "\n",
+    "print(f\"Generating {NUM_VARIATIONS} jump variations...\\n\")\n",
+    "\n",
+    "latent_paths = []\n",
+    "\n",
+    "for i, prompt in enumerate(jump_prompts[:NUM_VARIATIONS]):\n",
+    "    print(f\"[{i + 1}/{NUM_VARIATIONS}] {prompt}\")\n",
+    "\n",
+    "    # Generate motion with latent\n",
+    "    (joints, latent, video_path) = model.generate(\n",
+    "        prompt, MOTION_LENGTH, return_latent=True, create_video=True\n",
+    "    )\n",
+    "\n",
+    "    # Save files\n",
+    "    base_name = f\"jump_var_{i:02d}\"\n",
+    "    npy_path = OUTPUT_DIR / f\"{base_name}.npy\"\n",
+    "    latent_path = OUTPUT_DIR / f\"{base_name}.latent.pt\"\n",
+    "\n",
+    "    np.save(npy_path, joints)\n",
+    "    torch.save(latent, latent_path)\n",
+    "    latent_paths.append(latent_path)\n",
+    "\n",
+    "    # Save video\n",
+    "    video_path_target = OUTPUT_DIR / f\"{base_name}.mp4\"\n",
+    "    shutil.copy(video_path, video_path_target)\n",
+    "\n",
+    "    print(f\"  ✓ Saved {base_name}\")\n",
+    "    print(f\"    Joints: {joints.shape}, Latent: {latent.shape}\")\n",
+    "\n",
+    "print(f\"\\n✓ Generated {len(latent_paths)} jump variations\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 2: Compute Mean Latent\n",
+    "\n",
+    "Average all flip latents to create a \"prototype\" flip representation.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Computing mean latent from 20 samples...\n",
+      "✓ Mean latent shape: torch.Size([1, 1, 256])\n",
+      "✓ Saved to: outputs/jump/jump_mean.latent.pt\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"Computing mean latent from {len(latent_paths)} samples...\")\n",
+    "\n",
+    "# Load all latents\n",
+    "latents = [torch.load(path) for path in latent_paths]\n",
+    "\n",
+    "# Stack and compute mean\n",
+    "latents_stacked = torch.stack(latents)\n",
+    "mean_latent = latents_stacked.mean(dim=0)\n",
+    "\n",
+    "# Save mean latent\n",
+    "mean_latent_path = OUTPUT_DIR / \"jump_mean.latent.pt\"\n",
+    "torch.save(mean_latent, mean_latent_path)\n",
+    "\n",
+    "print(f\"✓ Mean latent shape: {mean_latent.shape}\")\n",
+    "print(f\"✓ Saved to: {mean_latent_path}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 3: Define Distance Function\n",
+    "\n",
+    "L2 distance measures similarity between latent representations.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✓ Distance function defined\n"
+     ]
+    }
+   ],
+   "source": [
+    "def compute_latent_distance(latent1, latent2):\n",
+    "    \"\"\"\n",
+    "    Compute L2 (Euclidean) distance between two latent representations.\n",
+    "\n",
+    "    Args:\n",
+    "        latent1: First latent tensor or path\n",
+    "        latent2: Second latent tensor or path\n",
+    "\n",
+    "    Returns:\n",
+    "        L2 distance (float)\n",
+    "    \"\"\"\n",
+    "    # Load if paths provided\n",
+    "    if isinstance(latent1, (str, Path)):\n",
+    "        latent1 = torch.load(latent1)\n",
+    "    if isinstance(latent2, (str, Path)):\n",
+    "        latent2 = torch.load(latent2)\n",
+    "\n",
+    "    # Compute L2 norm of difference\n",
+    "    distance = torch.norm(latent1 - latent2, p=2).item()\n",
+    "\n",
+    "    return distance\n",
+    "\n",
+    "\n",
+    "print(\"✓ Distance function defined\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 4: Generate Test Motions\n",
+    "\n",
+    "Generate:\n",
+    "- A flip motion (should be close to mean)\n",
+    "- A walk motion (should be far from mean)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating test motions...\n",
+      "\n",
+      "1. Generating jump-like motion...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/workspace/ai-toolkit/motion-latent-diffusion/standalone_demo/src/standalone_demo/models/utils.py:23: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.detach().clone() or sourceTensor.detach().clone().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  lengths = torch.tensor(lengths, device=device)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   ✓ Saved test jump motion\n",
+      "\n",
+      "2. Generating non-jump motion (walking)...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/workspace/ai-toolkit/motion-latent-diffusion/standalone_demo/src/standalone_demo/models/utils.py:23: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.detach().clone() or sourceTensor.detach().clone().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  lengths = torch.tensor(lengths, device=device)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   ✓ Saved test walk motion\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Generating test motions...\\n\")\n",
+    "\n",
+    "# Test 1: jump-like motion\n",
+    "print(\"1. Generating jump-like motion...\")\n",
+    "joints_jump, latent_jump, video_path_jump = model.generate(\n",
+    "    \"a person does a jump\", MOTION_LENGTH, return_latent=True, create_video=True\n",
+    ")\n",
+    "jump_latent_path = OUTPUT_DIR / \"test_jump.latent.pt\"\n",
+    "torch.save(latent_jump, jump_latent_path)\n",
+    "np.save(OUTPUT_DIR / \"test_jump.npy\", joints_jump)\n",
+    "\n",
+    "video_path_target = OUTPUT_DIR / \"test_jump.mp4\"\n",
+    "shutil.copy(video_path_jump, video_path_target)\n",
+    "\n",
+    "print(f\"   ✓ Saved test jump motion\")\n",
+    "\n",
+    "# Test 2: Non-jump motion (walking)\n",
+    "print(\"\\n2. Generating non-jump motion (walking)...\")\n",
+    "joints_walk, latent_walk, video_path_walk = model.generate(\n",
+    "    \"a person walks forward\", MOTION_LENGTH, return_latent=True, create_video=True\n",
+    ")\n",
+    "walk_latent_path = OUTPUT_DIR / \"test_walk.latent.pt\"\n",
+    "torch.save(latent_walk, walk_latent_path)\n",
+    "np.save(OUTPUT_DIR / \"test_walk.npy\", joints_walk)\n",
+    "\n",
+    "video_path_target = OUTPUT_DIR / \"test_walk.mp4\"\n",
+    "shutil.copy(video_path_walk, video_path_target)\n",
+    "\n",
+    "print(f\"   ✓ Saved test walk motion\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 5: Compare Distances\n",
+    "\n",
+    "Measure how close each test motion is to the mean jump latent.\n",
+    "\n",
+    "**Hypothesis**: jump motion should have smaller distance than walk motion.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Computing distances to mean jump latent...\n",
+      "\n",
+      "============================================================\n",
+      "📊 RESULTS\n",
+      "============================================================\n",
+      "Distance (jump → mean jump):  12.6496\n",
+      "Distance (walk → mean jump):  42.3448\n",
+      "\n",
+      "Ratio (walk/jump):            3.35x\n",
+      "============================================================\n",
+      "\n",
+      "✅ SUCCESS: jump is closer to mean jump latent!\n",
+      "   The model can distinguish jump from non-jump motions.\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Computing distances to mean jump latent...\\n\")\n",
+    "\n",
+    "# Distance: Test jump → Mean jump\n",
+    "dist_jump_to_mean = compute_latent_distance(latent_jump, mean_latent)\n",
+    "\n",
+    "# Distance: Test walk → Mean jump\n",
+    "dist_walk_to_mean = compute_latent_distance(latent_walk, mean_latent)\n",
+    "\n",
+    "# Display results\n",
+    "print(\"=\" * 60)\n",
+    "print(\"📊 RESULTS\")\n",
+    "print(\"=\" * 60)\n",
+    "print(f\"Distance (jump → mean jump):  {dist_jump_to_mean:.4f}\")\n",
+    "print(f\"Distance (walk → mean jump):  {dist_walk_to_mean:.4f}\")\n",
+    "print(f\"\\nRatio (walk/jump):            {dist_walk_to_mean / dist_jump_to_mean:.2f}x\")\n",
+    "print(\"=\" * 60)\n",
+    "\n",
+    "if dist_jump_to_mean < dist_walk_to_mean:\n",
+    "    print(\"\\n✅ SUCCESS: jump is closer to mean jump latent!\")\n",
+    "    print(f\"   The model can distinguish jump from non-jump motions.\")\n",
+    "else:\n",
+    "    print(\"\\n⚠️  UNEXPECTED: Walk is closer to mean jump latent.\")\n",
+    "    print(f\"   This suggests the latent space may not capture this distinction.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Bonus: Analyze Individual Variation Distances\n",
+    "\n",
+    "See how much each jump variation differs from the mean.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Analyzing variation distances...\n",
+      "\n",
+      "  Variation 00: 17.7083\n",
+      "  Variation 01: 23.6372\n",
+      "  Variation 02: 23.7708\n",
+      "  Variation 03: 27.0579\n",
+      "  Variation 04: 17.2911\n",
+      "  Variation 05: 18.6115\n",
+      "  Variation 06: 43.8279\n",
+      "  Variation 07: 29.0473\n",
+      "  Variation 08: 23.5446\n",
+      "  Variation 09: 20.4132\n",
+      "  Variation 10: 14.3313\n",
+      "  Variation 11: 19.8556\n",
+      "  Variation 12: 31.8104\n",
+      "  Variation 13: 20.7619\n",
+      "  Variation 14: 22.4498\n",
+      "  Variation 15: 34.5026\n",
+      "  Variation 16: 26.5776\n",
+      "  Variation 17: 38.9580\n",
+      "  Variation 18: 28.6006\n",
+      "  Variation 19: 24.1094\n",
+      "\n",
+      "Variation statistics:\n",
+      "  Mean distance: 25.3433\n",
+      "  Std deviation: 7.2979\n",
+      "\n",
+      "Comparison:\n",
+      "  Test jump: 12.6496 (0.50x mean variation)\n",
+      "  Test walk: 42.3448 (1.67x mean variation)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Analyzing variation distances...\\n\")\n",
+    "\n",
+    "variation_distances = []\n",
+    "for i, latent_path in enumerate(latent_paths):\n",
+    "    dist = compute_latent_distance(latent_path, mean_latent)\n",
+    "    variation_distances.append(dist)\n",
+    "    print(f\"  Variation {i:02d}: {dist:.4f}\")\n",
+    "\n",
+    "avg_variation = np.mean(variation_distances)\n",
+    "std_variation = np.std(variation_distances)\n",
+    "\n",
+    "print(f\"\\nVariation statistics:\")\n",
+    "print(f\"  Mean distance: {avg_variation:.4f}\")\n",
+    "print(f\"  Std deviation: {std_variation:.4f}\")\n",
+    "print(f\"\\nComparison:\")\n",
+    "print(\n",
+    "    f\"  Test jump: {dist_jump_to_mean:.4f} ({dist_jump_to_mean / avg_variation:.2f}x mean variation)\"\n",
+    ")\n",
+    "print(\n",
+    "    f\"  Test walk: {dist_walk_to_mean:.4f} ({dist_walk_to_mean / avg_variation:.2f}x mean variation)\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Summary\n",
+    "\n",
+    "### 📁 Files Created\n",
+    "\n",
+    "In `outputs/jump/`:\n",
+    "- `jump_var_00` to `jump_var_09` (.npy + .latent.pt) - 10 jump variations\n",
+    "- `jump_mean.latent.pt` - Mean latent of all variations ⭐\n",
+    "- `test_jump` (.npy + .latent.pt) - Test jump motion\n",
+    "- `test_walk` (.npy + .latent.pt) - Test walk motion\n",
+    "\n",
+    "**Total**: 24 files (10 variations + 2 tests + 1 mean + videos)\n",
+    "\n",
+    "### 🔬 Key Findings\n",
+    "\n",
+    "1. **Latent space clustering**: Similar motions (jumps) have similar latent representations\n",
+    "2. **Distance metric**: L2 distance effectively distinguishes motion types\n",
+    "3. **Mean latent**: Averaging latents creates a useful prototype representation\n",
+    "\n",
+    "### 🎯 Applications\n",
+    "\n",
+    "- **Motion classification**: Identify motion types (jump, walk, jump, etc.)\n",
+    "- **Motion retrieval**: Find similar motions in a database\n",
+    "- **Quality control**: Detect outlier/corrupted generations\n",
+    "- **Interpolation**: Blend between different motions\n",
+    "- **Style transfer**: Map motions to similar but different styles\n",
+    "- **Few-shot learning**: Create classifiers from few examples\n",
+    "\n",
+    "### 💡 Next Steps\n",
+    "\n",
+    "Try this analysis with other motion types:\n",
+    "- Jumps, spins, kicks, dances\n",
+    "- Compare multiple motion classes\n",
+    "- Build a motion classifier\n",
+    "- Create a motion search engine\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "motion-latent-diffusion-standalone-demo"
+version = "0.1.0"
+description = "Demo applications for MLD Text-to-Motion Generator - CLI and Gradio interface"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "gradio==5.49.1",
+    "matplotlib>=3.10.7",
+    "numpy>=2.3.4",
+    "torch>=2.9.0",
+    "tqdm>=4.67.1",
+    "spaces>=0.42.1",
+    "motion-latent-diffusion-standalone",
+]
+
+[dependency-groups]
+dev = ["ipykernel>=7.0.1"]
+
+[tool.uv.sources]
+motion-latent-diffusion-standalone = { git = "https://github.com/julien-blanchon/minimal-motion-generation" }

requirements.txt

@@ -0,0 +1,280 @@
+# This file was autogenerated by uv via the following command:
+#    uv pip compile pyproject.toml -o requirements.txt
+aiofiles==24.1.0
+    # via gradio
+annotated-types==0.7.0
+    # via pydantic
+anyio==4.11.0
+    # via
+    #   gradio
+    #   httpx
+    #   starlette
+brotli==1.1.0
+    # via gradio
+certifi==2025.10.5
+    # via
+    #   httpcore
+    #   httpx
+    #   requests
+charset-normalizer==3.4.4
+    # via requests
+click==8.3.0
+    # via
+    #   typer
+    #   uvicorn
+contourpy==1.3.3
+    # via matplotlib
+cycler==0.12.1
+    # via matplotlib
+diffusers==0.35.2
+    # via motion-latent-diffusion-standalone
+fastapi==0.119.0
+    # via gradio
+ffmpy==0.6.3
+    # via gradio
+filelock==3.20.0
+    # via
+    #   diffusers
+    #   huggingface-hub
+    #   torch
+    #   transformers
+fonttools==4.60.1
+    # via matplotlib
+fsspec==2025.9.0
+    # via
+    #   gradio-client
+    #   huggingface-hub
+    #   torch
+gradio==5.49.1
+    # via
+    #   motion-latent-diffusion-standalone-demo (pyproject.toml)
+    #   spaces
+gradio-client==1.13.3
+    # via gradio
+groovy==0.1.2
+    # via gradio
+h11==0.16.0
+    # via
+    #   httpcore
+    #   uvicorn
+hf-xet==1.1.10
+    # via huggingface-hub
+httpcore==1.0.9
+    # via httpx
+httpx==0.28.1
+    # via
+    #   gradio
+    #   gradio-client
+    #   safehttpx
+    #   spaces
+huggingface-hub==0.35.3
+    # via
+    #   diffusers
+    #   gradio
+    #   gradio-client
+    #   motion-latent-diffusion-standalone
+    #   tokenizers
+    #   transformers
+idna==3.11
+    # via
+    #   anyio
+    #   httpx
+    #   requests
+importlib-metadata==8.7.0
+    # via diffusers
+jinja2==3.1.6
+    # via
+    #   gradio
+    #   torch
+kiwisolver==1.4.9
+    # via matplotlib
+markdown-it-py==4.0.0
+    # via rich
+markupsafe==3.0.3
+    # via
+    #   gradio
+    #   jinja2
+matplotlib==3.10.7
+    # via motion-latent-diffusion-standalone-demo (pyproject.toml)
+mdurl==0.1.2
+    # via markdown-it-py
+motion-latent-diffusion-standalone @ git+https://github.com/julien-blanchon/minimal-motion-generation@33192ac1b86149a521b636ab8e5e26e3851f079e
+    # via motion-latent-diffusion-standalone-demo (pyproject.toml)
+mpmath==1.3.0
+    # via sympy
+networkx==3.5
+    # via torch
+numpy==2.3.4
+    # via
+    #   motion-latent-diffusion-standalone-demo (pyproject.toml)
+    #   contourpy
+    #   diffusers
+    #   gradio
+    #   matplotlib
+    #   pandas
+    #   transformers
+nvidia-cublas-cu12==12.8.4.1
+    # via
+    #   nvidia-cudnn-cu12
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-cuda-cupti-cu12==12.8.90
+    # via torch
+nvidia-cuda-nvrtc-cu12==12.8.93
+    # via torch
+nvidia-cuda-runtime-cu12==12.8.90
+    # via torch
+nvidia-cudnn-cu12==9.10.2.21
+    # via torch
+nvidia-cufft-cu12==11.3.3.83
+    # via torch
+nvidia-cufile-cu12==1.13.1.3
+    # via torch
+nvidia-curand-cu12==10.3.9.90
+    # via torch
+nvidia-cusolver-cu12==11.7.3.90
+    # via torch
+nvidia-cusparse-cu12==12.5.8.93
+    # via
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-cusparselt-cu12==0.7.1
+    # via torch
+nvidia-nccl-cu12==2.27.5
+    # via torch
+nvidia-nvjitlink-cu12==12.8.93
+    # via
+    #   nvidia-cufft-cu12
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+    #   torch
+nvidia-nvshmem-cu12==3.3.20
+    # via torch
+nvidia-nvtx-cu12==12.8.90
+    # via torch
+orjson==3.11.3
+    # via gradio
+packaging==25.0
+    # via
+    #   gradio
+    #   gradio-client
+    #   huggingface-hub
+    #   matplotlib
+    #   spaces
+    #   transformers
+pandas==2.3.3
+    # via gradio
+pillow==11.3.0
+    # via
+    #   diffusers
+    #   gradio
+    #   matplotlib
+psutil==5.9.8
+    # via spaces
+pydantic==2.11.10
+    # via
+    #   fastapi
+    #   gradio
+    #   spaces
+pydantic-core==2.33.2
+    # via pydantic
+pydub==0.25.1
+    # via gradio
+pygments==2.19.2
+    # via rich
+pyparsing==3.2.5
+    # via matplotlib
+python-dateutil==2.9.0.post0
+    # via
+    #   matplotlib
+    #   pandas
+python-multipart==0.0.20
+    # via gradio
+pytz==2025.2
+    # via pandas
+pyyaml==6.0.3
+    # via
+    #   gradio
+    #   huggingface-hub
+    #   transformers
+regex==2025.9.18
+    # via
+    #   diffusers
+    #   transformers
+requests==2.32.5
+    # via
+    #   diffusers
+    #   huggingface-hub
+    #   spaces
+    #   transformers
+rich==14.2.0
+    # via typer
+ruff==0.14.1
+    # via gradio
+safehttpx==0.1.6
+    # via gradio
+safetensors==0.6.2
+    # via
+    #   diffusers
+    #   transformers
+semantic-version==2.10.0
+    # via gradio
+shellingham==1.5.4
+    # via typer
+six==1.17.0
+    # via python-dateutil
+sniffio==1.3.1
+    # via anyio
+spaces==0.42.1
+    # via motion-latent-diffusion-standalone-demo (pyproject.toml)
+starlette==0.48.0
+    # via
+    #   fastapi
+    #   gradio
+sympy==1.14.0
+    # via torch
+tokenizers==0.22.1
+    # via transformers
+tomlkit==0.13.3
+    # via gradio
+torch==2.9.0
+    # via
+    #   motion-latent-diffusion-standalone-demo (pyproject.toml)
+    #   motion-latent-diffusion-standalone
+tqdm==4.67.1
+    # via
+    #   motion-latent-diffusion-standalone-demo (pyproject.toml)
+    #   huggingface-hub
+    #   transformers
+transformers==4.57.1
+    # via motion-latent-diffusion-standalone
+triton==3.5.0
+    # via torch
+typer==0.19.2
+    # via gradio
+typing-extensions==4.15.0
+    # via
+    #   anyio
+    #   fastapi
+    #   gradio
+    #   gradio-client
+    #   huggingface-hub
+    #   pydantic
+    #   pydantic-core
+    #   spaces
+    #   starlette
+    #   torch
+    #   typer
+    #   typing-inspection
+typing-inspection==0.4.2
+    # via pydantic
+tzdata==2025.2
+    # via pandas
+urllib3==2.5.0
+    # via requests
+uvicorn==0.38.0
+    # via gradio
+websockets==15.0.1
+    # via gradio-client
+zipp==3.23.0
+    # via importlib-metadata

visualize.py

@@ -0,0 +1,281 @@
+"""
+Simple 3D skeleton motion visualizer for HumanML3D motion data.
+Usage: python visualize.py <motion.pt> [--output output.mp4] [--fps 20]
+"""
+
+import argparse
+import numpy as np
+import torch
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation, FFMpegWriter
+from pathlib import Path
+
+
+# HumanML3D skeleton structure (22 joints)
+# Kinematic chain based on HumanML3D dataset specification
+# From mld/utils/joints.py and datasets/HumanML3D/paramUtil.py
+SKELETON_CHAINS = [
+    [0, 3, 6, 9, 12, 15],  # Body: root -> BP -> BT -> BLN -> BMN -> BUN (head)
+    [9, 14, 17, 19, 21],  # Left arm: BLN -> LSI -> LS -> LE -> LW
+    [9, 13, 16, 18, 20],  # Right arm: BLN -> RSI -> RS -> RE -> RW
+    [0, 2, 5, 8, 11],  # Left leg: root -> LH -> LK -> LMrot -> LF
+    [0, 1, 4, 7, 10],  # Right leg: root -> RH -> RK -> RMrot -> RF
+]
+
+
+def load_motion(pt_path: str) -> np.ndarray:
+    """
+    Load motion data from .pt file (PyTorch tensor).
+
+    HumanML3D format: (frames, 22, 3) where last dimension is (x, y, z)
+    In HumanML3D: Y is vertical (up), X and Z are horizontal
+    For proper 3D visualization: we'll map Y -> Z (vertical), X -> X, Z -> Y
+
+    Returns numpy array for matplotlib visualization.
+    """
+    # Load PyTorch tensor and convert to numpy for visualization
+    motion_tensor = torch.load(pt_path, map_location="cpu")
+    motion = motion_tensor.numpy()
+
+    print(f"Loaded motion: {motion.shape}")
+    print(f"  Frames: {motion.shape[0]}")
+    print(f"  Joints: {motion.shape[1]}")
+    print(f"  Dimensions: {motion.shape[2]}")
+
+    # Remap axes: HumanML3D (x, y, z) -> Visualization (x, z, y)
+    # This makes Y axis (vertical in HumanML3D) become Z axis (vertical in plot)
+    motion_remapped = motion.copy()
+    motion_remapped[:, :, [0, 1, 2]] = motion[:, :, [0, 2, 1]]  # x, z, y <- x, y, z
+
+    return motion_remapped
+
+
+def setup_3d_plot():
+    """Set up the 3D plot with proper viewing angle."""
+    fig = plt.figure(figsize=(10, 10))
+    ax = fig.add_subplot(111, projection="3d")
+
+    # Set labels
+    ax.set_xlabel("X")
+    ax.set_ylabel("Y")
+    ax.set_zlabel("Z")
+
+    return fig, ax
+
+
+def update_frame(frame_idx: int, motion: np.ndarray, ax, lines: list, points: list):
+    """Update function for animation."""
+    ax.clear()
+
+    # Get current frame
+    frame = motion[frame_idx]
+
+    # Set consistent axis limits based on all frames
+    all_coords = motion.reshape(-1, 3)
+    margin = 0.5
+    x_range = [all_coords[:, 0].min() - margin, all_coords[:, 0].max() + margin]
+    y_range = [all_coords[:, 1].min() - margin, all_coords[:, 1].max() + margin]
+    z_range = [0, all_coords[:, 2].max() + margin]  # Z starts at ground (0)
+
+    ax.set_xlim(x_range)
+    ax.set_ylim(y_range)
+    ax.set_zlim(z_range)
+
+    # Set labels and title
+    ax.set_xlabel("X", fontsize=10)
+    ax.set_ylabel("Y", fontsize=10)
+    ax.set_zlabel("Z (Height)", fontsize=10)
+    ax.set_title(f"Frame {frame_idx + 1}/{len(motion)}", fontsize=14, pad=20)
+
+    # Set viewing angle (slightly elevated, rotated for better view)
+    ax.view_init(elev=15, azim=45)
+
+    # Draw ground plane at z=0
+    xx, yy = np.meshgrid(
+        np.linspace(x_range[0], x_range[1], 2), np.linspace(y_range[0], y_range[1], 2)
+    )
+    zz = np.zeros_like(xx)
+    ax.plot_surface(xx, yy, zz, alpha=0.1, color="gray")
+
+    # Plot skeleton bones with different colors for different parts
+    colors = ["red", "blue", "green", "cyan", "magenta"]
+    for chain_idx, chain in enumerate(SKELETON_CHAINS):
+        color = colors[chain_idx % len(colors)]
+        for i in range(len(chain) - 1):
+            j1, j2 = chain[i], chain[i + 1]
+            if j1 < len(frame) and j2 < len(frame):
+                xs = [frame[j1, 0], frame[j2, 0]]
+                ys = [frame[j1, 1], frame[j2, 1]]
+                zs = [frame[j1, 2], frame[j2, 2]]
+                linewidth = 4.0 if chain_idx == 0 else 3.0  # Thicker for body
+                ax.plot(xs, ys, zs, color=color, linewidth=linewidth, alpha=0.8)
+
+    # Plot joints (darker red)
+    ax.scatter(
+        frame[:, 0],
+        frame[:, 1],
+        frame[:, 2],
+        c="darkred",
+        marker="o",
+        s=50,
+        alpha=0.9,
+        edgecolors="black",
+        linewidth=0.5,
+    )
+
+    # Add grid
+    ax.grid(True, alpha=0.3)
+
+    return (ax,)
+
+
+def create_video_from_joints(
+    joints: torch.Tensor | np.ndarray, output_path: str, fps: int = 20
+) -> str:
+    """
+    Create 3D skeleton animation directly from joint tensor or array.
+
+    Args:
+        joints: Joint positions as torch.Tensor or np.ndarray (frames, 22, 3)
+        output_path: Path to save video
+        fps: Frames per second for the video
+
+    Returns:
+        Path to output video
+    """
+    # Convert to numpy if it's a torch tensor
+    if isinstance(joints, torch.Tensor):
+        joints = joints.cpu().numpy()
+
+    # Remap axes for visualization (same as load_motion)
+    motion = joints.copy()
+    motion[:, :, [0, 1, 2]] = joints[:, :, [0, 2, 1]]  # x, z, y <- x, y, z
+
+    # Set up plot
+    fig, ax = setup_3d_plot()
+    lines, points = [], []
+
+    # Create animation
+    anim = FuncAnimation(
+        fig,
+        update_frame,
+        frames=len(motion),
+        fargs=(motion, ax, lines, points),
+        interval=1000 / fps,
+        blit=False,
+        repeat=True,
+    )
+
+    # Save video using FFMpeg
+    writer = FFMpegWriter(fps=fps, bitrate=1800, codec="libx264")
+    anim.save(str(output_path), writer=writer, dpi=100)
+
+    plt.close(fig)
+    return str(output_path)
+
+
+def visualize_motion(
+    pt_path: str, output_path: str | None = None, fps: int = 20, show: bool = False
+) -> str:
+    """
+    Visualize motion from .pt file (PyTorch tensor).
+
+    Args:
+        pt_path: Path to .pt motion file
+        output_path: Path to save video (if None, will auto-generate)
+        fps: Frames per second for the video
+        show: If True, display the animation in a window
+
+    Returns:
+        Path to the generated video file
+    """
+    # Load motion data (converts to numpy internally for matplotlib)
+    motion = load_motion(pt_path)
+
+    # Create output path if not specified
+    if output_path is None:
+        output_path = Path(pt_path).with_suffix(".mp4")
+    else:
+        output_path = Path(output_path)
+
+    print(f"\nCreating animation with {fps} FPS...")
+
+    # Set up plot
+    fig, ax = setup_3d_plot()
+    lines, points = [], []
+
+    # Create animation
+    anim = FuncAnimation(
+        fig,
+        update_frame,
+        frames=len(motion),
+        fargs=(motion, ax, lines, points),
+        interval=1000 / fps,
+        blit=False,
+        repeat=True,
+    )
+
+    # Save video using FFMpeg
+    print(f"Saving video to: {output_path}")
+    writer = FFMpegWriter(fps=fps, bitrate=1800, codec="libx264")
+    anim.save(str(output_path), writer=writer, dpi=100)
+    print("✓ Video saved successfully!")
+
+    # Show animation if requested
+    if show:
+        plt.show()
+
+    plt.close(fig)
+    return str(output_path)
+
+
+def main() -> int:
+    """Main entry point for CLI"""
+    parser = argparse.ArgumentParser(
+        description="Visualize HumanML3D motion data as 3D skeleton animation"
+    )
+    parser.add_argument("input", type=str, help="Path to input .pt motion file")
+    parser.add_argument(
+        "--output",
+        "-o",
+        type=str,
+        default=None,
+        help="Path to output video file (default: input_name.mp4)",
+    )
+    parser.add_argument(
+        "--fps",
+        type=int,
+        default=20,
+        help="Frames per second for output video (default: 20)",
+    )
+    parser.add_argument(
+        "--show",
+        action="store_true",
+        help="Display the animation in a window (in addition to saving)",
+    )
+
+    args = parser.parse_args()
+
+    # Check if input file exists
+    input_path = Path(args.input)
+    if not input_path.exists():
+        print(f"Error: Input file not found: {args.input}")
+        return 1
+
+    # Visualize the motion
+    try:
+        output_path = visualize_motion(
+            args.input, output_path=args.output, fps=args.fps, show=args.show
+        )
+        print(f"\n✓ Done! Video saved to: {output_path}")
+        return 0
+    except Exception as e:
+        print(f"\n✗ Error: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return 1
+
+
+if __name__ == "__main__":
+    exit(main())