Fresh start: Absolute minimal Gradio app

README.md

@@ -4,34 +4,12 @@ emoji: 🎯
 colorFrom: blue
 colorTo: purple
 sdk: gradio
-sdk_version: 4.44.1
+sdk_version: 4.0.0
 app_file: app.py
 pinned: false
-license: mit
 ---
 
 # Trajectory End Point Labeler
 
-A tool for labeling trajectory end points in robot/human demonstration datasets from HuggingFace.
+Testing basic Gradio deployment on HuggingFace Spaces.
 
-## Features
-
-- 🎯 **Frame-Accurate Video Player**: Shows current frame number (0-N) with percentage
-- 📊 **Pattern Analysis**: Analyzes manually labeled end points to detect patterns
-- 🤖 **Auto-Labeling**: Automatically labels similar trajectories based on detected patterns
-- 💾 **CSV Export**: Saves all labels with metadata
-
-## Usage
-
-1. Enter a dataset repository (e.g., `jesbu1/epic_rfm`)
-2. Optionally specify config name
-3. Set number of human and robot samples to load
-4. Navigate videos and label end points
-5. Analyze patterns after labeling all trajectories
-
-## Output
-
-Labels are saved to CSV with:
-- Dataset info, trajectory IDs, end frames/percentages
-- Task descriptions
-- Pattern analysis results

app.py

@@ -1,14 +1,8 @@
-"""
-Trajectory End Point Labeler - Step 1: Minimal test
-"""
-
 import gradio as gr
 
-# Minimal interface to test Spaces deployment
 demo = gr.Interface(
-    fn=lambda name: f"Hello {name}! App is working.",
-    inputs=gr.Textbox(label="Enter your name"),
-    outputs=gr.Textbox(label="Result"),
-    title="Trajectory End Point Labeler",
-    description="Testing deployment - will add features incrementally"
+    fn=lambda x: f"You entered: {x}",
+    inputs="text",
+    outputs="text"
 )
+

dataset_discovery.py

@@ -1,207 +0,0 @@
-#!/usr/bin/env python3
-"""
-Discover and analyze datasets from HuggingFace Hub.
-Checks for datasets with both human and robot data.
-"""
-
-import random
-from collections import defaultdict
-from typing import Dict, List, Optional, Tuple
-
-from datasets import load_dataset
-from huggingface_hub import HfApi, list_datasets
-from tqdm import tqdm
-
-
-def list_rewardfm_datasets() -> List[str]:
-    """List all datasets from rewardfm organization/users."""
-    api = HfApi()
-    
-    # Known datasets - you can add more here
-    known_datasets = [
-        "jesbu1/epic_rfm",
-        "abraranwar/libero_rfm",
-        "ykorkmaz/libero_failure_rfm",
-        "jesbu1/oxe_rfm",
-        "jesbu1/oxe_rfm_eval",
-        "aliangdw/metaworld_rfm",
-        "HenryZhang/metaworld_rewind_rfm_train",
-        "HenryZhang/metaworld_rewind_rfm_eval",
-        "ykorkmaz/h2r_rfm",
-        "abraranwar/agibotworld_rfm",
-        "abraranwar/egodex_rfm",
-    ]
-    
-    datasets = known_datasets.copy()
-    
-    # Also search for datasets with known patterns
-    search_terms = ["rfm"]
-    
-    for term in search_terms:
-        try:
-            results = list_datasets(search=term, sort="downloads", direction=-1, limit=50)
-            for ds in results:
-                repo_id = ds.id
-                if repo_id not in datasets:
-                    datasets.append(repo_id)
-        except Exception as e:
-            print(f"Warning: Could not search for {term}: {e}")
-    
-    return datasets
-
-
-def check_dataset_has_both_types(dataset_repo: str, config_name: Optional[str] = None) -> Tuple[bool, Dict]:
-    """
-    Check if dataset has both human and robot trajectories.
-    
-    Returns:
-        (has_both, stats) where stats contains counts and info
-    """
-    try:
-        if config_name:
-            dataset = load_dataset(dataset_repo, config_name, split="train", streaming=True)
-        else:
-            dataset = load_dataset(dataset_repo, split="train", streaming=True)
-        
-        human_count = 0
-        robot_count = 0
-        total_checked = 0
-        max_samples_to_check = 1000
-        
-        for sample in dataset:
-            total_checked += 1
-            is_robot = sample.get("is_robot", False)
-            
-            if is_robot:
-                robot_count += 1
-            else:
-                human_count += 1
-            
-            if human_count > 0 and robot_count > 0:
-                return True, {
-                    "human_count": human_count,
-                    "robot_count": robot_count,
-                    "checked": total_checked,
-                    "has_both": True
-                }
-            
-            if total_checked >= max_samples_to_check:
-                break
-        
-        return False, {
-            "human_count": human_count,
-            "robot_count": robot_count,
-            "checked": total_checked,
-            "has_both": False
-        }
-        
-    except Exception as e:
-        return False, {"error": str(e)}
-
-
-def sample_trajectories(
-    dataset_repo: str,
-    config_name: Optional[str] = None,
-    is_robot: bool = True,
-    num_samples: int = 10,
-    max_to_check: int = 10000
-) -> List[Dict]:
-    """
-    Sample random trajectories of a specific type (human or robot).
-    
-    Args:
-        dataset_repo: HuggingFace dataset repository ID
-        config_name: Optional config name for the dataset
-        is_robot: If True, sample robot trajectories; else human
-        num_samples: Number of trajectories to sample
-        max_to_check: Maximum number of trajectories to check
-    
-    Returns:
-        List of trajectory dictionaries
-    """
-    try:
-        if config_name:
-            dataset = load_dataset(dataset_repo, config_name, split="train", streaming=True)
-        else:
-            dataset = load_dataset(dataset_repo, split="train", streaming=True)
-        
-        matching_trajectories = []
-        checked = 0
-        
-        # Collect all matching trajectories up to max_to_check
-        for sample in dataset:
-            checked += 1
-            if sample.get("is_robot", False) == is_robot:
-                matching_trajectories.append(sample)
-            
-            if checked >= max_to_check:
-                break
-        
-        # Randomly sample from collected trajectories
-        if len(matching_trajectories) == 0:
-            return []
-        
-        if len(matching_trajectories) <= num_samples:
-            # If we have fewer or equal, return all (shuffled for randomness)
-            random.shuffle(matching_trajectories)
-            return matching_trajectories
-        else:
-            # Randomly sample exactly num_samples
-            return random.sample(matching_trajectories, num_samples)
-        
-    except Exception as e:
-        print(f"Error sampling trajectories: {e}")
-        return []
-
-
-def discover_datasets_with_both_types() -> Dict[str, Dict]:
-    """
-    Discover all datasets that have both human and robot data.
-    
-    Returns:
-        Dictionary mapping dataset_repo -> stats
-    """
-    print("🔍 Discovering datasets...")
-    all_datasets = list_rewardfm_datasets()
-    
-    print(f"Found {len(all_datasets)} potential datasets")
-    print("Checking for datasets with both human and robot data...\n")
-    
-    results = {}
-    
-    for dataset_repo in tqdm(all_datasets, desc="Checking datasets"):
-        # Try to load with and without config name
-        has_both, stats = check_dataset_has_both_types(dataset_repo)
-        
-        if has_both:
-            results[dataset_repo] = stats
-            print(f"✅ {dataset_repo}: {stats['human_count']} human, {stats['robot_count']} robot")
-        
-        # Also check with config names if available
-        try:
-            from huggingface_hub import HfApi
-            api = HfApi()
-            dataset_info = api.dataset_info(dataset_repo)
-            if hasattr(dataset_info, 'configs') and dataset_info.configs:
-                for config in dataset_info.configs:
-                    config_name = config.config_name
-                    has_both, stats = check_dataset_has_both_types(dataset_repo, config_name)
-                    if has_both:
-                        repo_with_config = f"{dataset_repo}/{config_name}"
-                        results[repo_with_config] = stats
-                        print(f"✅ {repo_with_config}: {stats['human_count']} human, {stats['robot_count']} robot")
-        except Exception as e:
-            # Skip if can't get config info
-            pass
-    
-    return results
-
-
-if __name__ == "__main__":
-    # Example usage
-    results = discover_datasets_with_both_types()
-    print("\n" + "="*60)
-    print(f"Found {len(results)} datasets with both human and robot data:")
-    for repo, stats in results.items():
-        print(f"  {repo}: {stats}")
-

