vlalab 0.1.0__py3-none-any.whl

vlalab/__init__.py

@@ -0,0 +1,82 @@
+"""
+VLA-Lab: The missing toolkit for VLA model deployment.
+
+Debug, visualize, and analyze your VLA deployments in the real world.
+
+Quick Start:
+    import vlalab
+
+    # Initialize a run
+    run = vlalab.init(
+        project="pick_and_place",
+        config={
+            "model": "diffusion_policy",
+            "action_horizon": 8,
+        },
+    )
+
+    # Access config
+    print(f"Action horizon: {run.config.action_horizon}")
+
+    # Log steps
+    for step in range(100):
+        vlalab.log({
+            "state": obs["state"],
+            "action": action,
+            "images": {"front": obs["image"]},
+            "inference_latency_ms": latency,
+        })
+
+    # Finish (auto-called on exit)
+    vlalab.finish()
+
+Advanced API:
+    from vlalab import RunLogger
+    
+    logger = RunLogger(run_dir="runs/my_run", model_name="diffusion_policy")
+    logger.log_step(step_idx=0, state=[...], action=[...])
+    logger.close()
+"""
+
+__version__ = "0.1.0"
+
+# Simple API
+from vlalab.core import (
+    init,
+    log,
+    log_image,
+    finish,
+    get_run,
+    Run,
+    Config,
+    # Run discovery (uses same dir as init)
+    get_runs_dir,
+    list_projects,
+    list_runs,
+)
+
+# Advanced API
+from vlalab.logging import RunLogger
+from vlalab.schema import StepRecord, RunMeta, ImageRef
+
+__all__ = [
+    # Version
+    "__version__",
+    # Simple API
+    "init",
+    "log",
+    "log_image",
+    "finish",
+    "get_run",
+    "Run",
+    "Config",
+    # Run discovery
+    "get_runs_dir",
+    "list_projects",
+    "list_runs",
+    # Advanced API
+    "RunLogger",
+    "StepRecord",
+    "RunMeta",
+    "ImageRef",
+]

vlalab/adapters/__init__.py

@@ -0,0 +1,10 @@
+"""
+VLA-Lab Adapters Module
+
+Provides adapters for different VLA frameworks (Diffusion Policy, GR00T, etc.)
+"""
+
+from vlalab.adapters.dp_adapter import DPAdapter
+from vlalab.adapters.groot_adapter import GR00TAdapter
+
+__all__ = ["DPAdapter", "GR00TAdapter"]

vlalab/adapters/converter.py

@@ -0,0 +1,146 @@
+"""
+VLA-Lab Legacy Log Converter
+
+Convert old log formats to VLA-Lab run format.
+"""
+
+import json
+from pathlib import Path
+from datetime import datetime
+from typing import Dict, Any, Optional
+
+from vlalab.logging.run_logger import RunLogger
+from vlalab.adapters.dp_adapter import DPAdapter
+from vlalab.adapters.groot_adapter import GR00TAdapter
+
+
+def detect_log_format(log_path: Path) -> str:
+    """
+    Detect the format of a log file.
+    
+    Args:
+        log_path: Path to log file
+        
+    Returns:
+        Format string: "dp", "groot", or "unknown"
+    """
+    with open(log_path, "r") as f:
+        data = json.load(f)
+    
+    meta = data.get("meta", {})
+    
+    # Check for GR00T markers
+    if meta.get("model_type") == "groot":
+        return "groot"
+    
+    # Check for DP markers
+    if "checkpoint" in meta:
+        return "dp"
+    
+    # Check step format
+    steps = data.get("steps", [])
+    if steps:
+        first_step = steps[0]
+        if "input" in first_step:
+            input_data = first_step["input"]
+            if "state8" in input_data:
+                return "groot"
+            if "state" in input_data or "image_base64" in input_data:
+                return "dp"
+    
+    return "unknown"
+
+
+def convert_legacy_log(
+    input_path: Path,
+    output_dir: Path,
+    input_format: str = "auto",
+) -> Dict[str, Any]:
+    """
+    Convert a legacy log file to VLA-Lab run format.
+    
+    Args:
+        input_path: Path to input log file
+        output_dir: Path to output run directory
+        input_format: Input format ("dp", "groot", or "auto")
+        
+    Returns:
+        Statistics dictionary
+    """
+    input_path = Path(input_path)
+    output_dir = Path(output_dir)
+    
+    # Load input log
+    with open(input_path, "r") as f:
+        log_data = json.load(f)
+    
+    # Detect format if auto
+    if input_format == "auto":
+        input_format = detect_log_format(input_path)
+        if input_format == "unknown":
+            raise ValueError(f"Could not detect log format for {input_path}")
+    
+    # Select adapter
+    if input_format == "dp":
+        adapter = DPAdapter
+    elif input_format == "groot":
+        adapter = GR00TAdapter
+    else:
+        raise ValueError(f"Unknown format: {input_format}")
+    
+    # Extract metadata
+    meta_data = log_data.get("meta", {})
+    converted_meta = adapter.convert_meta(meta_data)
+    
+    # Create run logger
+    logger = RunLogger(
+        run_dir=output_dir,
+        model_name=converted_meta.get("model_name", "unknown"),
+        model_path=converted_meta.get("model_path"),
+        model_type=converted_meta.get("model_type"),
+        task_name="converted",
+    )
+    
+    # Convert steps
+    steps = log_data.get("steps", [])
+    image_count = 0
+    
+    for step_data in steps:
+        step_record = adapter.convert_step(
+            step_data,
+            run_dir=str(output_dir),
+            save_images=True,
+        )
+        
+        # Count images
+        image_count += len(step_record.obs.images)
+        
+        # Log step
+        logger.log_step_raw(
+            step_idx=step_record.step_idx,
+            obs_dict=step_record.obs.to_dict(),
+            action_dict=step_record.action.to_dict(),
+            timing_dict=step_record.timing.to_dict(),
+            prompt=step_record.prompt,
+            tags=step_record.tags,
+        )
+    
+    # Close logger
+    logger.close()
+    
+    return {
+        "steps": len(steps),
+        "images": image_count,
+        "format": input_format,
+        "output_dir": str(output_dir),
+    }
+
+
+def convert_dp_log(input_path: Path, output_dir: Path) -> Dict[str, Any]:
+    """Convenience function for DP logs."""
+    return convert_legacy_log(input_path, output_dir, "dp")
+
+
+def convert_groot_log(input_path: Path, output_dir: Path) -> Dict[str, Any]:
+    """Convenience function for GR00T logs."""
+    return convert_legacy_log(input_path, output_dir, "groot")

vlalab/adapters/dp_adapter.py

