update interface

app.py

@@ -12,9 +12,14 @@ from typing import Optional, Tuple
 import logging
 
 import gradio as gr
-import spaces  # Required for ZeroGPU
+
+try:
+    import spaces  # Required for ZeroGPU on Hugging Face Spaces
+except ImportError:
+    spaces = None  # Not available when running locally
 import matplotlib
-matplotlib.use('Agg')  # Use non-interactive backend
+
+matplotlib.use("Agg")  # Use non-interactive backend
 import matplotlib.pyplot as plt
 import numpy as np
 import requests
@@ -24,6 +29,7 @@ from typing import Any, Optional, Tuple
 
 from rfm.data.dataset_types import Trajectory, ProgressSample, PreferenceSample
 from rfm.evals.eval_utils import build_payload, post_batch_npy
+from rfm.evals.eval_viz_utils import create_combined_progress_success_plot
 from datasets import load_dataset as load_dataset_hf, get_dataset_config_names
 
 logger = logging.getLogger(__name__)
@@ -57,7 +63,7 @@ PREDEFINED_DATASETS = [
     "aliangdw/usc_xarm_policy_ranking",
     "aliangdw/usc_franka_policy_ranking",
     "aliangdw/utd_so101_policy_ranking",
-    "aliangdw/utd_so101_human"
+    "aliangdw/utd_so101_human",
 ]
 
 # Global server state
@@ -65,17 +71,18 @@ _server_state = {
     "server_url": None,
 }
 
+
 def check_server_health(server_url: str) -> Tuple[str, Optional[dict], Optional[str]]:
     """Check server health and get model info."""
     if not server_url:
         return "Please provide a server URL.", None, None
-    
+
     try:
         url = server_url.rstrip("/") + "/health"
         response = requests.get(url, timeout=5.0)
         response.raise_for_status()
         health_data = response.json()
-        
+
         # Also try to get GPU status for more info
         try:
             status_url = server_url.rstrip("/") + "/gpu_status"