labeler_app.py

@@ -1,604 +0,0 @@
-#!/usr/bin/env python3
-"""
-Main Gradio app for labeling trajectory end points.
-Features:
-- Video player with frame counter
-- Manual labeling interface
-- Pattern analysis and auto-labeling
-"""
-
-import os
-from pathlib import Path
-from typing import Dict, List, Optional, Tuple
-
-import cv2
-import gradio as gr
-import numpy as np
-import pandas as pd
-
-from dataset_discovery import sample_trajectories
-from video_downloader import VideoDownloader
-
-
-class TrajectoryLabeler:
-    """Main labeling application."""
-    
-    def __init__(self, cache_dir: str = "video_cache", labels_file: str = "labels.csv"):
-        self.downloader = VideoDownloader(cache_dir)
-        self.labels_file = Path(labels_file)
-        self.labels = self._load_labels()
-        self.current_trajectories = []
-        self.current_idx = 0
-        
-    def _load_labels(self) -> pd.DataFrame:
-        """Load existing labels from CSV."""
-        if self.labels_file.exists():
-            df = pd.read_csv(self.labels_file)
-            # Add task column if it doesn't exist (for backward compatibility)
-            if 'task' not in df.columns:
-                df['task'] = ''
-            return df
-        else:
-            # Create empty DataFrame with columns
-            return pd.DataFrame(columns=[
-                "dataset_repo", "config_name", "trajectory_id", "is_robot",
-                "task", "manual_end_frame", "manual_end_percent", "auto_labeled",
-                "pattern_matched", "notes"
-            ])
-    
-    def _save_labels(self):
-        """Save labels to CSV."""
-        # Ensure columns are in the correct order
-        column_order = [
-            "dataset_repo", "config_name", "trajectory_id", "is_robot",
-            "task", "manual_end_frame", "manual_end_percent", "auto_labeled",
-            "pattern_matched", "notes"
-        ]
-        # Only include columns that exist
-        existing_columns = [col for col in column_order if col in self.labels.columns]
-        # Add any other columns that might exist
-        other_columns = [col for col in self.labels.columns if col not in column_order]
-        final_order = existing_columns + other_columns
-        
-        self.labels[final_order].to_csv(self.labels_file, index=False)
-    
-    def load_dataset_trajectories(
-        self,
-        dataset_repo: str,
-        config_name: Optional[str] = None,
-        num_human: int = 10,
-        num_robot: int = 10
-    ) -> Tuple[str, List[Dict]]:
-        """Load and download trajectories for a dataset."""
-        try:
-            # Sample human trajectories
-            human_trajs = sample_trajectories(dataset_repo, config_name, is_robot=False, num_samples=num_human)
-            # Sample robot trajectories
-            robot_trajs = sample_trajectories(dataset_repo, config_name, is_robot=True, num_samples=num_robot)
-            
-            all_trajectories = human_trajs + robot_trajs
-            
-            # Download videos
-            downloaded = self.downloader.download_trajectories(all_trajectories, dataset_repo, config_name)
-            
-            self.current_trajectories = downloaded
-            self.current_idx = 0
-            
-            return f"✅ Loaded {len(downloaded)} trajectories ({len([t for t in downloaded if not t.get('is_robot')])} human, {len([t for t in downloaded if t.get('is_robot')])} robot)", downloaded
-            
-        except Exception as e:
-            return f"❌ Error: {str(e)}", []
-    
-    def extract_frame(self, video_path: str, frame_num: int) -> Optional[np.ndarray]:
-        """Extract a specific frame from video."""
-        cap = cv2.VideoCapture(video_path)
-        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-        
-        if frame_num >= total_frames:
-            frame_num = total_frames - 1
-        
-        cap.set(cv2.CAP_PROP_POS_FRAMES, frame_num)
-        ret, frame = cap.read()
-        cap.release()
-        
-        if ret:
-            # Convert BGR to RGB for display
-            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-            return frame_rgb
-        return None
-    
-    def get_current_trajectory(self) -> Optional[Dict]:
-        """Get current trajectory."""
-        if 0 <= self.current_idx < len(self.current_trajectories):
-            return self.current_trajectories[self.current_idx]
-        return None
-    
-    def next_trajectory(self):
-        """Move to next trajectory."""
-        if self.current_idx < len(self.current_trajectories) - 1:
-            self.current_idx += 1
-        return self.current_idx
-    
-    def prev_trajectory(self):
-        """Move to previous trajectory."""
-        if self.current_idx > 0:
-            self.current_idx -= 1
-        return self.current_idx
-    
-    def save_label(
-        self,
-        trajectory_id: str,
-        dataset_repo: str,
-        config_name: str,
-        is_robot: bool,
-        end_frame: int,
-        task: str = "",
-        notes: str = ""
-    ):
-        """Save a manual label. Only one label per trajectory_id."""
-        # Calculate percentage
-        traj = next((t for t in self.current_trajectories if t.get('id') == trajectory_id), None)
-        if not traj:
-            return "Trajectory not found"
-        
-        video_path = traj.get('local_video_path')
-        if not video_path:
-            return "Video path not found"
-        
-        cap = cv2.VideoCapture(video_path)
-        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-        cap.release()
-        
-        end_percent = (end_frame / total_frames * 100) if total_frames > 0 else 0
-        
-        # Check if label already exists for this trajectory
-        existing_mask = (
-            (self.labels['dataset_repo'] == dataset_repo) &
-            (self.labels['config_name'] == (config_name or "")) &
-            (self.labels['trajectory_id'] == trajectory_id) &
-            (self.labels['auto_labeled'] == False)  # Only check manual labels
-        )
-        
-        if existing_mask.any():
-            # Update existing label
-            idx = self.labels[existing_mask].index[0]
-            self.labels.at[idx, 'manual_end_frame'] = end_frame
-            self.labels.at[idx, 'manual_end_percent'] = end_percent
-            self.labels.at[idx, 'task'] = task
-            self.labels.at[idx, 'notes'] = notes
-            self._save_labels()
-            return f"✅ Updated label: Frame {end_frame} ({end_percent:.1f}%)"
-        
-        # Add new label
-        new_row = {
-            "dataset_repo": dataset_repo,
-            "config_name": config_name or "",
-            "trajectory_id": trajectory_id,
-            "is_robot": is_robot,
-            "task": task,
-            "manual_end_frame": end_frame,
-            "manual_end_percent": end_percent,
-            "auto_labeled": False,
-            "pattern_matched": False,
-            "notes": notes
-        }
-        
-        self.labels = pd.concat([self.labels, pd.DataFrame([new_row])], ignore_index=True)
-        self._save_labels()
-        
-        return f"✅ Saved label: Frame {end_frame} ({end_percent:.1f}%)"
-    
-    def analyze_patterns(
-        self, 
-        dataset_repo: str, 
-        config_name: Optional[str], 
-        is_robot: bool,
-        expected_count: Optional[int] = None
-    ) -> Dict:
-        """
-        Analyze patterns in manually labeled end points.
-        Only works when all expected trajectories are labeled.
-        """
-        # Filter labels for this dataset and type
-        filtered = self.labels[
-            (self.labels['dataset_repo'] == dataset_repo) &
-            (self.labels['config_name'] == (config_name or "")) &
-            (self.labels['is_robot'] == is_robot) &
-            (self.labels['auto_labeled'] == False)
-        ]
-        
-        labeled_count = len(filtered)
-        
-        # Check if all trajectories are labeled
-        if expected_count is not None:
-            if labeled_count < expected_count:
-                return {
-                    "pattern_found": False,
-                    "error": True,
-                    "message": f"Only {labeled_count}/{expected_count} trajectories labeled. Please label all trajectories before analyzing patterns.",
-                    "labeled_count": labeled_count,
-                    "expected_count": expected_count
-                }
-        
-        if labeled_count < 3:
-            return {
-                "pattern_found": False,
-                "error": True,
-                "message": "Need at least 3 manual labels to detect pattern",
-                "labeled_count": labeled_count
-            }
-        
-        # Calculate statistics
-        end_percents = filtered['manual_end_percent'].values
-        mean_percent = np.mean(end_percents)
-        std_percent = np.std(end_percents)
-        min_percent = np.min(end_percents)
-        max_percent = np.max(end_percents)
-        quantile_90 = np.percentile(end_percents, 90)
-        median_percent = np.median(end_percents)
-        
-        # Consider it a pattern if std < 10%
-        if std_percent < 10:
-            return {
-                "pattern_found": True,
-                "error": False,
-                "mean_percent": round(mean_percent, 2),
-                "median_percent": round(median_percent, 2),
-                "std_percent": round(std_percent, 2),
-                "min_percent": round(min_percent, 2),
-                "max_percent": round(max_percent, 2),
-                "quantile_90": round(quantile_90, 2),
-                "count": labeled_count,
-                "suggested_label": round(mean_percent)
-            }
-        else:
-            return {
-                "pattern_found": False,
-                "error": False,
-                "mean_percent": round(mean_percent, 2),
-                "median_percent": round(median_percent, 2),
-                "std_percent": round(std_percent, 2),
-                "min_percent": round(min_percent, 2),
-                "max_percent": round(max_percent, 2),
-                "quantile_90": round(quantile_90, 2),
-                "count": labeled_count,
-                "message": f"High variance ({std_percent:.1f}%) - no clear pattern"
-            }
-    
-    def auto_label_similar(
-        self,
-        dataset_repo: str,
-        config_name: Optional[str],
-        is_robot: bool,
-        target_percent: float,
-        threshold: float = 5.0
-    ) -> str:
-        """Auto-label trajectories similar to the pattern."""
-        # Find unlabeled trajectories
-        labeled_ids = set(self.labels[
-            (self.labels['dataset_repo'] == dataset_repo) &
-            (self.labels['config_name'] == (config_name or "")) &
-            (self.labels['is_robot'] == is_robot)
-        ]['trajectory_id'].values)
-        
-        # Load all trajectories for this dataset
-        all_human = sample_trajectories(dataset_repo, config_name, is_robot=False, num_samples=1000)
-        all_robot = sample_trajectories(dataset_repo, config_name, is_robot=True, num_samples=1000)
-        all_trajs = (all_human if not is_robot else all_robot)
-        
-        # Filter unlabeled
-        unlabeled = [t for t in all_trajs if t.get('id') not in labeled_ids]
-        
-        # For each unlabeled trajectory, label with target_percent
-        labeled_count = 0
-        for traj in unlabeled[:100]:  # Limit to 100 for performance
-            video_path = self.downloader.download_video(traj, dataset_repo, config_name)
-            if not video_path:
-                continue
-            
-            cap = cv2.VideoCapture(video_path)
-            total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-            cap.release()
-            
-            end_frame = int(total_frames * target_percent / 100)
-            
-            new_row = {
-                "dataset_repo": dataset_repo,
-                "config_name": config_name or "",
-                "trajectory_id": traj.get('id'),
-                "is_robot": is_robot,
-                "task": traj.get('task', ''),
-                "manual_end_frame": end_frame,
-                "manual_end_percent": target_percent,
-                "auto_labeled": True,
-                "pattern_matched": True,
-                "notes": f"Auto-labeled based on pattern: {target_percent:.1f}%"
-            }
-            
-            self.labels = pd.concat([self.labels, pd.DataFrame([new_row])], ignore_index=True)
-            labeled_count += 1
-        
-        self._save_labels()
-        return f"✅ Auto-labeled {labeled_count} trajectories with {target_percent:.1f}%"
-
-
-def create_gradio_interface():
-    """Create the Gradio interface."""
-    labeler = TrajectoryLabeler()
-    
-    with gr.Blocks(title="Trajectory End Point Labeler") as demo:
-        gr.Markdown("# Trajectory End Point Labeler")
-        gr.Markdown("Label the success completion point for robot/human trajectories")
-        
-        with gr.Row():
-            with gr.Column(scale=1):
-                dataset_repo_input = gr.Textbox(
-                    label="Dataset Repository",
-                    placeholder="jesbu1/epic_rfm",
-                    value="jesbu1/epic_rfm"
-                )
-                config_name_input = gr.Textbox(
-                    label="Config Name (optional)",
-                    placeholder="Leave empty if no config"
-                )
-                num_human_input = gr.Number(label="Human Samples", value=10, precision=0)
-                num_robot_input = gr.Number(label="Robot Samples", value=10, precision=0)
-                load_btn = gr.Button("Load Dataset", variant="primary")
-                load_status = gr.Textbox(label="Status", interactive=False)
-            
-            with gr.Column(scale=2):
-                # Trajectory info and navigation
-                traj_info = gr.Textbox(label="Current Trajectory", interactive=False)
-                task_display = gr.Textbox(label="Task Description", interactive=False)
-                with gr.Row():
-                    prev_btn = gr.Button("← Previous", variant="secondary")
-                    next_btn = gr.Button("Next →", variant="secondary")
-                
-                # Video player
-                video_output = gr.Video(label="Video Player (64 frames)")
-                frame_slider = gr.Slider(
-                    minimum=0,
-                    maximum=63,
-                    step=1,
-                    value=0,
-                    label="Frame Number (0-63)"
-                )
-                current_frame_img = gr.Image(label="Current Frame Preview")
-                
-                # Labeling controls
-                with gr.Row():
-                    end_frame_input = gr.Number(label="End Frame", value=0, precision=0)
-                    end_percent_display = gr.Textbox(label="End Percent", interactive=False)
-                notes_input = gr.Textbox(label="Notes", placeholder="Optional notes...")
-                save_label_btn = gr.Button("Save Label", variant="primary")
-                label_status = gr.Textbox(label="Label Status", interactive=False)
-        
-        # Pattern analysis section
-        with gr.Row():
-            with gr.Column():
-                analyze_btn = gr.Button("Analyze Pattern")
-                pattern_output = gr.JSON(label="Pattern Analysis")
-            
-            with gr.Column():
-                auto_label_percent = gr.Number(label="Target Percent", value=95.0)
-                auto_label_btn = gr.Button("Auto-Label Similar", variant="secondary")
-                auto_label_status = gr.Textbox(label="Auto-Label Status")
-        
-        # Load dataset handler
-        def load_dataset(dataset_repo, config_name, num_human, num_robot):
-            config = config_name.strip() if config_name else None
-            status, trajectories = labeler.load_dataset_trajectories(
-                dataset_repo, config, int(num_human), int(num_robot)
-            )
-            
-            if trajectories:
-                # Update frame slider max and show first trajectory
-                first_traj = trajectories[0]
-                first_video = first_traj.get('local_video_path')
-                if first_video and os.path.exists(first_video):
-                    cap = cv2.VideoCapture(first_video)
-                    max_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-                    cap.release()
-                    
-                    traj_info = f"Trajectory 1/{len(trajectories)} | ID: {first_traj.get('id', 'unknown')[:20]}... | Type: {'Robot' if first_traj.get('is_robot') else 'Human'}"
-                    task_desc = first_traj.get('task', 'No task description')
-                    
-                    return (
-                        status,
-                        traj_info,
-                        task_desc,
-                        gr.update(maximum=max_frames-1, value=0),
-                        first_video,
-                        None,
-                        "0.0%"
-                    )
-            
-            return status, "No trajectories loaded", "", gr.update(), None, None, "0.0%"
-        
-        # Trajectory navigation handlers
-        def navigate_next():
-            idx = labeler.next_trajectory()
-            traj = labeler.get_current_trajectory()
-            if traj:
-                video_path = traj.get('local_video_path')
-                if video_path and os.path.exists(video_path):
-                    cap = cv2.VideoCapture(video_path)
-                    max_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-                    cap.release()
-                    
-                    traj_info = f"Trajectory {idx+1}/{len(labeler.current_trajectories)} | ID: {traj.get('id', 'unknown')[:20]}... | Type: {'Robot' if traj.get('is_robot') else 'Human'}"
-                    task_desc = traj.get('task', 'No task description')
-                    
-                    return (
-                        traj_info,
-                        task_desc,
-                        gr.update(maximum=max_frames-1, value=0),
-                        video_path,
-                        None,
-                        "0.0%"
-                    )
-            return "No more trajectories", "", gr.update(), None, None, "0.0%"
-        
-        def navigate_prev():
-            idx = labeler.prev_trajectory()
-            traj = labeler.get_current_trajectory()
-            if traj:
-                video_path = traj.get('local_video_path')
-                if video_path and os.path.exists(video_path):
-                    cap = cv2.VideoCapture(video_path)
-                    max_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-                    cap.release()
-                    
-                    traj_info = f"Trajectory {idx+1}/{len(labeler.current_trajectories)} | ID: {traj.get('id', 'unknown')[:20]}... | Type: {'Robot' if traj.get('is_robot') else 'Human'}"
-                    task_desc = traj.get('task', 'No task description')
-                    
-                    return (
-                        traj_info,
-                        task_desc,
-                        gr.update(maximum=max_frames-1, value=0),
-                        video_path,
-                        None,
-                        "0.0%"
-                    )
-            return "No more trajectories", "", gr.update(), None, None, "0.0%"
-        
-        # Frame navigation handler
-        def show_frame(video_path, frame_num):
-            if not video_path or not os.path.exists(video_path):
-                return None, "0.0%"
-            
-            frame_num = int(frame_num)
-            frame = labeler.extract_frame(video_path, frame_num)
-            
-            # Calculate percent
-            cap = cv2.VideoCapture(video_path)
-            total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-            cap.release()
-            
-            percent = (frame_num / total_frames * 100) if total_frames > 0 else 0
-            
-            return frame, f"{percent:.1f}%"
-        
-        def update_end_percent(video_path, end_frame):
-            if not video_path or not os.path.exists(video_path):
-                return "0.0%"
-            
-            cap = cv2.VideoCapture(video_path)
-            total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-            cap.release()
-            
-            percent = (int(end_frame) / total_frames * 100) if total_frames > 0 else 0
-            return f"{percent:.1f}%"
-        
-        # Save label handler
-        def save_label_handler(dataset_repo, config_name, end_frame, notes):
-            if not labeler.current_trajectories:
-                return "No trajectories loaded"
-            
-            traj = labeler.current_trajectories[labeler.current_idx]
-            task_desc = traj.get('task', '')
-            result = labeler.save_label(
-                traj.get('id'),
-                dataset_repo,
-                config_name,
-                traj.get('is_robot', False),
-                int(end_frame),
-                task_desc,
-                notes
-            )
-            return result
-        
-        # Pattern analysis handler
-        def analyze_pattern_handler(dataset_repo, config_name):
-            if not labeler.current_trajectories:
-                return {"error": True, "message": "No trajectories loaded"}
-            
-            traj = labeler.current_trajectories[labeler.current_idx]
-            is_robot = traj.get('is_robot', False)
-            
-            # Count expected trajectories for this type
-            expected_count = len([
-                t for t in labeler.current_trajectories 
-                if t.get('is_robot', False) == is_robot
-            ])
-            
-            return labeler.analyze_patterns(
-                dataset_repo,
-                config_name,
-                is_robot,
-                expected_count=expected_count
-            )
-        
-        # Auto-label handler
-        def auto_label_handler(dataset_repo, config_name, target_percent):
-            if not labeler.current_trajectories:
-                return "No trajectories loaded"
-            
-            traj = labeler.current_trajectories[labeler.current_idx]
-            return labeler.auto_label_similar(
-                dataset_repo,
-                config_name,
-                traj.get('is_robot', False),
-                float(target_percent)
-            )
-        
-        # Connect handlers
-        load_btn.click(
-            load_dataset,
-            inputs=[dataset_repo_input, config_name_input, num_human_input, num_robot_input],
-            outputs=[load_status, traj_info, task_display, frame_slider, video_output, current_frame_img, end_percent_display]
-        )
-        
-        next_btn.click(
-            navigate_next,
-            outputs=[traj_info, task_display, frame_slider, video_output, current_frame_img, end_percent_display]
-        )
-        
-        prev_btn.click(
-            navigate_prev,
-            outputs=[traj_info, task_display, frame_slider, video_output, current_frame_img, end_percent_display]
-        )
-        
-        frame_slider.change(
-            show_frame,
-            inputs=[video_output, frame_slider],
-            outputs=[current_frame_img, end_percent_display]
-        )
-        
-        end_frame_input.change(
-            update_end_percent,
-            inputs=[video_output, end_frame_input],
-            outputs=[end_percent_display]
-        )
-        
-        video_output.change(
-            lambda v: show_frame(v, 0) if v else (None, "0.0%"),
-            inputs=[video_output],
-            outputs=[current_frame_img, end_percent_display]
-        )
-        
-        save_label_btn.click(
-            save_label_handler,
-            inputs=[dataset_repo_input, config_name_input, end_frame_input, notes_input],
-            outputs=[label_status]
-        )
-        
-        analyze_btn.click(
-            analyze_pattern_handler,
-            inputs=[dataset_repo_input, config_name_input],
-            outputs=[pattern_output]
-        )
-        
-        auto_label_btn.click(
-            auto_label_handler,
-            inputs=[dataset_repo_input, config_name_input, auto_label_percent],
-            outputs=[auto_label_status]
-        )
-    
-    return demo
-
-
-if __name__ == "__main__":
-    demo = create_gradio_interface()
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
-

labels.csv

@@ -1,117 +0,0 @@
-dataset_repo,config_name,trajectory_id,is_robot,task,manual_end_frame,manual_end_percent,auto_labeled,pattern_matched,notes
-abraranwar/agibotworld_alpha_rfm,,5c7b9812-0374-40af-a7d7-ef94febc2cf1,True,,0,0.0,False,False,
-abraranwar/agibotworld_alpha_rfm,,e672c58f-ee21-4471-835e-eeecbd915eaa,True,,55,85.9375,False,False,
-abraranwar/agibotworld_alpha_rfm,,e672c58f-ee21-4471-835e-eeecbd915eaa,True,,58,90.625,False,False,
-abraranwar/agibotworld_alpha_rfm,,5c7b9812-0374-40af-a7d7-ef94febc2cf1,True,,50,78.125,False,False,
-abraranwar/agibotworld_alpha_rfm,,d2015f14-b370-4448-9ec2-35827541bd1a,True,,48,75.0,False,False,
-abraranwar/agibotworld_alpha_rfm,,d2015f14-b370-4448-9ec2-35827541bd1a,True,,51,79.6875,False,False,
-anqil/rh20t_subset_rfm,rh20t_human,edc7c228-16f3-44e6-9add-03183e87b553,False,Press the button from top to bottom,16,66.66666666666666,False,False,
-anqil/rh20t_subset_rfm,rh20t_human,253bb21b-f6ee-449d-8e26-aef100a675e9,False,Press the button from top to bottom,14,63.63636363636363,False,False,
-anqil/rh20t_subset_rfm,rh20t_human,7c624645-f428-44be-b3da-b8b4df08b06f,False,Press the button from top to bottom,21,75.0,False,False,
-anqil/rh20t_subset_rfm,rh20t_human,3346f2d7-460a-4e1f-beda-b73870a69ccb,False,Press the button from top to bottom,19,76.0,False,False,
-anqil/rh20t_subset_rfm,rh20t_human,8b848169-8e75-4c97-85e7-ef067e9f299b,False,Press the button from top to bottom,33,86.8421052631579,False,False,
-anqil/rh20t_subset_rfm,rh20t_human,38ed0e20-33a7-4077-bd05-3070483c5898,False,Press the button from top to bottom,25,80.64516129032258,False,False,
-anqil/rh20t_subset_rfm,rh20t_human,2ea39435-4ac1-4b82-8e51-1488c6b6c9ed,False,Press the button from top to bottom,26,81.25,False,False,
-anqil/rh20t_subset_rfm,rh20t_human,92275b63-339d-49b2-8a8f-8f23673993b8,False,Press the button from top to bottom,36,87.8048780487805,False,False,
-anqil/rh20t_subset_rfm,rh20t_human,5d92a0d2-d963-40a0-a077-6fd7a53c4aa8,False,Press the button from top to bottom,21,80.76923076923077,False,False,
-anqil/rh20t_subset_rfm,rh20t_human,80e94c43-2167-4b75-be66-b66a7c7e6b9e,False,Press the button from top to bottom,14,77.77777777777779,False,False,
-anqil/rh20t_subset_rfm,rh20t_robot,4830d4e6-d612-4a15-817b-71bba67f5f0a,True,Press the button from top to bottom,50,78.125,False,False,
-anqil/rh20t_subset_rfm,rh20t_robot,2e4399a7-ede2-42d7-b518-504b359ea896,True,Press the button from top to bottom,41,64.0625,False,False,
-anqil/rh20t_subset_rfm,rh20t_robot,a00bcbf3-bf68-4090-990f-0e66580f0e29,True,Press the button from top to bottom,44,68.75,False,False,
-anqil/rh20t_subset_rfm,rh20t_robot,25cb76a2-3964-4430-8f4d-44d988d2e75a,True,Press the button from top to bottom,45,70.3125,False,False,
-anqil/rh20t_subset_rfm,rh20t_robot,5ee5eee8-f9ea-43c5-90c4-a92436632481,True,Press the button from top to bottom,40,62.5,False,False,
-anqil/rh20t_subset_rfm,rh20t_robot,aa30fbd5-f1c1-45f5-a08b-ff3f71227e0d,True,Press the button from top to bottom,47,73.4375,False,False,
-anqil/rh20t_subset_rfm,rh20t_robot,0d8d506e-8bac-4dbd-a858-a743bd011ec1,True,Press the button from top to bottom,51,79.6875,False,False,
-anqil/rh20t_subset_rfm,rh20t_robot,7301509f-8a40-41ba-a3f5-13fd3b053cd3,True,Press the button from top to bottom,47,73.4375,False,False,
-anqil/rh20t_subset_rfm,rh20t_robot,74437d99-97e0-4dcc-860b-c0d316c6fbfe,True,Press the button from top to bottom,36,56.25,False,False,
-anqil/rh20t_subset_rfm,rh20t_robot,c1056af0-16a6-48d6-a979-4fecb488a0eb,True,Press the button from top to bottom,42,65.625,False,False,
-anqil/rh20t_subset_rfm,rh20t_robot,ede4327f-95e4-40fd-9b7d-612edbca7963,True,Remove the object from the scale,56,87.5,False,False,
-anqil/rh20t_subset_rfm,rh20t_robot,7dc22f64-1038-477a-83f9-5a906beaafcf,True,Dial a number on an old rotary phone,59,92.1875,False,False,
-anqil/rh20t_subset_rfm,rh20t_robot,d81591d8-aa9b-4da2-9b60-71faccfb8d9d,True,Drop coins into a piggy bank,56,87.5,False,False,
-anqil/rh20t_subset_rfm,rh20t_robot,d557ab79-1041-4583-8456-48a56da5eda8,True,Put the pen into the pen holder,53,82.8125,False,False,
-anqil/rh20t_subset_rfm,rh20t_robot,4133da48-539a-4dfe-97f6-8c46c678513e,True,Drag the plate to the goal post after holding it down,57,89.0625,False,False,
-anqil/rh20t_subset_rfm,rh20t_robot,197fc077-ad66-4a29-861c-0a36db6246d4,True,Scrub the table with a brush,49,76.5625,False,False,
-anqil/rh20t_subset_rfm,rh20t_robot,79e7d74b-bfd1-45be-9b14-24a544ff8ce6,True,Stack the squares into a pyramid shape,64,100.0,False,False,
-anqil/rh20t_subset_rfm,rh20t_robot,28e35846-4bbf-47be-89f5-447e438ed0a7,True,Use a shovel to scoop up an object,62,96.875,False,False,
-anqil/rh20t_subset_rfm,rh20t_robot,bf17468f-8161-40d5-a2f6-292e93bb20cb,True,Stack blocks (small Lego) one on top of the other every time,57,89.0625,False,False,
-anqil/rh20t_subset_rfm,rh20t_robot,b403a108-a6e2-4910-8b8c-efb59cdf093e,True,Open a box,60,93.75,False,False,
-anqil/rh20t_subset_rfm,rh20t_human,7f7df6ad-32a1-44ad-a0e6-295d1bb65c76,False,Turn the hands of a clock,36,87.8048780487805,False,False,
-anqil/rh20t_subset_rfm,rh20t_human,a01d4769-4c96-4e00-b67e-8f4749396c90,False,Slice the lotus root,55,85.9375,False,False,
-anqil/rh20t_subset_rfm,rh20t_human,6de0f308-bf23-4f8f-949e-fbc9f70612d3,False,Sharpen the pencil with a pencil sharpener,56,87.5,False,False,
-anqil/rh20t_subset_rfm,rh20t_human,01ad9018-59fb-4215-affe-6bd364b0fdec,False,Put the toilet paper on its holder,12,100.0,False,False,
-anqil/rh20t_subset_rfm,rh20t_human,b216b59f-efb8-4e15-a194-e58c55994086,False,Assemble one piece of a puzzle,59,92.1875,False,False,
-anqil/rh20t_subset_rfm,rh20t_human,d529c6ff-1383-43c1-80d6-7bafd2f7a0a5,False,Pick up the cup,24,75.0,False,False,
-anqil/rh20t_subset_rfm,rh20t_human,db988113-8aab-4b8f-8ee0-ed141fd910c7,False,Cover the box,43,91.48936170212765,False,False,
-anqil/rh20t_subset_rfm,rh20t_human,e0463214-4e47-40aa-83b4-bc1606a6393d,False,Finish setting up the starting position of a chessboard that is almost arranged,32,78.04878048780488,False,False,
-anqil/rh20t_subset_rfm,rh20t_human,3cb04ccf-93c2-4d8a-a2f0-9b39dc02c10f,False,Turn on the water tap,17,77.27272727272727,False,False,
-anqil/rh20t_subset_rfm,rh20t_human,473b7d30-80e0-4510-8ac4-e87eff084afd,False,Transfer liquid using a dropper,54,84.375,False,False,
-jesbu1/molmoact_rfm,molmoact_dataset_household,bd7a4fde-ef2a-49d3-b0c9-453b26febcb8,True,put my clothes in the laundry bag,58,90.625,False,False,
-jesbu1/molmoact_rfm,molmoact_dataset_household,1825aac8-6dbb-488c-ac36-de1d120e082c,True,put the toy car in the basket,59,92.1875,False,False,
-jesbu1/molmoact_rfm,molmoact_dataset_household,8424dd49-b1f5-49ed-90a7-1f25fd4bd72c,True,put the fork in the dishwasher,60,93.75,False,False,
-jesbu1/molmoact_rfm,molmoact_dataset_household,4a5493f9-c04e-46eb-807a-4c904be6cf7e,True,put the apple in the tray,58,90.625,False,False,
-jesbu1/molmoact_rfm,molmoact_dataset_household,c122c462-6207-4a61-966e-85389eebbd97,True,put the protein bar into the container,59,92.1875,False,False,
-jesbu1/molmoact_rfm,molmoact_dataset_household,c47da149-c1b2-4c33-92c9-79c199640893,True,pour me some water,53,82.8125,False,False,
-jesbu1/molmoact_rfm,molmoact_dataset_household,a010f8c4-d74c-4306-a844-0159ecebbe6f,True,put the markers back in the holder,54,84.375,False,False,
-jesbu1/molmoact_rfm,molmoact_dataset_household,013b967c-9f7d-422d-9b07-47c18c4ac9dc,True,turn off the cold water,36,94.73684210526315,False,False,
-jesbu1/molmoact_rfm,molmoact_dataset_household,46cb42ae-6c91-4223-a0e4-87979382e1d3,True,put the tongs back in the holder,59,92.1875,False,False,
-jesbu1/molmoact_rfm,molmoact_dataset_household,4ffe10df-0e91-4b61-81cc-741827cf0dc3,True,stand the pillow up,55,85.9375,False,False,
-jesbu1/molmoact_rfm,molmoact_dataset_tabletop,5949019c-7d3b-4e3f-908f-1ab6dad1c71f,True,knock down the dish soap,56,91.80327868852459,False,False,
-jesbu1/molmoact_rfm,molmoact_dataset_tabletop,3280cd5f-8610-49bb-8616-8bc91afab9a1,True,knock down the dish soap,52,89.65517241379311,False,False,
-jesbu1/molmoact_rfm,molmoact_dataset_tabletop,c46051d3-e31e-4517-aa69-51a038be6c81,True,close the top drawer,57,89.0625,False,False,
-jesbu1/molmoact_rfm,molmoact_dataset_tabletop,79a3ad30-55fb-4703-8935-b3b404522587,True,knock down the dish soap,54,84.375,False,False,
-jesbu1/molmoact_rfm,molmoact_dataset_tabletop,bb5c7271-f755-41ec-90e2-8e381649f7ed,True,fold the towel,56,87.5,False,False,
-jesbu1/molmoact_rfm,molmoact_dataset_tabletop,30d0dc38-c11f-4677-873d-0aa8614cc3d3,True,hang the mug,59,92.1875,False,False,
-jesbu1/molmoact_rfm,molmoact_dataset_tabletop,6b0985e3-32f6-474c-acec-7a6dfddf8373,True,load the plate,61,95.3125,False,False,
-jesbu1/molmoact_rfm,molmoact_dataset_tabletop,983438c9-208c-4a56-9c07-35536e5fb64c,True,stand the sanitizer,58,90.625,False,False,
-jesbu1/molmoact_rfm,molmoact_dataset_tabletop,497997c8-7134-42cd-ae09-0143c7ad9ad3,True,load the plate,61,95.3125,False,False,
-jesbu1/molmoact_rfm,molmoact_dataset_tabletop,0e246684-b029-436d-af14-55cb7b01cba4,True,flip the mug upright,58,90.625,False,False,
-jesbu1/galaxea_rfm,galaxea_part1_r1_lite,84bc312a-b111-4adb-a5e9-f723979c00b0,True,Remove the flower from the vase with your right hand and place it on the right side of the table.,58,90.625,False,False,
-jesbu1/galaxea_rfm,galaxea_part1_r1_lite,d9d2272e-a195-4f4c-9e23-ab00f5e0f0f6,True,Pick up the kettle with the right hand and move it under the faucet.,64,100.0,False,False,
-jesbu1/galaxea_rfm,galaxea_part1_r1_lite,ee7754ce-0174-4760-87bf-782230ada240,True,Turn off the faucet with your right hand.,62,96.875,False,False,
-jesbu1/galaxea_rfm,galaxea_part1_r1_lite,36a1cdd5-2126-41f9-bea5-06a23f0c93d8,True,Pick up the vegetable leaf on the black table with your right hand.,62,144.1860465116279,False,False,
-jesbu1/galaxea_rfm,galaxea_part1_r1_lite,24006f47-27e4-4d00-8cdc-429030942502,True,Pick up the cigarette butt on the black table with your right hand.,62,96.875,False,False,
-jesbu1/galaxea_rfm,galaxea_part1_r1_lite,d623ad49-3f90-46da-a647-3bc7b616c37f,True,"Pick up the sponge with the right hand, scrub the cutting board, then place it on the table.",62,96.875,False,False,
-jesbu1/fino_net_rfm,,5ef99446-50eb-4174-974b-00551ecef49f,True,put the single block on the table onto the stack,49,76.5625,False,False,
-jesbu1/fino_net_rfm,,d6baa6cf-10db-4d62-915e-1de3ad8f08bf,True,put the single block on the table onto the stack,49,76.5625,False,False,
-jesbu1/fino_net_rfm,,0499983c-c52e-4b17-bb50-5bc63374b4c3,True,put the object on the table into the container,32,76.19047619047619,False,False,
-jesbu1/h2r_rfm,,0ed22a8d-6d1b-494a-ba1f-23d98e95cdbd,False,pick up the marker and place it on the plate,47,73.4375,False,False,
-jesbu1/h2r_rfm,,53c4fc6e-32ca-4f9b-b869-305f8b3e2b95,False,pull the plate from bottom to top,49,76.5625,False,False,
-jesbu1/h2r_rfm,,fc8a6de7-bbaa-4cdd-9008-a0000943207f,False,pick up the marker and place it on the plate,49,76.5625,False,False,
-jesbu1/h2r_rfm,,45b4dce3-4aeb-42c6-9b85-b19918474b97,False,move the cup from left to right,57,89.0625,False,False,
-jesbu1/h2r_rfm,,40d487af-eccc-4699-bd8b-3a6a3c3e2181,False,pull the plate from bottom to top,49,76.5625,False,False,
-jesbu1/h2r_rfm,,f9b5c6e7-da35-441a-a093-2fbada53a385,False,put the red cube on the darker plate,51,79.6875,False,False,
-jesbu1/h2r_rfm,,308aaadb-e2b4-4325-8699-2e5b17d3da11,False,"put the cube on the plate, then pull the plate from bottom to top",51,79.6875,False,False,
-jesbu1/h2r_rfm,,0408b830-5ba3-4f2b-92ea-fa907578cd06,False,"put the cube on the plate, then pull the plate from bottom to top",52,81.25,False,False,
-jesbu1/h2r_rfm,,575b629a-16f8-4bdd-972b-a9315f6bd460,False,move the cup from left to right,57,89.0625,False,False,
-jesbu1/h2r_rfm,,2c460bcf-cb19-4c02-8a3b-e63a239cd18b,False,pick up the marker and place it on the plate,49,76.5625,False,False,
-jesbu1/h2r_rfm,,fc3a70c9-9f77-4eb4-a155-4a9a8588fddf,True,pick up the marker and place it on the plate,52,81.25,False,False,
-jesbu1/h2r_rfm,,a4afdcc0-4c4b-4e5f-a3bb-224a4a963c71,True,pick up the green cube and place it onto the plate,50,78.125,False,False,
-jesbu1/h2r_rfm,,2627f693-778e-47e1-b6ec-cc1c92e0d74d,True,pick up the marker and place it on the plate,54,84.375,False,False,
-jesbu1/h2r_rfm,,ef91ed87-e672-46ea-8698-4ba556f90c85,True,pull the plate from bottom to top,53,82.8125,False,False,
-jesbu1/h2r_rfm,,d95dc409-d04f-431f-84f2-9fff51a585f7,True,pick up the green cube and place it onto the plate,51,79.6875,False,False,
-jesbu1/h2r_rfm,,5c4d9545-1ab8-4d91-9a9e-763eeb71043a,True,pull the plate from bottom to top,52,81.25,False,False,
-jesbu1/h2r_rfm,,8a562db7-79b6-49de-a3a2-a41eb083d43b,True,pick up the marker and place it on the plate,54,84.375,False,False,
-jesbu1/h2r_rfm,,103bb2bf-0bc2-478f-86ed-95c65d8895f4,True,move the cup from left to right,57,89.0625,False,False,
-jesbu1/h2r_rfm,,3c00c0e6-bfa2-4f60-b321-eb26b8f2048a,True,pick up the red cube and place it onto the darker plate,59,92.1875,False,False,
-jesbu1/h2r_rfm,,49444f63-a51f-491f-8013-d8ef2cb6630b,True,pull the plate from bottom to top,55,85.9375,False,False,
-jesbu1/humanoid_everyday_rfm,,0f804831-1cd8-48a1-8d31-60fff45b84a7,True,The robot uses its right hand to grab and squeeze a pink dumpling toy kept on the black mask on the desk,49,76.5625,False,False,
-jesbu1/humanoid_everyday_rfm,,c0d74c20-62ab-4bb6-b918-b3225cb70954,True,the robot uses its right hand to grab the drawer kept on the middle of the desk and pull it out towards the robot,44,68.75,False,False,
-jesbu1/humanoid_everyday_rfm,,2e7d1cc5-f563-44dd-86ea-ec99d9b9ddab,True,A hammer is kept on the right hand side and a pillow is kept on the left hand side on the desk infront of the robot and the robot uses its right hand to pick up the hammer and makes a downward swinging motion to hit the pillow,44,68.75,False,False,
-jesbu1/humanoid_everyday_rfm,,d4066d1c-a284-4fff-8fa8-18f038e28d52,True,"The robot uses left hand to click on the left button of the black mouse, which is placed on the left area of the table",47,73.4375,False,False,
-jesbu1/humanoid_everyday_rfm,,1afa6a70-b5c1-4552-87a7-aa4ea437212b,True,the robot uses its left hand to push the cover of the diary kept in the middle of the desk to close it,47,73.4375,False,False,
-jesbu1/humanoid_everyday_rfm,,22f0419b-d5a3-47b6-80bf-68cfd6c13eb3,True,the robot picks up a small bag of sunflower seeds on the right hand side and take it to the empty plate on the left hand side then pours some sunflower seeds on to the plate. ,47,73.4375,False,False,
-jesbu1/humanoid_everyday_rfm,,24de05de-208d-479e-976c-7cfb716844b6,True,the robot uses its right hand to make a fist and press the red button kept in the middle of the desk,45,70.3125,False,False,
-jesbu1/humanoid_everyday_rfm,,e28e9adb-c80d-43db-b4e4-5cbcc7020e25,True,The robot picks the blue plier placed on top of the container and places it on the grey area of the table,48,75.0,False,False,
-jesbu1/humanoid_everyday_rfm,,685621ee-de8f-4fd8-a93e-89559c721f1d,True,A controller is being placed at the center of the desk near the left hand and the robot uses its left hand's index finger to press a button at the left area of the controller,50,78.125,False,False,
-jesbu1/humanoid_everyday_rfm,,8116b7d4-5076-4c2c-9aa7-69b82cc129ca,True,use the right hand to grab the handle of the kettle from the base and place it on the right side,48,75.0,False,False,
-jesbu1/motif_rfm,,62b48133-e804-4b46-93e7-1cd120c33e0b,False,pick up the cup and place it to the lower left of the laptop: move downward and to the left,53,82.8125,False,False,
-jesbu1/motif_rfm,,e5661543-2bd0-47b8-a84d-457907e50505,False,"pick up the cup and place it to the lower left of the laptop: move downward, then move to the left",57,89.0625,False,False,
-jesbu1/motif_rfm,,bc3efef9-5f1c-45c0-b092-271bdc1f7a9d,False,brush hair: move downward and to the right,54,84.375,False,False,
-jesbu1/motif_rfm,,67cc01d1-323d-4666-8e67-e6b5f6ab5390,False,shake the boba: make a circular motion clockwise,54,84.375,False,False,
-jesbu1/motif_rfm,,7d6cd285-248f-4422-9128-a0d9e49e3524,False,stir: make a circular motion counter-clockwise,54,84.375,False,False,
-jesbu1/motif_rfm,,7a79788d-5021-4f20-a53e-87753271a6bb,False,brush hair: move downward,56,87.5,False,False,
-jesbu1/motif_rfm,,a8a39a08-aa89-4acd-86a5-3fdf38082de5,False,brush hair: move downward,57,89.0625,False,False,
-jesbu1/motif_rfm,,abc6f7f8-985b-4174-8d8f-dcd8135e989b,False,brush hair: move downward,57,89.0625,False,False,
-jesbu1/motif_rfm,,457ce97a-eecc-4299-a7f3-37b6bc7762e6,False,brush hair: move downward,51,79.6875,False,False,
-jesbu1/motif_rfm,,4d29c82d-e73e-4061-9c14-6ca2b8179570,False,pick up the cup and place it to the lower left of the laptop: move downward and to the left,51,79.6875,False,False,
-jesbu1/motif_rfm,,0740db4e-bf3d-453e-8560-8560181b0d85,True,stir: make a circular motion clockwise,51,79.6875,False,False,

requirements.txt

@@ -1,2 +1,2 @@
-huggingface-hub==0.19.4
-gradio>=4.0.0
+# Minimal requirements - Gradio is pre-installed by Spaces
+

test_discovery.py

@@ -1,87 +0,0 @@
-#!/usr/bin/env python3
-"""
-Quick script to test dataset discovery and video downloading.
-"""
-
-from dataset_discovery import discover_datasets_with_both_types, sample_trajectories
-from video_downloader import VideoDownloader
-
-
-def main():
-    print("=" * 60)
-    print("Trajectory Labeler - Dataset Discovery Test")
-    print("=" * 60)
-    
-    # Discover datasets
-    print("\n1. Discovering datasets with both human and robot data...")
-    datasets = discover_datasets_with_both_types()
-    
-    if not datasets:
-        print("No datasets found. You can manually test with a known dataset.")
-        print("\nExample: jesbu1/epic_rfm")
-        return
-    
-    print(f"\nFound {len(datasets)} datasets:")
-    for repo, stats in datasets.items():
-        print(f"  - {repo}: {stats}")
-    
-    # Test sampling from first dataset
-    if datasets:
-        print("\n2. Testing trajectory sampling...")
-        first_repo = list(datasets.keys())[0]
-        
-        # Handle repo with config
-        if "/" in first_repo and first_repo.count("/") >= 2:
-            parts = first_repo.split("/")
-            repo_id = "/".join(parts[:2])
-            config_name = parts[2] if len(parts) > 2 else None
-        else:
-            repo_id = first_repo
-            config_name = None
-        
-        print(f"Sampling from: {repo_id} (config: {config_name})")
-        
-        try:
-            human_samples = sample_trajectories(repo_id, config_name, is_robot=False, num_samples=2)
-            robot_samples = sample_trajectories(repo_id, config_name, is_robot=True, num_samples=2)
-            
-            print(f"  ✅ Human samples: {len(human_samples)}")
-            print(f"  ✅ Robot samples: {len(robot_samples)}")
-            
-            if human_samples:
-                print(f"  Example human trajectory ID: {human_samples[0].get('id', 'unknown')[:30]}...")
-            if robot_samples:
-                print(f"  Example robot trajectory ID: {robot_samples[0].get('id', 'unknown')[:30]}...")
-            
-            # Test video download
-            print("\n3. Testing video download...")
-            downloader = VideoDownloader()
-            
-            if human_samples:
-                print(f"  Downloading human video...")
-                video_path = downloader.download_video(human_samples[0], repo_id, config_name)
-                if video_path:
-                    print(f"  ✅ Downloaded to: {video_path}")
-                    info = downloader.get_video_info(video_path)
-                    print(f"  Video info: {info.get('frame_count')} frames, {info.get('fps'):.1f} fps")
-                else:
-                    print(f"  ❌ Failed to download video")
-            
-        except Exception as e:
-            print(f"  ❌ Error: {e}")
-            import traceback
-            traceback.print_exc()
-    
-    print("\n" + "=" * 60)
-    print("Test complete! Run 'python labeler_app.py' to start the labeling app.")
-    print("=" * 60)
-
-
-if __name__ == "__main__":
-    main()
-
-
-
-
-
-

video_downloader.py

@@ -1,163 +0,0 @@
-#!/usr/bin/env python3
-"""
-Download videos for sampled trajectories.
-Manages local cache and handles video file paths.
-"""
-
-import os
-import shutil
-from pathlib import Path
-from typing import Dict, List, Optional
-
-from datasets import load_dataset
-from huggingface_hub import hf_hub_download
-from tqdm import tqdm
-
-
-class VideoDownloader:
-    """Handles downloading and caching trajectory videos."""
-    
-    def __init__(self, cache_dir: str = "video_cache"):
-        self.cache_dir = Path(cache_dir)
-        self.cache_dir.mkdir(exist_ok=True)
-        self.downloaded_videos = {}  # repo -> video_path mapping
-    
-    def download_video(self, trajectory: Dict, dataset_repo: str, config_name: Optional[str] = None) -> Optional[str]:
-        """
-        Download a single video for a trajectory.
-        
-        Args:
-            trajectory: Trajectory dictionary with 'frames' field (video path)
-            dataset_repo: HuggingFace dataset repository ID
-            config_name: Optional config name
-            
-        Returns:
-            Local path to downloaded video, or None if failed
-        """
-        video_path = trajectory.get("frames")
-        if not video_path:
-            return None
-        
-        # Create cache subdirectory for this dataset
-        repo_key = f"{dataset_repo}_{config_name}" if config_name else dataset_repo
-        repo_key = repo_key.replace("/", "_").replace("\\", "_")
-        dataset_cache_dir = self.cache_dir / repo_key
-        dataset_cache_dir.mkdir(parents=True, exist_ok=True)
-        
-        # Handle relative paths - preserve directory structure
-        video_path_obj = Path(video_path)
-        if video_path_obj.is_absolute():
-            # If absolute, just use filename
-            local_video_path = dataset_cache_dir / video_path_obj.name
-        else:
-            # Preserve relative directory structure
-            local_video_path = dataset_cache_dir / video_path
-            local_video_path.parent.mkdir(parents=True, exist_ok=True)
-        
-        # Check if already downloaded
-        if local_video_path.exists():
-            return str(local_video_path)
-        
-        # Download from HuggingFace Hub
-        try:
-            # Use local_dir to preserve directory structure
-            downloaded_path = hf_hub_download(
-                repo_id=dataset_repo,
-                repo_type="dataset",
-                filename=video_path,
-                local_dir=str(dataset_cache_dir),
-                local_dir_use_symlinks=False,
-            )
-            
-            # hf_hub_download returns the full path, check if it matches our expected path
-            if Path(downloaded_path).exists():
-                return downloaded_path
-            elif local_video_path.exists():
-                return str(local_video_path)
-            else:
-                # Try to find the downloaded file
-                downloaded_file = Path(downloaded_path)
-                if downloaded_file.exists():
-                    # Copy to expected location
-                    local_video_path.parent.mkdir(parents=True, exist_ok=True)
-                    shutil.copy2(downloaded_file, local_video_path)
-                    return str(local_video_path)
-                else:
-                    print(f"Downloaded file not found: {downloaded_path}")
-                    return None
-            
-        except Exception as e:
-            print(f"Error downloading video {video_path}: {e}")
-            # Try alternative: load via datasets library which handles paths better
-            try:
-                from datasets import load_dataset
-                if config_name:
-                    dataset = load_dataset(dataset_repo, config_name, split="train", streaming=False)
-                else:
-                    dataset = load_dataset(dataset_repo, split="train", streaming=False)
-                
-                # Find trajectory by ID
-                traj_id = trajectory.get("id")
-                for sample in dataset:
-                    if sample.get("id") == traj_id:
-                        # Try to get the video file
-                        frames = sample.get("frames")
-                        if isinstance(frames, str) and os.path.exists(frames):
-                            return frames
-                        break
-            except Exception as e2:
-                print(f"Alternative download method also failed: {e2}")
-            
-            return None
-    
-    def download_trajectories(
-        self,
-        trajectories: List[Dict],
-        dataset_repo: str,
-        config_name: Optional[str] = None
-    ) -> List[Dict]:
-        """
-        Download videos for multiple trajectories.
-        
-        Returns:
-            List of trajectory dicts with 'local_video_path' added
-        """
-        results = []
-        
-        for traj in tqdm(trajectories, desc="Downloading videos"):
-            local_path = self.download_video(traj, dataset_repo, config_name)
-            if local_path:
-                traj_copy = traj.copy()
-                traj_copy["local_video_path"] = local_path
-                traj_copy["dataset_repo"] = dataset_repo
-                traj_copy["config_name"] = config_name
-                results.append(traj_copy)
-            else:
-                print(f"Warning: Failed to download video for trajectory {traj.get('id', 'unknown')}")
-        
-        return results
-    
-    def get_video_info(self, video_path: str) -> Dict:
-        """Get video metadata (frame count, duration, etc.)."""
-        import cv2
-        
-        if not os.path.exists(video_path):
-            return {"error": "Video not found"}
-        
-        cap = cv2.VideoCapture(video_path)
-        if not cap.isOpened():
-            return {"error": "Could not open video"}
-        
-        frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-        fps = cap.get(cv2.CAP_PROP_FPS)
-        duration = frame_count / fps if fps > 0 else 0
-        
-        cap.release()
-        
-        return {
-            "frame_count": frame_count,
-            "fps": fps,
-            "duration": duration,
-            "path": video_path
-        }
-