@@ -0,0 +1,181 @@
+"""
+VLA-Lab Adapter for Diffusion Policy (RealWorld-DP)
+
+Converts between DP log format and VLA-Lab unified format.
+"""
+
+from typing import Dict, Any, List, Optional
+import numpy as np
+
+from vlalab.schema.step import StepRecord, ObsData, ActionData, TimingData, ImageRef
+
+
+class DPAdapter:
+    """
+    Adapter for Diffusion Policy inference logs.
+    
+    DP log format (inference_log_*.json):
+    {
+        "meta": {
+            "checkpoint": "...",
+            "start_time": "..."
+        },
+        "steps": [
+            {
+                "step": 0,
+                "timing": {
+                    "client_send": float,
+                    "server_recv": float,
+                    "infer_start": float,
+                    "infer_end": float,
+                    "send_timestamp": float,
+                    "transport_latency_ms": float,
+                    "inference_latency_ms": float,
+                    "total_latency_ms": float,
+                    "message_interval_ms": float,
+                },
+                "input": {
+                    "state": [float, ...],
+                    "image_base64": "..."
+                },
+                "action": {
+                    "values": [[float, ...], ...]
+                }
+            },
+            ...
+        ]
+    }
+    """
+    
+    @staticmethod
+    def convert_step(
+        step_data: Dict[str, Any],
+        run_dir: Optional[str] = None,
+        save_images: bool = False,
+    ) -> StepRecord:
+        """
+        Convert a DP step to VLA-Lab StepRecord.
+        
+        Args:
+            step_data: DP step dictionary
+            run_dir: Run directory (for saving images)
+            save_images: Whether to save images to disk
+            
+        Returns:
+            StepRecord
+        """
+        step_idx = step_data.get("step", 0)
+        
+        # Convert timing
+        timing_raw = step_data.get("timing", {})
+        timing = TimingData(
+            client_send=timing_raw.get("client_send"),
+            server_recv=timing_raw.get("server_recv"),
+            infer_start=timing_raw.get("infer_start"),
+            infer_end=timing_raw.get("infer_end"),
+            send_timestamp=timing_raw.get("send_timestamp"),
+            transport_latency_ms=timing_raw.get("transport_latency_ms"),
+            inference_latency_ms=timing_raw.get("inference_latency_ms"),
+            total_latency_ms=timing_raw.get("total_latency_ms"),
+            message_interval_ms=timing_raw.get("message_interval_ms"),
+        )
+        
+        # Convert observation
+        input_data = step_data.get("input", {})
+        state = input_data.get("state", [])
+        
+        # Handle image
+        image_refs = []
+        image_b64 = input_data.get("image_base64")
+        if image_b64 and save_images and run_dir:
+            # Save image to disk
+            from vlalab.logging.run_logger import RunLogger
+            import base64
+            import cv2
+            
+            try:
+                img_data = base64.b64decode(image_b64)
+                img_array = np.frombuffer(img_data, dtype=np.uint8)
+                image = cv2.imdecode(img_array, cv2.IMREAD_COLOR)
+                image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+                
+                # Save image
+                from pathlib import Path
+                run_path = Path(run_dir)
+                images_dir = run_path / "artifacts" / "images"
+                images_dir.mkdir(parents=True, exist_ok=True)
+                
+                filename = f"step_{step_idx:06d}_default.jpg"
+                image_path = images_dir / filename
+                cv2.imwrite(str(image_path), image, [cv2.IMWRITE_JPEG_QUALITY, 85])
+                
+                image_refs.append(ImageRef(
+                    path=f"artifacts/images/{filename}",
+                    camera_name="default",
+                    shape=list(image_rgb.shape),
+                    encoding="jpeg",
+                ))
+            except Exception:
+                pass
+        
+        obs = ObsData(
+            state=state,
+            images=image_refs,
+        )
+        
+        # Convert action
+        action_raw = step_data.get("action", {})
+        action_values = action_raw.get("values", [])
+        action = ActionData(
+            values=action_values,
+            action_dim=len(action_values[0]) if action_values else None,
+            chunk_size=len(action_values) if action_values else None,
+        )
+        
+        return StepRecord(
+            step_idx=step_idx,
+            obs=obs,
+            action=action,
+            timing=timing,
+        )
+    
+    @staticmethod
+    def convert_meta(meta_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Convert DP metadata to VLA-Lab format.
+        
+        Args:
+            meta_data: DP meta dictionary
+            
+        Returns:
+            VLA-Lab meta dictionary
+        """
+        return {
+            "model_name": "diffusion_policy",
+            "model_path": meta_data.get("checkpoint"),
+            "model_type": "diffusion_policy",
+            "start_time": meta_data.get("start_time"),
+        }
+    
+    @staticmethod
+    def get_latency_ms(timing_dict: Dict[str, Any], key_base: str) -> float:
+        """
+        Get latency value in ms (compatible with old/new format).
+        
+        Args:
+            timing_dict: Timing dictionary
+            key_base: Base key name (e.g., 'transport_latency')
+            
+        Returns:
+            Latency in milliseconds
+        """
+        # Try new format (already in ms)
+        new_key = f"{key_base}_ms"
+        if new_key in timing_dict and timing_dict[new_key] is not None:
+            return timing_dict[new_key]
+        
+        # Try old format (in seconds)
+        if key_base in timing_dict and timing_dict[key_base] is not None:
+            return timing_dict[key_base] * 1000
+        
+        return 0.0

vlalab/adapters/groot_adapter.py

@@ -0,0 +1,148 @@
+"""
+VLA-Lab Adapter for Isaac-GR00T
+
+Converts between GR00T log format and VLA-Lab unified format.
+"""
+
+from typing import Dict, Any, List, Optional
+import numpy as np
+
+from vlalab.schema.step import StepRecord, ObsData, ActionData, TimingData, ImageRef
+
+
+class GR00TAdapter:
+    """
+    Adapter for GR00T inference logs.
+    
+    GR00T log format (inference_log_groot_*.json):
+    {
+        "meta": {
+            "model_path": "...",
+            "model_type": "groot",
+            "start_time": "..."
+        },
+        "steps": [
+            {
+                "step": 0,
+                "timing": {
+                    "client_send": float,
+                    "server_recv": float,
+                    "infer_start": float,
+                    "infer_end": float,
+                    "inference_latency_ms": float,
+                },
+                "input": {
+                    "state8": [float, ...],  # [x, y, z, qx, qy, qz, qw, gripper]
+                    "prompt": "..."
+                },
+                "action": {
+                    "action8": [[float, ...], ...]  # Chunk of 8D actions
+                }
+            },
+            ...
+        ]
+    }
+    """
+    
+    @staticmethod
+    def convert_step(
+        step_data: Dict[str, Any],
+        run_dir: Optional[str] = None,
+        save_images: bool = False,
+    ) -> StepRecord:
+        """
+        Convert a GR00T step to VLA-Lab StepRecord.
+        
+        Args:
+            step_data: GR00T step dictionary
+            run_dir: Run directory (for saving images)
+            save_images: Whether to save images to disk
+            
+        Returns:
+            StepRecord
+        """
+        step_idx = step_data.get("step", 0)
+        
+        # Convert timing
+        timing_raw = step_data.get("timing", {})
+        timing = TimingData(
+            client_send=timing_raw.get("client_send"),
+            server_recv=timing_raw.get("server_recv"),
+            infer_start=timing_raw.get("infer_start"),
+            infer_end=timing_raw.get("infer_end"),
+            inference_latency_ms=timing_raw.get("inference_latency_ms"),
+        )
+        
+        # Compute additional latencies if possible
+        if timing.server_recv and timing.client_send:
+            timing.transport_latency_ms = (timing.server_recv - timing.client_send) * 1000
+        
+        # Convert observation
+        input_data = step_data.get("input", {})
+        state8 = input_data.get("state8", [])
+        prompt = input_data.get("prompt")
+        
+        # Parse state8: [x, y, z, qx, qy, qz, qw, gripper]
+        pose = state8[:7] if len(state8) >= 7 else None
+        gripper = state8[7] if len(state8) >= 8 else None
+        
+        obs = ObsData(
+            state=state8,
+            images=[],  # GR00T logs typically don't include images
+            pose=pose,
+            gripper=gripper,
+        )
+        
+        # Convert action
+        action_raw = step_data.get("action", {})
+        action8 = action_raw.get("action8", [])
+        
+        action = ActionData(
+            values=action8,
+            action_dim=len(action8[0]) if action8 else 8,
+            chunk_size=len(action8) if action8 else None,
+        )
+        
+        return StepRecord(
+            step_idx=step_idx,
+            obs=obs,
+            action=action,
+            timing=timing,
+            prompt=prompt,
+        )
+    
+    @staticmethod
+    def convert_meta(meta_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Convert GR00T metadata to VLA-Lab format.
+        
+        Args:
+            meta_data: GR00T meta dictionary
+            
+        Returns:
+            VLA-Lab meta dictionary
+        """
+        return {
+            "model_name": "groot",
+            "model_path": meta_data.get("model_path"),
+            "model_type": "groot",
+            "start_time": meta_data.get("start_time"),
+        }
+    
+    @staticmethod
+    def state8_to_pose_gripper(state8: List[float]) -> tuple:
+        """
+        Parse state8 into pose and gripper.
+        
+        Args:
+            state8: [x, y, z, qx, qy, qz, qw, gripper]
+            
+        Returns:
+            (pose_7d, gripper)
+        """
+        if len(state8) >= 8:
+            return state8[:7], state8[7]
+        elif len(state8) >= 7:
+            return state8[:7], None
+        else:
+            return state8, None

vlalab/apps/__init__.py

@@ -0,0 +1 @@
+"""VLA-Lab Apps Module"""

vlalab/apps/streamlit/__init__.py

@@ -0,0 +1 @@
+"""VLA-Lab Streamlit App"""

vlalab/apps/streamlit/app.py

@@ -0,0 +1,103 @@
+"""
+VLA-Lab Streamlit Multi-Page Application
+
+Main entry point for the visualization app.
+Usage: streamlit run app.py
+"""
+
+import streamlit as st
+from pathlib import Path
+
+# Page config must be the first Streamlit command
+st.set_page_config(
+    page_title="VLA-Lab",
+    page_icon="🤖",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+# Setup matplotlib fonts
+try:
+    from vlalab.viz.mpl_fonts import setup_matplotlib_fonts
+    setup_matplotlib_fonts(verbose=False)
+except Exception:
+    pass
+
+
+def main():
+    st.sidebar.title("🤖 VLA-Lab")
+    st.sidebar.markdown("---")
+    
+    # Navigation
+    pages = {
+        "🏠 Home": "home",
+        "🔬 Inference Runs": "inference",
+        "📊 Dataset Viewer": "dataset",
+        "📈 Latency Analysis": "latency",
+    }
+    
+    selection = st.sidebar.radio("Navigate", list(pages.keys()))
+    
+    page_name = pages[selection]
+    
+    if page_name == "home":
+        show_home_page()
+    elif page_name == "inference":
+        from vlalab.apps.streamlit.pages import inference_viewer
+        inference_viewer.render()
+    elif page_name == "dataset":
+        from vlalab.apps.streamlit.pages import dataset_viewer
+        dataset_viewer.render()
+    elif page_name == "latency":
+        from vlalab.apps.streamlit.pages import latency_viewer
+        latency_viewer.render()
+    
+    # Footer
+    st.sidebar.markdown("---")
+    st.sidebar.caption("VLA-Lab v0.1.0")
+
+
+def show_home_page():
+    st.title("🤖 VLA-Lab")
+    st.markdown("""
+    **A toolbox for tracking and visualizing the real-world deployment process of VLA models.**
+    
+    ### Features
+    
+    - **🔬 Inference Run Viewer**: Replay and analyze policy inference sessions
+      - Step-by-step visualization with multi-camera support
+      - 3D trajectory and action visualization
+      - Latency breakdown analysis
+    
+    - **📊 Dataset Viewer**: Browse and analyze training/evaluation datasets
+      - Zarr dataset support (Diffusion Policy format)
+      - Episode navigation with image grid view
+      - Action trajectory analysis
+    
+    - **📈 Latency Analysis**: Deep dive into timing metrics
+      - Transport latency (network)
+      - Inference latency (GPU)
+      - End-to-end loop time
+    
+    ### Supported Frameworks
+    
+    | Framework | Status |
+    |-----------|--------|
+    | RealWorld-DP (Diffusion Policy) | ✅ Supported |
+    | Isaac-GR00T | ✅ Supported |
+    
+    ### Quick Start
+    
+    1. **View inference logs**: Select "🔬 Inference Runs" from the sidebar
+    2. **Browse datasets**: Select "📊 Dataset Viewer" from the sidebar
+    3. **Analyze latency**: Select "📈 Latency Analysis" from the sidebar
+    
+    ---
+    
+    📖 [Documentation](https://github.com/VLA-Lab/VLA-Lab) | 
+    🐛 [Report Issues](https://github.com/VLA-Lab/VLA-Lab/issues)
+    """)
+
+
+if __name__ == "__main__":
+    main()

vlalab/apps/streamlit/pages/__init__.py

@@ -0,0 +1 @@
+"""VLA-Lab Streamlit Pages"""