@@ -85,7 +92,7 @@ def check_server_health(server_url: str) -> Tuple[str, Optional[dict], Optional[
                 health_data.update(status_data)
         except:
             pass
-        
+
         # Try to get model info
         model_info_text = None
         try:
@@ -96,9 +103,13 @@ def check_server_health(server_url: str) -> Tuple[str, Optional[dict], Optional[
                 model_info_text = format_model_info(model_info_data)
         except Exception as e:
             logger.warning(f"Could not fetch model info: {e}")
-        
+
         _server_state["server_url"] = server_url
-        return f"Server connected: {health_data.get('available_gpus', 0)}/{health_data.get('total_gpus', 0)} GPUs available", health_data, model_info_text
+        return (
+            f"Server connected: {health_data.get('available_gpus', 0)}/{health_data.get('total_gpus', 0)} GPUs available",
+            health_data,
+            model_info_text,
+        )
     except requests.exceptions.RequestException as e:
         return f"Error connecting to server: {str(e)}", None, None
 
@@ -106,31 +117,31 @@ def check_server_health(server_url: str) -> Tuple[str, Optional[dict], Optional[
 def format_model_info(model_info: dict) -> str:
     """Format model info and experiment config as markdown."""
     lines = ["## Model Information\n"]
-    
+
     # Model path
     model_path = model_info.get("model_path", "Unknown")
     lines.append(f"**Model Path:** `{model_path}`\n")
-    
+
     # Number of GPUs
     num_gpus = model_info.get("num_gpus", "Unknown")
     lines.append(f"**Number of GPUs:** {num_gpus}\n")
-    
+
     # Model architecture
     model_arch = model_info.get("model_architecture", {})
     if model_arch and "error" not in model_arch:
         lines.append("\n## Model Architecture\n")
-        
+
         model_class = model_arch.get("model_class", "Unknown")
         model_module = model_arch.get("model_module", "Unknown")
         lines.append(f"- **Model Class:** `{model_class}`\n")
         lines.append(f"- **Module:** `{model_module}`\n")
-        
+
         # Parameter counts
         total_params = model_arch.get("total_parameters")
         trainable_params = model_arch.get("trainable_parameters")
         frozen_params = model_arch.get("frozen_parameters")
         trainable_pct = model_arch.get("trainable_percentage")
-        
+
         if total_params is not None:
             lines.append(f"\n### Parameter Statistics\n")
             lines.append(f"- **Total Parameters:** {total_params:,}\n")
@@ -140,7 +151,7 @@ def format_model_info(model_info: dict) -> str:
                 lines.append(f"- **Frozen Parameters:** {frozen_params:,}\n")
             if trainable_pct is not None:
                 lines.append(f"- **Trainable Percentage:** {trainable_pct:.2f}%\n")
-        
+
         # Architecture summary
         arch_summary = model_arch.get("architecture_summary", [])
         if arch_summary:
@@ -150,12 +161,12 @@ def format_model_info(model_info: dict) -> str:
                 module_type = module_info.get("type", "Unknown")
                 params = module_info.get("parameters", 0)
                 lines.append(f"- **{name}** (`{module_type}`): {params:,} parameters\n")
-    
+
     # Experiment config
     exp_config = model_info.get("experiment_config", {})
     if exp_config:
         lines.append("\n## Experiment Configuration\n")
-        
+
         # Model config
         model_cfg = exp_config.get("model", {})
         if model_cfg:
@@ -168,29 +179,33 @@ def format_model_info(model_info: dict) -> str:
             lines.append(f"- **Train Success Head:** {model_cfg.get('train_success_head', False)}\n")
             lines.append(f"- **Use PEFT:** {model_cfg.get('use_peft', False)}\n")
             lines.append(f"- **Use Unsloth:** {model_cfg.get('use_unsloth', False)}\n")
-        
+
         # Data config
         data_cfg = exp_config.get("data", {})
         if data_cfg:
             lines.append("\n### Data Configuration\n")
             lines.append(f"- **Max Frames:** {data_cfg.get('max_frames', 'N/A')}\n")
-            lines.append(f"- **Resized Dimensions:** {data_cfg.get('resized_height', 'N/A')}x{data_cfg.get('resized_width', 'N/A')}\n")
-            train_datasets = data_cfg.get('train_datasets', [])
+            lines.append(
+                f"- **Resized Dimensions:** {data_cfg.get('resized_height', 'N/A')}x{data_cfg.get('resized_width', 'N/A')}\n"
+            )
+            train_datasets = data_cfg.get("train_datasets", [])
             if train_datasets:
                 lines.append(f"- **Train Datasets:** {', '.join(train_datasets)}\n")
-            eval_datasets = data_cfg.get('eval_datasets', [])
+            eval_datasets = data_cfg.get("eval_datasets", [])
             if eval_datasets:
                 lines.append(f"- **Eval Datasets:** {', '.join(eval_datasets)}\n")
-        
+
         # Training config
         training_cfg = exp_config.get("training", {})
         if training_cfg:
             lines.append("\n### Training Configuration\n")
             lines.append(f"- **Learning Rate:** {training_cfg.get('learning_rate', 'N/A')}\n")
             lines.append(f"- **Batch Size:** {training_cfg.get('per_device_train_batch_size', 'N/A')}\n")
-            lines.append(f"- **Gradient Accumulation Steps:** {training_cfg.get('gradient_accumulation_steps', 'N/A')}\n")
+            lines.append(
+                f"- **Gradient Accumulation Steps:** {training_cfg.get('gradient_accumulation_steps', 'N/A')}\n"
+            )
             lines.append(f"- **Max Steps:** {training_cfg.get('max_steps', 'N/A')}\n")
-    
+
     return "".join(lines)
 
 
@@ -199,12 +214,12 @@ def load_rfm_dataset(dataset_name, config_name):
     try:
         if not dataset_name or not config_name:
             return None, "Please provide both dataset name and configuration"
-        
+
         dataset = load_dataset_hf(dataset_name, name=config_name, split="train")
-        
+
         if len(dataset) == 0:
             return None, f"Dataset {dataset_name}/{config_name} is empty"
-        
+
         return dataset, f"Loaded {len(dataset)} trajectories from {dataset_name}/{config_name}"
     except Exception as e:
         error_msg = str(e)
@@ -231,18 +246,18 @@ def get_trajectory_video_path(dataset, index, dataset_name):
     try:
         item = dataset[int(index)]
         frames_data = item["frames"]
-        
+
         if isinstance(frames_data, str):
             # Construct HuggingFace Hub URL
             if dataset_name:
                 video_path = f"https://huggingface.co/datasets/{dataset_name}/resolve/main/{frames_data}"
             else:
                 video_path = f"https://huggingface.co/datasets/aliangdw/rfm/resolve/main/{frames_data}"
-            
+
             task = item.get("task", "Complete the task")
             quality_label = item.get("quality_label", None)
             partial_success = item.get("partial_success", None)
-            
+
             return video_path, task, quality_label, partial_success
         else:
             return None, None, None, None
@@ -267,7 +282,7 @@ def extract_frames(video_path: str, fps: float = 1.0) -> np.ndarray:
     # Check if it's a URL or local file
     is_url = video_path.startswith(("http://", "https://"))
     is_local_file = os.path.exists(video_path) if not is_url else False
-    
+
     if not is_url and not is_local_file:
         logger.warning(f"Video path does not exist: {video_path}")
         return None
@@ -304,7 +319,7 @@ def extract_frames(video_path: str, fps: float = 1.0) -> np.ndarray:
             frame_indices = np.linspace(0, total_frames - 1, desired_frames, dtype=int).tolist()
 
         frames_array = vr.get_batch(frame_indices).asnumpy()  # Shape: (T, H, W, C)
-        del vr 
+        del vr
         return frames_array
     except Exception as e:
         logger.error(f"Error extracting frames from {video_path}: {e}")
@@ -316,26 +331,26 @@ def process_single_video(
     task_text: str = "Complete the task",
     server_url: str = "",
     fps: float = 1.0,
-) -> Tuple[Optional[str], Optional[str], Optional[str]]:
+) -> Tuple[Optional[str], Optional[str]]:
     """Process single video for progress and success predictions using eval server."""
     if not server_url:
-        return None, None, "Please provide a server URL and check connection first."
-    
+        return None, "Please provide a server URL and check connection first."
+
     if not _server_state.get("server_url"):
-        return None, None, "Server not connected. Please check server connection first."
-    
+        return None, "Server not connected. Please check server connection first."
+
     if video_path is None:
-        return None, None, "Please provide a video."
+        return None, "Please provide a video."
 
     try:
         frames_array = extract_frames(video_path, fps=fps)
         if frames_array is None or frames_array.size == 0:
-            return None, None, "Could not extract frames from video."
+            return None, "Could not extract frames from video."
 
         # Convert frames to (T, H, W, C) numpy array with uint8 values
         if frames_array.dtype != np.uint8:
             frames_array = np.clip(frames_array, 0, 255).astype(np.uint8)
-        
+
         num_frames = frames_array.shape[0]
         frames_shape = frames_array.shape  # (T, H, W, C)
 
@@ -366,25 +381,54 @@ def process_single_video(
         # Process response
         outputs_progress = response.get("outputs_progress", {})
         progress_pred = outputs_progress.get("progress_pred", [])
-        
+        outputs_success = response.get("outputs_success", {})
+        success_probs = outputs_success.get("success_probs", []) if outputs_success else None
+
         # Extract progress predictions
         if progress_pred and len(progress_pred) > 0:
             progress_array = np.array(progress_pred[0])  # First sample
         else:
             progress_array = np.array([])
 
-        # Create plots
-        progress_plot = create_progress_plot(progress_array, num_frames)
-        success_plot = None  # Success predictions not always available from server
+        # Extract success predictions if available
+        success_array = None
+        if success_probs and len(success_probs) > 0:
+            success_array = np.array(success_probs[0])
+        
+        # Convert success_array to binary if available
+        success_binary = None
+        if success_array is not None:
+            success_binary = (success_array > 0.5).astype(float)
+
+        # Create combined plot using shared helper function
+        fig = create_combined_progress_success_plot(
+            progress_pred=progress_array if len(progress_array) > 0 else np.array([0.0]),
+            num_frames=num_frames,
+            success_binary=success_binary,
+            success_probs=success_array,
+            success_labels=None,  # No ground truth labels available
+            is_discrete_mode=False,
+            num_bins=10,
+            title=f"Progress & Success - {task_text}",
+        )
+        
+        # Save to temporary file
+        tmp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
+        fig.savefig(tmp_file.name, dpi=150, bbox_inches="tight")
+        plt.close(fig)
+        progress_plot = tmp_file.name
 
         info_text = f"**Frames processed:** {num_frames}\n"
         if len(progress_array) > 0:
             info_text += f"**Final progress:** {progress_array[-1]:.3f}\n"
+        if success_array is not None and len(success_array) > 0:
+            info_text += f"**Final success probability:** {success_array[-1]:.3f}\n"
 
-        return progress_plot, success_plot, info_text
+        # Return combined plot (which includes success if available)
+        return progress_plot, info_text
 
     except Exception as e:
-        return None, None, f"Error processing video: {str(e)}"
+        return None, f"Error processing video: {str(e)}"
 
 
 def process_dual_videos(
@@ -398,7 +442,7 @@ def process_dual_videos(
     """Process two videos for preference or similarity prediction using eval server."""
     if not server_url:
         return "Please provide a server URL and check connection first.", None
-    
+
     if not _server_state.get("server_url"):
         return "Server not connected. Please check server connection first.", None
 
@@ -475,6 +519,47 @@ def process_dual_videos(
             else:
                 result_text += "Could not extract preference prediction from server response.\n"
 
+        elif prediction_type == "progress":
+            # Create ProgressSamples for both videos
+            from rfm.data.dataset_types import ProgressSample
+
+            progress_sample_a = ProgressSample(
+                trajectory=trajectory_a,
+                data_gen_strategy="demo",
+            )
+            progress_sample_b = ProgressSample(
+                trajectory=trajectory_b,
+                data_gen_strategy="demo",
+            )
+
+            # Build payload and send to server
+            files, sample_data = build_payload([progress_sample_a, progress_sample_b])
+            response = post_batch_npy(server_url, files, sample_data, timeout_s=120.0)
+
+            # Process response
+            outputs_progress = response.get("outputs_progress", {})
+            progress_pred = outputs_progress.get("progress_pred", [])
+
+            result_text = f"**Progress Comparison:**\n"
+            if progress_pred and len(progress_pred) >= 2:
+                progress_a = np.array(progress_pred[0])
+                progress_b = np.array(progress_pred[1])
+
+                final_progress_a = float(progress_a[-1]) if len(progress_a) > 0 else 0.0
+                final_progress_b = float(progress_b[-1]) if len(progress_b) > 0 else 0.0
+
+                result_text += f"- Video A final progress: {final_progress_a:.3f}\n"
+                result_text += f"- Video B final progress: {final_progress_b:.3f}\n"
+                result_text += f"- Difference: {abs(final_progress_a - final_progress_b):.3f}\n"
+                if final_progress_a > final_progress_b:
+                    result_text += f"- Video A has higher progress\n"
+                elif final_progress_b > final_progress_a:
+                    result_text += f"- Video B has higher progress\n"
+                else:
+                    result_text += f"- Both videos have equal progress\n"
+            else:
+                result_text += "Could not extract progress predictions from server response.\n"
+
         else:  # similarity - not yet implemented in eval server response format
             result_text = "Similarity prediction not yet supported in eval server response format."
 
@@ -489,107 +574,49 @@ def process_dual_videos(
         return f"Error processing videos: {str(e)}", None
 
 
-def create_progress_plot(progress_pred: np.ndarray, num_frames: int) -> str:
-    """Create progress prediction plot."""
-    plt.rcParams['font.family'] = 'DejaVu Sans'
-    plt.rcParams['font.size'] = 16
-    
-    fig, ax = plt.subplots(figsize=(10, 6))
-    
-    if len(progress_pred) > 0:
-        frame_indices = np.arange(len(progress_pred))
-        ax.plot(frame_indices, progress_pred, 'b-', linewidth=3, marker='o', markersize=8, label='Progress Prediction')
-    else:
-        ax.text(0.5, 0.5, 'No progress prediction available', 
-                horizontalalignment='center', verticalalignment='center',
-                transform=ax.transAxes, fontsize=18)
-    
-    ax.set_xlabel('Frame Index', fontsize=18, fontweight='bold')
-    ax.set_ylabel('Progress (0-1)', fontsize=18, fontweight='bold')
-    ax.set_title('Progress Prediction', fontsize=20, fontweight='bold')
-    ax.set_ylim([0, 1])
-    
-    plt.tight_layout()
-    
-    tmp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.png')
-    plt.savefig(tmp_file.name, dpi=150, bbox_inches='tight')
-    plt.close()
-    
-    return tmp_file.name
-
-
-def create_success_plot(success_probs: np.ndarray, num_frames: int) -> str:
-    """Create success probability plot."""
-    plt.rcParams['font.family'] = 'DejaVu Sans'
-    plt.rcParams['font.size'] = 16
-    
-    fig, ax = plt.subplots(figsize=(10, 6))
-    
-    if len(success_probs) > 0:
-        frame_indices = np.arange(len(success_probs))
-        ax.plot(frame_indices, success_probs, 'g-', linewidth=3, marker='s', markersize=8, label='Success Probability')
-        ax.axhline(y=0.5, color='r', linestyle='--', linewidth=2, label='Decision Threshold (0.5)')
-    else:
-        ax.text(0.5, 0.5, 'No success prediction available', 
-                horizontalalignment='center', verticalalignment='center',
-                transform=ax.transAxes, fontsize=18)
-    
-    ax.set_xlabel('Frame Index', fontsize=18, fontweight='bold')
-    ax.set_ylabel('Success Probability (0-1)', fontsize=18, fontweight='bold')
-    ax.set_title('Success Prediction', fontsize=20, fontweight='bold')
-    ax.set_ylim([0, 1])
-    
-    plt.tight_layout()
-    
-    tmp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.png')
-    plt.savefig(tmp_file.name, dpi=150, bbox_inches='tight')
-    plt.close()
-    
-    return tmp_file.name
-
 def create_comparison_plot(frames_a: list, frames_b: list, prediction_type: str) -> str:
     """Create side-by-side comparison plot of two videos."""
-    plt.rcParams['font.family'] = 'DejaVu Sans'
-    plt.rcParams['font.size'] = 16
-    
+    plt.rcParams["font.family"] = "DejaVu Sans"
+    plt.rcParams["font.size"] = 16
+
     fig, axes = plt.subplots(2, min(8, max(len(frames_a), len(frames_b))), figsize=(16, 4))
-    
+
     if len(axes.shape) == 1:
         axes = axes.reshape(2, -1)
-    
+
     # Sample frames to display
     num_display = min(8, max(len(frames_a), len(frames_b)))
     indices_a = np.linspace(0, len(frames_a) - 1, num_display, dtype=int) if len(frames_a) > 1 else [0]
     indices_b = np.linspace(0, len(frames_b) - 1, num_display, dtype=int) if len(frames_b) > 1 else [0]
-    
+
     # Display frames from video A (top row)
     for idx, frame_idx in enumerate(indices_a):
         if frame_idx < len(frames_a):
             axes[0, idx].imshow(frames_a[frame_idx])
-            axes[0, idx].axis('off')
-            axes[0, idx].set_title(f'Frame {frame_idx}', fontsize=12)
-    
+            axes[0, idx].axis("off")
+            axes[0, idx].set_title(f"Frame {frame_idx}", fontsize=12)
+
     # Display frames from video B (bottom row)
     for idx, frame_idx in enumerate(indices_b):
         if frame_idx < len(frames_b):
             axes[1, idx].imshow(frames_b[frame_idx])
-            axes[1, idx].axis('off')
-            axes[1, idx].set_title(f'Frame {frame_idx}', fontsize=12)
-    
+            axes[1, idx].axis("off")
+            axes[1, idx].set_title(f"Frame {frame_idx}", fontsize=12)
+
     # Add row labels
-    fig.text(0.02, 0.75, 'Video A', rotation=90, fontsize=18, fontweight='bold', va='center')
-    fig.text(0.02, 0.25, 'Video B', rotation=90, fontsize=18, fontweight='bold', va='center')
-    
+    fig.text(0.02, 0.75, "Video A", rotation=90, fontsize=18, fontweight="bold", va="center")
+    fig.text(0.02, 0.25, "Video B", rotation=90, fontsize=18, fontweight="bold", va="center")
+
     title = f"{prediction_type.capitalize()} Comparison: Video A vs Video B"
-    fig.suptitle(title, fontsize=20, fontweight='bold', y=0.98)
-    
+    fig.suptitle(title, fontsize=20, fontweight="bold", y=0.98)
+
     plt.tight_layout()
-    
+
     # Save to temporary file
-    tmp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.png')
-    plt.savefig(tmp_file.name, dpi=150, bbox_inches='tight')
+    tmp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
+    plt.savefig(tmp_file.name, dpi=150, bbox_inches="tight")
     plt.close()
-    
+
     return tmp_file.name
 
 
@@ -619,7 +646,7 @@ with demo:
     with gr.Tab("Server Setup"):
         gr.Markdown("### Connect to Eval Server")
         gr.Markdown("Enter the eval server URL and check connection.")
-        
+
         with gr.Row():
             with gr.Column(scale=3):
                 server_url_input = gr.Textbox(
@@ -630,7 +657,7 @@ with demo:
                 )
             with gr.Column(scale=1):
                 check_connection_btn = gr.Button("Check Connection", variant="primary", size="sm")
-        
+
         server_status = gr.Markdown("Enter server URL and click 'Check Connection'")
         model_info_display = gr.Markdown("", visible=False)
 
@@ -641,7 +668,7 @@ with demo:
                 return status, gr.update(value=model_info_text, visible=True)
             else:
                 return status, gr.update(visible=False)
-        
+
         check_connection_btn.click(
             fn=on_check_connection,
             inputs=[server_url_input],
@@ -651,7 +678,7 @@ with demo:
     with gr.Tab("Progress Prediction"):
         gr.Markdown("### Progress & Success Prediction")
         gr.Markdown("Upload a video or select one from a dataset to get progress predictions.")
-        
+
         with gr.Row():
             with gr.Column():
                 with gr.Accordion("📁 Select from Dataset", open=False):
@@ -659,37 +686,29 @@ with demo:
                         choices=PREDEFINED_DATASETS,
                         value="jesbu1/oxe_rfm",
                         label="Dataset Name",
-                        allow_custom_value=True
+                        allow_custom_value=True,
                     )
                     config_name_single = gr.Dropdown(
-                        choices=[],
-                        value="",
-                        label="Configuration Name",
-                        allow_custom_value=True
+                        choices=[], value="", label="Configuration Name", allow_custom_value=True
                     )
                     with gr.Row():
                         refresh_configs_btn = gr.Button("🔄 Refresh Configs", variant="secondary", size="sm")
                         load_dataset_btn = gr.Button("Load Dataset", variant="secondary", size="sm")
-                    
+
                     dataset_status_single = gr.Markdown("", visible=False)
                     with gr.Row():
                         prev_traj_btn = gr.Button("⬅️ Prev", variant="secondary", size="sm")
                         trajectory_slider = gr.Slider(
-                            minimum=0,
-                            maximum=0,
-                            step=1,
-                            value=0,
-                            label="Trajectory Index",
-                            interactive=True
+                            minimum=0, maximum=0, step=1, value=0, label="Trajectory Index", interactive=True
                         )
                         next_traj_btn = gr.Button("Next ➡️", variant="secondary", size="sm")
                     trajectory_metadata = gr.Markdown("", visible=False)
                     use_dataset_video_btn = gr.Button("Use Selected Video", variant="secondary")
-                
+
                 gr.Markdown("---")
                 gr.Markdown("**OR**")
                 gr.Markdown("---")
-                
+
                 single_video_input = gr.Video(label="Upload Video", height=300)
                 task_text_input = gr.Textbox(
                     label="Task Description",
@@ -707,13 +726,12 @@ with demo:
                 analyze_single_btn = gr.Button("Analyze Video", variant="primary")
 
             with gr.Column():
-                progress_plot = gr.Image(label="Progress Prediction", height=400)
-                success_plot = gr.Image(label="Success Prediction", height=400)
+                progress_plot = gr.Image(label="Progress & Success Prediction", height=400)
                 info_output = gr.Markdown("")
-        
+
         # State variables for dataset
         current_dataset_single = gr.State(None)
-        
+
         def update_config_choices_single(dataset_name):
             """Update config choices when dataset changes."""
             if not dataset_name:
@@ -727,7 +745,7 @@ with demo:
             except Exception as e:
                 logger.warning(f"Could not fetch configs: {e}")
                 return gr.update(choices=[], value="")
-        
+
         def load_dataset_single(dataset_name, config_name):
             """Load dataset and update slider."""
             dataset, status = load_rfm_dataset(dataset_name, config_name)
@@ -736,16 +754,23 @@ with demo:
                 return (
                     dataset,
                     gr.update(value=status, visible=True),
-                    gr.update(maximum=max_index, value=0, interactive=True, label=f"Trajectory Index (0 to {max_index})")
+                    gr.update(
+                        maximum=max_index, value=0, interactive=True, label=f"Trajectory Index (0 to {max_index})"
+                    ),
                 )
             else:
                 return None, gr.update(value=status, visible=True), gr.update(maximum=0, value=0, interactive=False)
-        
+
         def use_dataset_video(dataset, index, dataset_name):
             """Load video from dataset and update inputs."""
             if dataset is None:
-                return None, "Complete the task", gr.update(value="No dataset loaded", visible=True), gr.update(visible=False)
-            
+                return (
+                    None,
+                    "Complete the task",
+                    gr.update(value="No dataset loaded", visible=True),
+                    gr.update(visible=False),
+                )
+
             video_path, task, quality_label, partial_success = get_trajectory_video_path(dataset, index, dataset_name)
             if video_path:
                 # Build metadata text
@@ -754,28 +779,35 @@ with demo:
                     metadata_lines.append(f"**Quality Label:** {quality_label}")
                 if partial_success is not None:
                     metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
-                
+
                 metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
                 status_text = f"✅ Loaded trajectory {index} from dataset"
                 if metadata_text:
                     status_text += f"\n\n{metadata_text}"
-                
+
                 return (
-                    video_path, 
-                    task, 
+                    video_path,
+                    task,
                     gr.update(value=status_text, visible=True),
-                    gr.update(value=metadata_text, visible=bool(metadata_text))
+                    gr.update(value=metadata_text, visible=bool(metadata_text)),
                 )
             else:
-                return None, "Complete the task", gr.update(value="❌ Error loading trajectory", visible=True), gr.update(visible=False)
-        
+                return (
+                    None,
+                    "Complete the task",
+                    gr.update(value="❌ Error loading trajectory", visible=True),
+                    gr.update(visible=False),
+                )
+
         def next_trajectory(dataset, current_idx, dataset_name):
             """Go to next trajectory."""
             if dataset is None:
                 return 0, None, "Complete the task", gr.update(visible=False), gr.update(visible=False)
             next_idx = min(current_idx + 1, len(dataset) - 1)
-            video_path, task, quality_label, partial_success = get_trajectory_video_path(dataset, next_idx, dataset_name)
-            
+            video_path, task, quality_label, partial_success = get_trajectory_video_path(
+                dataset, next_idx, dataset_name
+            )
+
             if video_path:
                 # Build metadata text
                 metadata_lines = []
@@ -783,25 +815,27 @@ with demo:
                     metadata_lines.append(f"**Quality Label:** {quality_label}")
                 if partial_success is not None:
                     metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
-                
+
                 metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
                 return (
                     next_idx,
                     video_path,
                     task,
                     gr.update(value=metadata_text, visible=bool(metadata_text)),
-                    gr.update(value=f"✅ Trajectory {next_idx}/{len(dataset) - 1}", visible=True)
+                    gr.update(value=f"✅ Trajectory {next_idx}/{len(dataset) - 1}", visible=True),
                 )
             else:
                 return current_idx, None, "Complete the task", gr.update(visible=False), gr.update(visible=False)
-        
+
         def prev_trajectory(dataset, current_idx, dataset_name):
             """Go to previous trajectory."""
             if dataset is None:
                 return 0, None, "Complete the task", gr.update(visible=False), gr.update(visible=False)
             prev_idx = max(current_idx - 1, 0)
-            video_path, task, quality_label, partial_success = get_trajectory_video_path(dataset, prev_idx, dataset_name)
-            
+            video_path, task, quality_label, partial_success = get_trajectory_video_path(
+                dataset, prev_idx, dataset_name
+            )
+
             if video_path:
                 # Build metadata text
                 metadata_lines = []
@@ -809,23 +843,23 @@ with demo:
                     metadata_lines.append(f"**Quality Label:** {quality_label}")
                 if partial_success is not None:
                     metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
-                
+
                 metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
                 return (
                     prev_idx,
                     video_path,
                     task,
                     gr.update(value=metadata_text, visible=bool(metadata_text)),
-                    gr.update(value=f"✅ Trajectory {prev_idx}/{len(dataset) - 1}", visible=True)
+                    gr.update(value=f"✅ Trajectory {prev_idx}/{len(dataset) - 1}", visible=True),
                 )
             else:
                 return current_idx, None, "Complete the task", gr.update(visible=False), gr.update(visible=False)
-        
+
         def update_trajectory_on_slider_change(dataset, index, dataset_name):
             """Update trajectory metadata when slider changes."""
             if dataset is None:
                 return gr.update(visible=False), gr.update(visible=False)
-            
+
             video_path, task, quality_label, partial_success = get_trajectory_video_path(dataset, index, dataset_name)
             if video_path:
                 # Build metadata text
@@ -834,64 +868,73 @@ with demo:
                     metadata_lines.append(f"**Quality Label:** {quality_label}")
                 if partial_success is not None:
                     metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
-                
+
                 metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
                 return (
                     gr.update(value=metadata_text, visible=bool(metadata_text)),
-                    gr.update(value=f"Trajectory {index}/{len(dataset) - 1}", visible=True)
+                    gr.update(value=f"Trajectory {index}/{len(dataset) - 1}", visible=True),
                 )
             else:
                 return gr.update(visible=False), gr.update(visible=False)
-        
+
         # Dataset selection handlers
         dataset_name_single.change(
-            fn=update_config_choices_single,
-            inputs=[dataset_name_single],
-            outputs=[config_name_single]
+            fn=update_config_choices_single, inputs=[dataset_name_single], outputs=[config_name_single]
         )
-        
+
         refresh_configs_btn.click(
-            fn=update_config_choices_single,
-            inputs=[dataset_name_single],
-            outputs=[config_name_single]
+            fn=update_config_choices_single, inputs=[dataset_name_single], outputs=[config_name_single]
         )
-        
+
         load_dataset_btn.click(
             fn=load_dataset_single,
             inputs=[dataset_name_single, config_name_single],
-            outputs=[current_dataset_single, dataset_status_single, trajectory_slider]
+            outputs=[current_dataset_single, dataset_status_single, trajectory_slider],
         )
-        
+
         use_dataset_video_btn.click(
             fn=use_dataset_video,
             inputs=[current_dataset_single, trajectory_slider, dataset_name_single],
-            outputs=[single_video_input, task_text_input, dataset_status_single, trajectory_metadata]
+            outputs=[single_video_input, task_text_input, dataset_status_single, trajectory_metadata],
         )
-        
+
         # Navigation buttons
         next_traj_btn.click(
             fn=next_trajectory,
             inputs=[current_dataset_single, trajectory_slider, dataset_name_single],
-            outputs=[trajectory_slider, single_video_input, task_text_input, trajectory_metadata, dataset_status_single]
+            outputs=[
+                trajectory_slider,
+                single_video_input,
+                task_text_input,
+                trajectory_metadata,
+                dataset_status_single,
+            ],
         )
-        
+
         prev_traj_btn.click(
             fn=prev_trajectory,
             inputs=[current_dataset_single, trajectory_slider, dataset_name_single],
-            outputs=[trajectory_slider, single_video_input, task_text_input, trajectory_metadata, dataset_status_single]
+            outputs=[
+                trajectory_slider,
+                single_video_input,
+                task_text_input,
+                trajectory_metadata,
+                dataset_status_single,
+            ],
         )
-        
+
         # Update metadata when slider changes
         trajectory_slider.change(
             fn=update_trajectory_on_slider_change,
             inputs=[current_dataset_single, trajectory_slider, dataset_name_single],
-            outputs=[trajectory_metadata, dataset_status_single]
+            outputs=[trajectory_metadata, dataset_status_single],
         )
-        
+
         analyze_single_btn.click(
             fn=process_single_video,
             inputs=[single_video_input, task_text_input, server_url_input, fps_input_single],
-            outputs=[progress_plot, success_plot, info_output],
+            outputs=[progress_plot, info_output],
+            api_name="process_single_video",
         )
 
     with gr.Tab("Preference/Similarity Analysis"):
@@ -906,7 +949,7 @@ with demo:
                     value="Complete the task",
                 )
                 prediction_type = gr.Radio(
-                    choices=["preference", "similarity"],
+                    choices=["preference", "similarity", "progress"],
                     value="preference",
                     label="Prediction Type",
                 )
@@ -928,16 +971,17 @@ with demo:
             fn=process_dual_videos,
             inputs=[video_a_input, video_b_input, task_text_dual, prediction_type, server_url_input, fps_input_dual],
             outputs=[result_text, comparison_plot],
+            api_name="process_dual_videos",
         )
 
 
 def main():
     """Launch the Gradio app."""
     import sys
-    
+
     # Check if reload mode is requested
     watch_files = os.getenv("GRADIO_WATCH", "0") == "1" or "--reload" in sys.argv
-    
+
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,