update the table to video gallery

app.py

@@ -10,12 +10,10 @@ import gradio as gr
 from huggingface_hub import hf_hub_download
 
 
-# Make project root importable so we can reuse main.py
 ROOT_DIR = Path(__file__).resolve().parent
 if str(ROOT_DIR) not in sys.path:
     sys.path.append(str(ROOT_DIR))
 
-# Import only the existing pipelines from main.py
 from main import run_both_tasks, run_frame_reordering, run_outlier_detection  # type: ignore
 
 
@@ -43,7 +41,6 @@ def _get_example_videos_per_task(max_examples: int = 7) -> Dict[str, List[List[o
     tasks = ("outliers", "reorder", "both")
     examples: Dict[str, List[List[object]]] = {t: [] for t in tasks}
 
-    # List of video files to download (add your actual filenames here)
     video_files = [
         "v_FieldHockeyPenalty_g23_c04.mp4",
         "v_BalanceBeam_g11_c03.mp4",
@@ -54,36 +51,24 @@ def _get_example_videos_per_task(max_examples: int = 7) -> Dict[str, List[List[o
         "v_BalanceBeam_g13_c01.mp4",
     ]
 
-    # Create a temp directory for examples
     temp_dir = Path(tempfile.gettempdir()) / "gradio_examples"
     temp_dir.mkdir(exist_ok=True)
 
     try:
         for video_file in video_files[:max_examples]:
-            # Download video from HF dataset
             cached_path = hf_hub_download(
                 repo_id=dataset_repo,
                 filename=video_file,
                 repo_type="dataset"
             )
 
-            # Copy to temp directory to avoid Gradio path restrictions
             temp_video_path = temp_dir / video_file
             if not temp_video_path.exists():
                 shutil.copy2(cached_path, temp_video_path)
 
             for t in tasks:
                 if len(examples[t]) < max_examples:
-                    # Inputs: video, model_type, eps, min_samples, batch_size
-                    examples[t].append(
-                        [
-                            str(temp_video_path),
-                            "clip",
-                            0.5,
-                            40,
-                            64,
-                        ]
-                    )
+                    examples[t].append(str(temp_video_path))
 
             if all(len(examples[t]) >= max_examples for t in tasks):
                 break
@@ -125,7 +110,6 @@ def process_video(
     if not input_path.exists():
         raise gr.Error(f"Video not found: {input_path}")
 
-    # Outputs are written to a local folder relative to the project root.
     outputs_root = ROOT_DIR / "hf_space_outputs"
     outputs_root.mkdir(parents=True, exist_ok=True)
 
@@ -153,7 +137,7 @@ def _build_task_tab(
     task_value: str,
     title: str,
     description: str,
-    examples: List[List[object]],
+    examples: List[str],
 ):
     """Create a single tab for a specific task."""
     with gr.Tab(title):
@@ -196,14 +180,12 @@ def _build_task_tab(
             with gr.Column():
                 output_video = gr.Video(label="Processed video")
 
-        # Update DBSCAN parameters when model changes
         model_input.change(
             fn=update_dbscan_params,
             inputs=[model_input],
             outputs=[eps_input, min_samples_input],
         )
 
-        # Fix the task per tab; user can upload any video.
         run_button.click(
             fn=partial(process_video, task=task_value),
             inputs=[
@@ -219,14 +201,8 @@ def _build_task_tab(
         if examples:
             gr.Examples(
                 examples=examples,
-                inputs=[
-                    video_input,
-                    model_input,
-                    eps_input,
-                    min_samples_input,
-                    batch_size_input,
-                ],
-                label="Examples from ./inference",
+                inputs=video_input,
+                label="Example Videos",
             )
 
 

main.py

@@ -52,16 +52,9 @@ from tqdm import tqdm
 from outliers_removal_algorithm import dbscan_outliers, USE_GPU
 from reorder_frames_algorithm import load_video_gray, compute_mse_matrix, build_best_path
 
-# Device configuration
 DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-
-# Supported video extensions
 VIDEO_EXTS = ('.avi', '.mp4', '.mov', '.mkv')
 
-# ==========================================
-# EMBEDDING EXTRACTION (Outlier Detection)
-# ==========================================
-
 def load_embedding_model(model_type='clip', model_path=None, device='cuda'):
     """Load CLIP, DINOv2, or ResNet18 model for embedding extraction."""
     print(f"Loading {model_type.upper()} model...")
@@ -118,16 +111,10 @@ def load_embedding_model(model_type='clip', model_path=None, device='cuda'):
             features = feature_extractor(images)
             feats = torch.tensor(features, device=device)
 
-            # Debug: Print shape before processing
             if feats.dim() > 2:
-                print(f"DEBUG: DINOv2 features shape before squeeze: {feats.shape}")
                 feats = feats.squeeze(1)
 
             feats = torch.nn.functional.normalize(feats, dim=-1)
-
-            # Debug: Print statistics
-            print(f"DEBUG: DINOv2 batch - shape: {feats.shape}, mean: {feats.mean():.4f}, std: {feats.std():.4f}, min: {feats.min():.4f}, max: {feats.max():.4f}")
-
             return feats
 
         print(f"DINOv2 model loaded: {model_path} ({embedding_dim}-dim)")
@@ -136,9 +123,7 @@ def load_embedding_model(model_type='clip', model_path=None, device='cuda'):
     elif model_type == 'resnet18':
         from torchvision import models, transforms
 
-        # Load ResNet18 pretrained model
         model = models.resnet18(pretrained=True)
-        # Remove the final classification layer to get embeddings
         model = torch.nn.Sequential(*list(model.children())[:-1])
         model = model.to(device)
         model.eval()
@@ -227,10 +212,6 @@ def extract_video_embeddings(video_path, extract_fn, preprocess, device='cuda',
     return embeddings, fps, width, height
 
 
-# ==========================================
-# VIDEO SAVING
-# ==========================================
-
 def save_cleaned_video(video_path, predictions, output_path, fps, width, height):
     """Create cleaned video with outliers removed."""
     num_outliers = predictions.sum()
@@ -271,7 +252,6 @@ def save_cleaned_video(video_path, predictions, output_path, fps, width, height)
 
 def save_reordered_video(video_path, frame_order, output_path):
     """Create reordered video using predicted frame order."""
-    # Load all frames
     cap = cv2.VideoCapture(str(video_path))
     frames = []
     while True:
@@ -288,7 +268,6 @@ def save_reordered_video(video_path, frame_order, output_path):
     print(f"  Total frames: {len(frames)}")
     print(f"  Reconstructed order: {len(frame_order)} frames")
 
-    # Write reordered video
     fourcc = cv2.VideoWriter_fourcc(*'XVID')
     out = cv2.VideoWriter(str(output_path), fourcc, fps, (width, height))
 
@@ -305,7 +284,6 @@ def save_reordered_video(video_path, frame_order, output_path):
 
 def save_cleaned_and_reordered_video(video_path, outlier_predictions, frame_order, output_path):
     """Create video with outliers removed and frames reordered in one pass."""
-    # Load all frames
     cap = cv2.VideoCapture(str(video_path))
     all_frames = []
     while True:
@@ -318,7 +296,6 @@ def save_cleaned_and_reordered_video(video_path, outlier_predictions, frame_orde
     height, width = all_frames[0].shape[:2]
     cap.release()
 
-    # Filter out outliers
     inlier_frames = [all_frames[i] for i in range(len(all_frames))
                      if i < len(outlier_predictions) and not outlier_predictions[i]]
 
@@ -329,7 +306,6 @@ def save_cleaned_and_reordered_video(video_path, outlier_predictions, frame_orde
     print(f"  Inlier frames: {len(inlier_frames)} ({100*len(inlier_frames)/len(all_frames):.1f}%)")
     print(f"  Reordered frames: {len(frame_order)}")
 
-    # Write reordered video with only inlier frames
     fourcc = cv2.VideoWriter_fourcc(*'XVID')
     out = cv2.VideoWriter(str(output_path), fourcc, fps, (width, height))
 
@@ -344,28 +320,21 @@ def save_cleaned_and_reordered_video(video_path, outlier_predictions, frame_orde
     return output_path
 
 
-# ==========================================
-# MAIN PIPELINE
-# ==========================================
-
 def run_outlier_detection(video_path, output_path, args):
     """Run outlier detection pipeline using imported functions."""
     print("OUTLIER DETECTION")
     print(f"GPU Acceleration: {'Enabled (cuML)' if USE_GPU else 'Disabled (CPU/sklearn)'}")
 
-    # Load embedding model
     extract_fn, preprocess, embedding_dim = load_embedding_model(
         model_type=args.model_type,
         model_path=args.model_path,
         device=DEVICE
     )
 
-    # Extract embeddings
     embeddings, fps, width, height = extract_video_embeddings(
         video_path, extract_fn, preprocess, DEVICE, args.batch_size
     )
 
-    # Detect outliers using DBSCAN
     print(f"\nRunning DBSCAN outlier detection...")
     predictions = dbscan_outliers(
         embeddings,
@@ -373,7 +342,6 @@ def run_outlier_detection(video_path, output_path, args):
         min_samples=args.min_samples
     )
 
-    # Save cleaned video
     cleaned_path = save_cleaned_video(video_path, predictions, output_path, fps, width, height)
     return cleaned_path
 
@@ -394,7 +362,6 @@ def run_frame_reordering(video_path, output_path):
     print("Building temporal path...")
     path = build_best_path(mse)
 
-    # Save reordered video
     reordered_path = save_reordered_video(video_path, path, output_path)
     return reordered_path
 
@@ -406,7 +373,6 @@ def run_both_tasks(video_path, output_path, args):
     print("=" * 80)
     print(f"GPU Acceleration: {'Enabled (cuML)' if USE_GPU else 'Disabled (CPU/sklearn)'}")
 
-    # Load embedding model and extract embeddings
     extract_fn, preprocess, embedding_dim = load_embedding_model(
         model_type=args.model_type,
         model_path=args.model_path,
@@ -417,19 +383,7 @@ def run_both_tasks(video_path, output_path, args):
         video_path, extract_fn, preprocess, DEVICE, args.batch_size
     )
 
-    # Detect outliers using DBSCAN
     print(f"\nRunning DBSCAN outlier detection...")
-    print(f"DEBUG: Final embeddings before DBSCAN - shape: {embeddings.shape}, mean: {embeddings.mean():.4f}, std: {embeddings.std():.4f}")
-    print(f"DEBUG: Embeddings range - min: {embeddings.min():.4f}, max: {embeddings.max():.4f}")
-
-    # Compute pairwise distances to understand embedding space
-    import numpy as np
-    from scipy.spatial.distance import pdist
-    emb_np = embeddings.cpu().numpy() if hasattr(embeddings, 'cpu') else embeddings
-    distances = pdist(emb_np, metric='euclidean')
-    print(f"DEBUG: Pairwise distances - mean: {distances.mean():.4f}, std: {distances.std():.4f}, min: {distances.min():.4f}, max: {distances.max():.4f}")
-    print(f"DEBUG: Current eps={args.eps}, so distances > eps will not form clusters")
-
     outlier_predictions = dbscan_outliers(
         embeddings,
         eps=args.eps,
@@ -443,20 +397,17 @@ def run_both_tasks(video_path, output_path, args):
     print(f"  Inliers: {num_inliers} ({100*num_inliers/len(outlier_predictions):.1f}%)")
     print(f"  Outliers: {num_outliers} ({100*num_outliers/len(outlier_predictions):.1f}%)")
 
-    # Step 2: Frame reordering on inlier frames
     print("\n" + "=" * 80)
     print("STEP 2: FRAME REORDERING (on inlier frames)")
     print("=" * 80)
 
     all_frames = load_video_gray(str(video_path))
 
-    # Filter to only inlier frames
     inlier_frames = []
     for i in range(len(all_frames)):
         if i < len(outlier_predictions) and not outlier_predictions[i]:
             inlier_frames.append(all_frames[i])
 
-    # Check if we have any inlier frames
     if len(inlier_frames) == 0:
         print("\n⚠️  WARNING: All frames were detected as outliers!")
         print("This typically means the DBSCAN parameters are too strict for this video.")
@@ -467,7 +418,6 @@ def run_both_tasks(video_path, output_path, args):
         print("  - Try a different embedding model")
         print("\nReturning original video without processing...")
 
-        # Copy original video to output
         import shutil
         shutil.copy2(video_path, output_path)
         return str(output_path)
@@ -476,7 +426,6 @@ def run_both_tasks(video_path, output_path, args):
     mse = compute_mse_matrix(inlier_frames)
     path = build_best_path(mse)
 
-    # Save final video (cleaned and reordered)
     final_path = save_cleaned_and_reordered_video(video_path, outlier_predictions, path, output_path)
     return final_path
 
@@ -486,13 +435,11 @@ def get_output_path(input_path, output_dir, suffix="_fixed"):
     input_path = Path(input_path)
 
     if output_dir:
-        # Use specified output directory
         output_dir = Path(output_dir)
         output_dir.mkdir(exist_ok=True, parents=True)
         output_name = f"{input_path.stem}{suffix}{input_path.suffix}"
         return output_dir / output_name
     else:
-        # Save in same directory as input
         output_name = f"{input_path.stem}{suffix}{input_path.suffix}"
         return input_path.parent / output_name
 
@@ -511,10 +458,8 @@ def process_single_video(video_path, args):
     print(f"Task: {args.task.upper()}")
     print("=" * 80)
 
-    # Determine output path
     output_path = get_output_path(video_path, args.output_dir)
 
-    # Execute tasks
     if args.task == "outliers":
         run_outlier_detection(str(video_path), str(output_path), args)
 
@@ -522,7 +467,6 @@ def process_single_video(video_path, args):
         run_frame_reordering(str(video_path), str(output_path))
 
     elif args.task == "both":
-        # Run both tasks without saving intermediate video
         run_both_tasks(str(video_path), str(output_path), args)
 
     print("\n" + "=" * 80)
@@ -539,7 +483,6 @@ def process_directory(input_dir, args):
         print(f"Error: Directory not found: {input_dir}")
         return
 
-    # Find all video files
     video_files = []
     for ext in VIDEO_EXTS:
         video_files.extend(input_dir.glob(f"*{ext}"))
@@ -555,15 +498,12 @@ def process_directory(input_dir, args):
     print(f"Found {len(video_files)} video(s) in {input_dir}")
     print("=" * 80)
 
-    # Process each video
     for i, video_path in enumerate(video_files, 1):
         print(f"\n[{i}/{len(video_files)}] Processing: {video_path.name}")
 
-        # Determine output path
         output_path = get_output_path(video_path, args.output_dir)
 
         try:
-            # Execute tasks
             if args.task == "outliers":
                 run_outlier_detection(str(video_path), str(output_path), args)
 
@@ -571,7 +511,6 @@ def process_directory(input_dir, args):
                 run_frame_reordering(str(video_path), str(output_path))
 
             elif args.task == "both":
-                # Run both tasks without saving intermediate video
                 run_both_tasks(str(video_path), str(output_path), args)
 
             print(f"  ✓ Saved: {output_path}")
@@ -590,29 +529,24 @@ def main():
         description="Main script for video processing: outlier detection (DBSCAN) and/or frame reordering"
     )
 
-    # Input arguments (mutually exclusive)
     input_group = parser.add_mutually_exclusive_group(required=True)
     input_group.add_argument("--video",
                            help="Process a single video file")
     input_group.add_argument("--input-dir",
                            help="Process all videos in a directory (default: ./inference)")
 
-    # Task selection
     parser.add_argument("--task", required=True, choices=["outliers", "reorder", "both"],
                        help="Task to perform: outliers, reorder, or both")
 
-    # Output directory (optional)
     parser.add_argument("--output-dir",
                        help="Output directory (default: same as input directory)")
 
-    # Outlier detection parameters
     parser.add_argument("--model-type", default="clip", choices=["clip", "dinov2", "resnet18"],
                        help="Embedding model type for outlier detection")
     parser.add_argument("--model-path", help="Path to DINOv2 model (optional)")
     parser.add_argument("--batch-size", type=int, default=128,
                        help="Batch size for embedding extraction")
 
-    # DBSCAN parameters
     parser.add_argument("--eps", type=float, default=0.5,
                        help="DBSCAN: Epsilon parameter")
     parser.add_argument("--min-samples", type=int, default=40,
@@ -620,13 +554,9 @@ def main():
 
     args = parser.parse_args()
 
-    # Default to ./inference if neither --video nor --input-dir specified
-    # (This won't happen due to required=True, but keeping for clarity)
-
     if args.task in ["outliers", "both"]:
         print(f"DBSCAN parameters: eps={args.eps}, min_samples={args.min_samples}")
 
-    # Process based on input mode
     if args.video:
         process_single_video(args.video, args)
     elif args.input_dir: