Update app.py

app.py

@@ -1,254 +1,239 @@
 #!/usr/bin/env python3
 # ========================= PRE-IMPORT ENV GUARDS =========================
 import os
-# Remove invalid OMP setting or tame thread counts BEFORE importing numpy/cv2/torch
-os.environ.pop("OMP_NUM_THREADS", None)           # or set "1"
+os.environ.pop("OMP_NUM_THREADS", None)
 os.environ.setdefault("MKL_NUM_THREADS", "1")
 os.environ.setdefault("OPENBLAS_NUM_THREADS", "1")
 os.environ.setdefault("NUMEXPR_NUM_THREADS", "1")
-# Optional CUDA allocator tuning
 os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "max_split_size_mb:1024")
 os.environ.setdefault("CUDA_LAUNCH_BLOCKING", "0")
 # ========================================================================
 
 """
-High-Quality Video Background Replacement - MAIN APPLICATION
-Upload video → Choose professional background → Replace with cinema quality
-Features: SAM2 + MatAnyone with multi-fallback loading, professional backgrounds,
-cinema-quality processing, lazy loading, and enhanced stability
+CORE VIDEO PROCESSING - Fast startup with UI separation
+SAM2 + MatAnyone processing core with persistent model caching
 """
 
 import sys
-import tempfile
 import cv2
 import numpy as np
 from pathlib import Path
-import gradio as gr
 import torch
-import requests
-from PIL import Image, ImageDraw, ImageFilter, ImageEnhance
-import json
 import traceback
 import time
 import shutil
 import gc
 import threading
-import queue
-from typing import Optional, Tuple, Dict, Any
+import pickle
+from typing import Optional
 import logging
-import warnings
+from huggingface_hub import hf_hub_download
 
-# Import your utilities
-from utilities import *  # must provide required helpers & PROFESSIONAL_BACKGROUNDS
+# Import utilities
+from utilities import *
 
-warnings.filterwarnings("ignore")
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 # ============================================================================ #
-# GRADIO MONKEY PATCH (BUG FIX for gradio>=4.44.0)
+# FAST RESTART MODEL CACHING SYSTEM
 # ============================================================================ #
-try:
-    import gradio_client.utils as gc_utils
-    original_get_type = gc_utils.get_type
-    def patched_get_type(schema):
-        if not isinstance(schema, dict):
-            if isinstance(schema, bool):
-                return "boolean"
-            return "string"
-        return original_get_type(schema)
-    gc_utils.get_type = patched_get_type
-    logger.info("Applied Gradio schema validation monkey patch.")
-except (ImportError, AttributeError) as e:
-    logger.warning(f"Could not apply Gradio monkey patch: {e}")
+CACHE_DIR = Path("/tmp/persistent_models")
+CACHE_DIR.mkdir(exist_ok=True, parents=True)
 
-# ============================================================================ #
-# SAM2 LOADER (Hydra search path; pass STRING config name to build_sam2)
-# ============================================================================ #
-def load_sam2_predictor(device: str = "cuda", progress: Optional[gr.Progress] = None):
-    """Loads SAM2 and returns SAM2ImagePredictor. Uses STRING config name for build_sam2."""
-    import hydra
-
-    sam_logger = logging.getLogger("SAM2Loader")
-    configs_dir = os.path.abspath("Configs")
-    sam_logger.info(f"Looking for SAM2 configs in absolute path: {configs_dir}")
-
-    if not os.path.isdir(configs_dir):
-        raise gr.Error(f"FATAL: SAM2 Configs directory not found at '{configs_dir}'")
-
-    def _maybe_progress(pct: float, desc: str):
-        if progress is not None:
-            try: progress(pct, desc=desc)
-            except Exception: pass
-
-    def try_load(config_name_with_yaml: str, checkpoint_name: str):
-        try:
-            checkpoint_path = os.path.join("./checkpoints", checkpoint_name)
-            sam_logger.info(f"Attempting to use checkpoint: {checkpoint_path}")
-
-            if not os.path.exists(checkpoint_path):
-                sam_logger.info(f"Downloading {checkpoint_name} from Hugging Face Hub...")
-                _maybe_progress(0.1, f"Downloading {checkpoint_name}...")
-                from huggingface_hub import hf_hub_download
-                repo = f"facebook/{config_name_with_yaml.replace('.yaml','')}"
-                checkpoint_path = hf_hub_download(
-                    repo_id=repo,
-                    filename=checkpoint_name,
-                    cache_dir="./checkpoints",
-                    local_dir_use_symlinks=False
-                )
-                sam_logger.info(f"Download complete: {checkpoint_path}")
-
-            # Reset & init Hydra so its repo includes ./Configs
-            if hydra.core.global_hydra.GlobalHydra.instance().is_initialized():
-                hydra.core.global_hydra.GlobalHydra.instance().clear()
-            hydra.initialize(
-                version_base=None,
-                config_path=os.path.relpath(configs_dir),
-                job_name=f"sam2_load_{int(time.time())}"
-            )
+def get_cache_path(model_name: str) -> Path:
+    return CACHE_DIR / f"{model_name}_cached.pkl"
 
-            # Pass STRING config name to build_sam2
-            config_name = config_name_with_yaml.replace(".yaml", "")
-
-            from sam2.build_sam import build_sam2
-            from sam2.sam2_image_predictor import SAM2ImagePredictor
-
-            sam_logger.info(f"Trying to load {config_name_with_yaml} on {device} with checkpoint {checkpoint_path}")
-            _maybe_progress(0.3, f"Loading {config_name_with_yaml}...")
-
-            sam2_model = build_sam2(config_name, checkpoint_path)
-            sam2_model.to(device)
-            predictor = SAM2ImagePredictor(sam2_model)
-            sam_logger.info(f"Loaded {config_name_with_yaml} successfully on {device}")
-            return predictor
+def save_model_to_cache(model, model_name: str):
+    try:
+        cache_path = get_cache_path(model_name)
+        if hasattr(model, 'model') and hasattr(model.model, 'to'):
+            model.model.to('cpu')
+        elif hasattr(model, 'to'):
+            model.to('cpu')
+        
+        with open(cache_path, 'wb') as f:
+            pickle.dump(model, f)
+        logger.info(f"Model {model_name} cached successfully")
+        return True
+    except Exception as e:
+        logger.warning(f"Failed to cache {model_name}: {e}")
+        return False
 
-        except Exception as e:
-            err = f"Failed to load {config_name_with_yaml}: {e}\nTraceback: {traceback.format_exc()}"
-            sam_logger.warning(err)
+def load_model_from_cache(model_name: str, device: str):
+    try:
+        cache_path = get_cache_path(model_name)
+        if not cache_path.exists():
             return None
-
-    predictor = try_load("sam2_hiera_large.yaml", "sam2_hiera_large.pt")
-    if predictor is None:
-        raise gr.Error("SAM2 loading failed for large model. Check configs/checkpoint.")
-    return predictor
+        
+        with open(cache_path, 'rb') as f:
+            model = pickle.load(f)
+        
+        if hasattr(model, 'model') and hasattr(model.model, 'to'):
+            model.model.to(device)
+        elif hasattr(model, 'to'):
+            model.to(device)
+        
+        logger.info(f"Model {model_name} loaded from cache")
+        return model
+    except Exception as e:
+        logger.warning(f"Failed to load {model_name} from cache: {e}")
+        return None
 
 # ============================================================================ #
-# MatAnyone LOADER (simple Hugging Face approach)
+# FAST SAM2 LOADER
 # ============================================================================ #
-def load_matanyone(device: str):
-    """
-    Load MatAnyone using the simple Hugging Face approach as documented
-    """
-    ma_logger = logging.getLogger("MatAnyoneLoader")
+def load_sam2_predictor_fast(device: str = "cuda", progress_callback=None):
+    def _prog(pct: float, desc: str):
+        if progress_callback:
+            progress_callback(pct, desc)
+
+    # Try cache first
+    _prog(0.1, "Checking SAM2 cache...")
+    cached_predictor = load_model_from_cache("sam2_predictor", device)
+    if cached_predictor is not None:
+        _prog(1.0, "SAM2 loaded from cache!")
+        return cached_predictor
+
+    # Load fresh
+    _prog(0.2, "Loading SAM2 fresh...")
+    try:
+        checkpoint_path = hf_hub_download(
+            repo_id="facebook/sam2-hiera-large",
+            filename="sam2_hiera_large.pt",
+            cache_dir=str(CACHE_DIR / "sam2_checkpoint")
+        )
+        _prog(0.6, "Building SAM2...")
+        
+        from sam2.build_sam import build_sam2
+        from sam2.sam2_image_predictor import SAM2ImagePredictor
+        
+        sam2_model = build_sam2("sam2_hiera_l.yaml", checkpoint_path)
+        sam2_model.to(device)
+        predictor = SAM2ImagePredictor(sam2_model)
+        
+        _prog(0.9, "Caching SAM2...")
+        save_model_to_cache(predictor, "sam2_predictor")
+        predictor.model.to(device)
+        
+        _prog(1.0, "SAM2 ready!")
+        return predictor
+        
+    except Exception as e:
+        logger.error(f"SAM2 loading failed: {e}")
+        raise
 
+# ============================================================================ #
+# FAST MATANYONE LOADER  
+# ============================================================================ #
+def load_matanyone_fast(progress_callback=None):
+    def _prog(pct: float, desc: str):
+        if progress_callback:
+            progress_callback(pct, desc)
+
+    # Try cache first
+    _prog(0.1, "Checking MatAnyone cache...")
+    cached_processor = load_model_from_cache("matanyone", "cpu")
+    if cached_processor is not None:
+        _prog(1.0, "MatAnyone loaded from cache!")
+        return cached_processor
+
+    # Load fresh
+    _prog(0.3, "Loading MatAnyone fresh...")
     try:
-        # Use the official approach from MatAnyone documentation
         from matanyone import InferenceCore
-        ma_logger.info("MatAnyone package found, creating InferenceCore...")
-        
-        # Use the Hugging Face model as specified in the documentation
         processor = InferenceCore("PeiqingYang/MatAnyone")
-        ma_logger.info("MatAnyone loaded successfully via Hugging Face")
+        
+        _prog(0.8, "Caching MatAnyone...")
+        save_model_to_cache(processor, "matanyone")
+        
+        _prog(1.0, "MatAnyone ready!")
         return processor
         
-    except ImportError as e:
-        ma_logger.error(f"MatAnyone package not found: {e}")
-        raise RuntimeError(f"MatAnyone package not installed. Please install with: pip install git+https://github.com/pq-yang/MatAnyone")
     except Exception as e:
-        ma_logger.error(f"Failed to create MatAnyone InferenceCore: {e}")
-        raise RuntimeError(f"MatAnyone initialization failed: {e}")
+        logger.error(f"MatAnyone loading failed: {e}")
+        raise
 
 # ============================================================================ #
-# GLOBALS & MODEL SETUP
+# GLOBAL MODEL STATE
 # ============================================================================ #
 sam2_predictor = None
 matanyone_model = None
 models_loaded = False
 loading_lock = threading.Lock()
 
-def download_and_setup_models(progress: Optional[gr.Progress] = None):
-    """Download and setup models. BOTH SAM2 and MatAnyone are REQUIRED."""
+def load_models_fast(progress_callback=None):
+    """Fast model loading with caching"""
     global sam2_predictor, matanyone_model, models_loaded
 
     with loading_lock:
         if models_loaded:
-            return "SAM2 + MatAnyone already loaded"
+            return "Models already loaded"
 
         try:
-            logger.info("Starting ENHANCED model loading...")
+            start_time = time.time()
             device = "cuda" if torch.cuda.is_available() else "cpu"
-
-            # --- Load SAM2 (required) ---
-            local_sam2 = load_sam2_predictor(device=device, progress=progress)
-            sam2_predictor = local_sam2
-
-            # --- Load MatAnyone (required) ---
-            local_matanyone = load_matanyone(device)
-            matanyone_model = local_matanyone
+            
+            sam2_predictor = load_sam2_predictor_fast(device=device, progress_callback=progress_callback)
+            matanyone_model = load_matanyone_fast(progress_callback=progress_callback)
 
             models_loaded = True
-            logger.info("--- All models loaded successfully (SAM2 + MatAnyone) ---")
-            return "SAM2 + MatAnyone loaded successfully!"
+            load_time = time.time() - start_time
+            
+            message = f"SAM2 + MatAnyone loaded in {load_time:.1f}s!"
+            logger.info(message)
+            return message
+            
         except Exception as e:
-            logger.error(f"Enhanced loading failed: {str(e)}")
-            logger.error(f"Full traceback: {traceback.format_exc()}")
-            return f"Enhanced loading failed: {str(e)}"
+            logger.error(f"Model loading failed: {str(e)}")
+            return f"Model loading failed: {str(e)}"
 
 # ============================================================================ #
-# TWO-STAGE PROCESSING PIPELINE (uses your utilities' segmentation/compositing)
+# CORE VIDEO PROCESSING
 # ============================================================================ #
-def create_green_screen_background(frame):
-    """Create a pure green screen background for the frame"""
-    return np.full_like(frame, (0, 255, 0), dtype=np.uint8)
-
-def process_video_hq(video_path, background_choice, custom_background_path, progress: Optional[gr.Progress] = None):
-    """SINGLE-STAGE High-quality video processing: Original → Final Background"""
+def process_video_core(video_path, background_choice, custom_background_path, progress_callback=None):
+    """Core video processing function"""
     if not models_loaded:
-        return None, "Models not loaded. Click 'Load Models' first."
+        return None, "Models not loaded. Call load_models_fast() first."
     if not video_path:
         return None, "No video file provided."
 
     def _prog(pct: float, desc: str):
-        if progress is not None:
-            try: progress(pct, desc=desc)
-            except Exception: pass
+        if progress_callback:
+            progress_callback(pct, desc)
 
     try:
-        _prog(0.0, "Initializing SINGLE-STAGE processing...")
+        _prog(0.0, "Starting processing...")
 
         if not os.path.exists(video_path):
             return None, f"Video file not found: {video_path}"
 
         cap = cv2.VideoCapture(video_path)
         if not cap.isOpened():
-            return None, "Could not open video file. Please check the format."
+            return None, "Could not open video file."
 
         fps = cap.get(cv2.CAP_PROP_FPS)
         total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
         frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
         frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-        logger.info(f"Video properties: {frame_width}x{frame_height}, {fps}fps, {total_frames} frames")
 
         if total_frames == 0:
-            return None, "Video appears to be empty or corrupted."
+            return None, "Video appears to be empty."
 
-        # Prepare final background
+        # Prepare background
         background = None
         background_name = ""
 
         if background_choice == "custom" and custom_background_path:
             background = cv2.imread(custom_background_path)
             if background is None:
-                return None, "Could not read custom background image. Please check the file format."
+                return None, "Could not read custom background image."
             background_name = "Custom Image"
-            logger.info("Using custom background image")
         else:
             if background_choice in PROFESSIONAL_BACKGROUNDS:
                 bg_config = PROFESSIONAL_BACKGROUNDS[background_choice]
                 background = create_professional_background(bg_config, frame_width, frame_height)
                 background_name = bg_config["name"]
-                logger.info(f"Using professional background: {background_name}")
             else:
                 return None, f"Invalid background selection: {background_choice}"
 
@@ -258,43 +243,44 @@ def process_video_hq(video_path, background_choice, custom_background_path, prog
         timestamp = int(time.time())
         fourcc = cv2.VideoWriter_fourcc(*'mp4v')
 
-        # SINGLE-STAGE: Original → Final Background
-        _prog(0.1, f"SINGLE-STAGE: Replacing background with {background_name}...")
-        final_path = f"/tmp/final_output_{timestamp}.mp4"
+        _prog(0.1, f"Processing with {background_name}...")
+        final_path = f"/tmp/output_{timestamp}.mp4"
         final_writer = cv2.VideoWriter(final_path, fourcc, fps, (frame_width, frame_height))
+        
         if not final_writer.isOpened():
             return None, "Could not create output video file."
 
         frame_count = 0
-        keyframe_interval = 3  # Process MatAnyone every 3rd frame
+        keyframe_interval = 3  # MatAnyone every 3rd frame
         last_refined_mask = None
         
         while True:
             ret, frame = cap.read()
             if not ret:
                 break
+                
             try:
-                _prog(0.1 + (frame_count / max(1, total_frames)) * 0.8, f"Processing frame {frame_count + 1}/{total_frames}")
+                _prog(0.1 + (frame_count / max(1, total_frames)) * 0.8, 
+                     f"Frame {frame_count + 1}/{total_frames}")
                 
-                # Always run SAM2 segmentation
+                # SAM2 segmentation
                 mask = segment_person_hq(frame, sam2_predictor)
                 
-                # Run MatAnyone refinement only on keyframes
+                # MatAnyone refinement on keyframes
                 if (frame_count % keyframe_interval == 0) or (last_refined_mask is None):
                     refined_mask = refine_mask_hq(frame, mask, matanyone_model)
                     last_refined_mask = refined_mask.copy()
-                    logger.info(f"MatAnyone refinement on frame {frame_count}")
                 else:
-                    # Use SAM2 mask directly for intermediate frames
                     refined_mask = mask
                 
-                # Direct background replacement
+                # Background replacement
                 result_frame = replace_background_hq(frame, refined_mask, background)
                 final_writer.write(result_frame)
                 
             except Exception as e:
                 logger.warning(f"Error processing frame {frame_count}: {e}")
                 final_writer.write(frame)
+                
             frame_count += 1
             if frame_count % 100 == 0:
                 gc.collect()
@@ -305,311 +291,92 @@ def process_video_hq(video_path, background_choice, custom_background_path, prog
         cap.release()
 
         if frame_count == 0:
-            return None, "No frames were processed successfully."
+            return None, "No frames were processed."
 
-        _prog(0.9, "Adding high-quality audio...")
-        final_output = f"/tmp/final_output_hq_{timestamp}.mp4"
+        _prog(0.9, "Adding audio...")
+        final_output = f"/tmp/final_{timestamp}.mp4"
+        
         try:
             audio_cmd = (
                 f'ffmpeg -y -i "{final_path}" -i "{video_path}" '
-                f'-c:v libx264 -crf 18 -preset medium -profile:v high -level:v 4.0 '
+                f'-c:v libx264 -crf 18 -preset medium '
                 f'-c:a aac -b:a 192k -ac 2 -ar 48000 '
                 f'-map 0:v:0 -map 1:a:0? -shortest "{final_output}"'
             )
             result = os.system(audio_cmd)
             if result != 0 or not os.path.exists(final_output):
-                logger.warning("Audio merging failed, using video without audio")
                 shutil.copy2(final_path, final_output)
         except Exception as e:
-            logger.warning(f"Audio processing error: {e}, using video without audio")
-            try: shutil.copy2(final_path, final_output)
-            except Exception as e2:
-                logger.error(f"Failed to copy video file: {e2}")
-                return None, f"Failed to finalize video: {str(e2)}"
+            logger.warning(f"Audio processing error: {e}")
+            shutil.copy2(final_path, final_output)
 
-        # Save to MyAvatar/My Videos directory
+        # Save to MyAvatar directory
         try:
             myavatar_path = "/tmp/MyAvatar/My_Videos/"
             os.makedirs(myavatar_path, exist_ok=True)
-            saved_filename = f"single_stage_bg_replaced_{timestamp}.mp4"
+            saved_filename = f"bg_replaced_{timestamp}.mp4"
             saved_path = os.path.join(myavatar_path, saved_filename)
             shutil.copy2(final_output, saved_path)
-            logger.info(f"Video saved to: {saved_path}")
         except Exception as e:
-            logger.warning(f"Could not save to MyAvatar directory: {e}")
+            logger.warning(f"Could not save to MyAvatar: {e}")
             saved_filename = os.path.basename(final_output)
 
+        # Cleanup
         try:
             if os.path.exists(final_path):
                 os.remove(final_path)
-        except Exception:
+        except:
             pass
 
-        _prog(1.0, "SINGLE-STAGE processing complete!")
+        _prog(1.0, "Processing complete!")
+        
         success_message = (
-            f"SINGLE-STAGE Success!\n"
-            f"Direct background replacement: {background_name}\n"
+            f"Success!\n"
+            f"Background: {background_name}\n"
             f"Processed: {frame_count} frames\n"
-            f"Saved: MyAvatar/My Videos/{saved_filename}\n"
-            f"Quality: Cinema-grade with SAM2 + MatAnyone\n"
-            f"Method: Optimized single-stage processing"
+            f"Saved: {saved_filename}\n"
+            f"Quality: SAM2 + MatAnyone"
         )
+        
         return final_output, success_message
 
     except Exception as e:
-        logger.error(f"Video processing error: {traceback.format_exc()}")
-        return None, f"SINGLE-STAGE Processing Error: {str(e)}"
+        logger.error(f"Processing error: {traceback.format_exc()}")
+        return None, f"Processing Error: {str(e)}"
+
+def get_cache_status():
+    """Get current cache status"""
+    sam2_cached = get_cache_path("sam2_predictor").exists()
+    matanyone_cached = get_cache_path("matanyone").exists()
+    return {
+        "sam2_cached": sam2_cached,
+        "matanyone_cached": matanyone_cached,
+        "cache_dir": str(CACHE_DIR)
+    }
 
 # ============================================================================ #
-# GRADIO UI
-# ============================================================================ #
-def create_interface():
-    def extract_video_path(v):
-        if isinstance(v, (tuple, list)) and len(v) > 0:
-            return v[0]
-        return v
-
-    with gr.Blocks(
-        title="ENHANCED High-Quality Video Background Replacement",
-        theme=gr.themes.Soft(),
-        css="""
-        .gradio-container { max-width: 1200px !important; }
-        .progress-bar { background: linear-gradient(90deg, #3498db, #2ecc71) !important; }
-        """
-    ) as demo:
-        gr.Markdown("# Cinema-Quality Video Background Replacement")
-        gr.Markdown("**Upload a video → Choose a background → Get professional results with AI**")
-        gr.Markdown("*Powered by SAM2 + MatAnyone with multi-fallback loading for maximum reliability*")
-        gr.Markdown("---")
-
-        with gr.Row():
-            with gr.Column(scale=1):
-                gr.Markdown("### Step 1: Upload Your Video")
-                gr.Markdown("*Supports MP4, MOV, AVI, and other common formats*")
-                video_input = gr.Video(label="Drop your video here", height=300)
-
-                gr.Markdown("### Step 2: Choose Background Method")
-                gr.Markdown("*Select your preferred background creation method*")
-                background_method = gr.Radio(
-                    choices=["upload", "professional", "colors", "ai"],
-                    value="professional",
-                    label="Background Method"
-                )
-                gr.Markdown(
-                    "- **upload** = Upload Image  \n"
-                    "- **professional** = Professional Presets  \n"
-                    "- **colors** = Colors/Gradients  \n"
-                    "- **ai** = AI Generated"
-                )
-
-                with gr.Group(visible=False) as upload_group:
-                    gr.Markdown("**Upload Your Background Image**")
-                    custom_background = gr.Image(label="Drop your background image here", type="filepath")
-
-                with gr.Group(visible=True) as professional_group:
-                    gr.Markdown("**Professional Background Presets**")
-                    professional_choice = gr.Dropdown(
-                        choices=list(PROFESSIONAL_BACKGROUNDS.keys()),
-                        value="office_modern",
-                        label="Select Professional Background"
-                    )
-
-                with gr.Group(visible=False) as colors_group:
-                    gr.Markdown("**Custom Colors & Gradients**")
-                    gradient_type = gr.Dropdown(
-                        choices=["solid", "vertical", "horizontal", "diagonal", "radial", "soft_radial"],
-                        value="vertical",
-                        label="Gradient Type"
-                    )
-                    with gr.Row():
-                        color1 = gr.ColorPicker(label="Color 1", value="#3498db")
-                        color2 = gr.ColorPicker(label="Color 2", value="#2ecc71")
-                    with gr.Row():
-                        color3 = gr.ColorPicker(label="Color 3", value="#e74c3c")
-                        use_third_color = gr.Checkbox(label="Use 3rd color", value=False)
-
-                with gr.Group(visible=False) as ai_group:
-                    gr.Markdown("**AI Generated Background**")
-                    ai_prompt = gr.Textbox(
-                        label="Describe your background",
-                        placeholder="e.g., 'modern office with plants', 'sunset over mountains', 'abstract tech pattern'",
-                        lines=2
-                    )
-                    ai_style = gr.Dropdown(
-                        choices=["photorealistic", "artistic", "abstract", "minimalist", "corporate", "nature"],
-                        value="photorealistic",
-                        label="Style"
-                    )
-                    with gr.Row():
-                        generate_ai_btn = gr.Button("Generate Background", variant="secondary")
-                        ai_generated_image = gr.Image(label="Generated Background", type="filepath", visible=False)
-
-                def switch_background_method(method):
-                    return (
-                        gr.update(visible=(method == "upload")),
-                        gr.update(visible=(method == "professional")),
-                        gr.update(visible=(method == "colors")),
-                        gr.update(visible=(method == "ai"))
-                    )
-                background_method.change(
-                    fn=switch_background_method,
-                    inputs=background_method,
-                    outputs=[upload_group, professional_group, colors_group, ai_group]
-                )
-
-                gr.Markdown("### Processing Controls")
-                gr.Markdown("*First load the AI models, then process your video*")
-                with gr.Row():
-                    load_models_btn = gr.Button("Step 1: Load AI Models", variant="secondary")
-                    process_btn = gr.Button("Step 2: Process Video", variant="primary")
-
-                status_text = gr.Textbox(label="System Status", value=get_model_status(), interactive=False, lines=3)
-
-            with gr.Column(scale=1):
-                gr.Markdown("### Your Results")
-                gr.Markdown("*Processed video will appear here after Step 2*")
-                video_output = gr.Video(label="Your Processed Video", height=400)
-                result_text = gr.Textbox(
-                    label="Processing Results",
-                    interactive=False,
-                    lines=6,
-                    placeholder="Processing status and results will appear here..."
-                )
-
-                gr.Markdown("### Professional Backgrounds Available")
-                bg_preview_html = """
-                <div style='display: grid; grid-template-columns: repeat(3, 1fr); gap: 8px; padding: 10px; max-height: 400px; overflow-y: auto; border: 1px solid #ddd; border-radius: 8px;'>
-                """
-                for key, config in PROFESSIONAL_BACKGROUNDS.items():
-                    colors = config["colors"]
-                    gradient = f"linear-gradient(45deg, {colors[0]}, {colors[-1]})" if len(colors) >= 2 else colors[0]
-                    bg_preview_html += f"""
-                    <div style='padding: 12px 8px; border: 1px solid #ddd; border-radius: 6px; text-align: center; background: {gradient};
-                                min-height: 60px; display: flex; align-items: center; justify-content: center;'>
-                        <div>
-                            <strong style='color: white; text-shadow: 1px 1px 2px rgba(0,0,0,0.8); font-size: 12px; display: block;'>{config["name"]}</strong>
-                            <small style='color: rgba(255,255,255,0.9); text-shadow: 1px 1px 1px rgba(0,0,0,0.6); font-size: 10px;'>{config.get("description", "")[:30]}...</small>
-                        </div>
-                    </div>
-                    """
-                bg_preview_html += "</div>"
-                gr.HTML(bg_preview_html)
-
-        def generate_ai_background(prompt, style):
-            if not prompt or not prompt.strip():
-                return None, "Please enter a prompt"
-            try:
-                bg_image = create_procedural_background(prompt, style, 1920, 1080)
-                if bg_image is not None:
-                    with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as tmp:
-                        cv2.imwrite(tmp.name, bg_image)
-                        return tmp.name, f"Background generated: {prompt[:50]}..."
-                return None, "Generation failed, try different prompt"
-            except Exception as e:
-                logger.error(f"AI generation error: {e}")
-                return None, f"Generation error: {str(e)}"
-
-        def process_video_enhanced(
-            video_path, bg_method, custom_img, prof_choice, grad_type,
-            color1, color2, color3, use_third, ai_prompt, ai_style, ai_img,
-            progress: Optional[gr.Progress] = None
-        ):
-            if not models_loaded:
-                return None, "Models not loaded. Click 'Load Models' first."
-            if not video_path:
-                return None, "No video file provided."
-            try:
-                if bg_method == "upload":
-                    if custom_img and os.path.exists(custom_img):
-                        return process_video_hq(video_path, "custom", custom_img, progress)
-                    return None, "No image uploaded. Please upload a background image."
-                elif bg_method == "professional":
-                    if prof_choice and prof_choice in PROFESSIONAL_BACKGROUNDS:
-                        return process_video_hq(video_path, prof_choice, None, progress)
-                    return None, f"Invalid professional background: {prof_choice}"
-                elif bg_method == "colors":
-                    try:
-                        colors = [color1 or "#3498db", color2 or "#2ecc71"]
-                        if use_third and color3:
-                            colors.append(color3)
-                        bg_config = {
-                            "type": "gradient" if grad_type != "solid" else "color",
-                            "colors": colors if grad_type != "solid" else [colors[0]],
-                            "direction": grad_type if grad_type != "solid" else "vertical"
-                        }
-                        gradient_bg = create_professional_background(bg_config, 1920, 1080)
-                        temp_path = f"/tmp/gradient_{int(time.time())}.png"
-                        cv2.imwrite(temp_path, gradient_bg)
-                        return process_video_hq(video_path, "custom", temp_path, progress)
-                    except Exception as e:
-                        return None, f"Error creating gradient: {str(e)}"
-                elif bg_method == "ai":
-                    if ai_img and os.path.exists(ai_img):
-                        return process_video_hq(video_path, "custom", ai_img, progress)
-                    return None, "No AI background generated. Click 'Generate Background' first."
-                else:
-                    return None, f"Unknown background method: {bg_method}"
-            except Exception as e:
-                logger.error(f"Enhanced processing error: {e}")
-                return None, f"Processing error: {str(e)}"
-
-        load_models_btn.click(fn=download_and_setup_models, outputs=status_text)
-        generate_ai_btn.click(fn=generate_ai_background, inputs=[ai_prompt, ai_style], outputs=[ai_generated_image, status_text])
-        process_btn.click(
-            fn=process_video_enhanced,
-            inputs=[video_input, background_method, custom_background, professional_choice,
-                    gradient_type, color1, color2, color3, use_third_color,
-                    ai_prompt, ai_style, ai_generated_image],
-            outputs=[video_output, result_text]
-        )
-
-        with gr.Accordion("ENHANCED Quality & Features", open=False):
-            gr.Markdown("""
-            ### TWO-STAGE Cinema-Quality Features:
-            **Stage 1**: Original → Green Screen (SAM2 + MatAnyone)
-            **Stage 2**: Green Screen → Final Background (professional chroma key)
-            **Quality**: Edge feathering, gamma correction, mask cleanup, H.264 CRF 18, AAC 192kbps.
-            """)
-
-        gr.Markdown("---")
-        gr.Markdown("*Cinema-Quality Video Background Replacement — TWO-STAGE pipeline*")
-
-    return demo
-
-# ============================================================================ #
-# MAIN
+# MAIN - IMPORT UI COMPONENTS ONLY WHEN NEEDED
 # ============================================================================ #
 def main():
     try:
-        print(f"===== Application Startup at {time.strftime('%Y-%m-%d %H:%M:%S')} =====\n")
-        print("Cinema-Quality Video Background Replacement")
-        print("=" * 50)
+        print("===== FAST STARTUP CORE =====")
+        print("Loading UI components...")
+        
+        # Import UI components only when needed
+        from ui_components import create_interface
+        
         os.makedirs("/tmp/MyAvatar/My_Videos/", exist_ok=True)
-        os.makedirs(os.path.expanduser("~/.cache/sam2"), exist_ok=True)
-
-        print("Features:")
-        print("  • SAM2 + MatAnyone AI models")
-        print("  • TWO-STAGE processing (Original → Green Screen → Final)")
-        print("  • 4 background methods (Upload/Professional/Colors/AI)")
-        print("  • Multi-fallback loading system")
-        print("  • Cinema-quality processing")
-        print("  • Enhanced stability & error handling")
-        print("=" * 50)
-
-        logger.info("Creating Gradio interface...")
+        CACHE_DIR.mkdir(exist_ok=True, parents=True)
+
+        print("Creating interface...")
         demo = create_interface()
 
-        logger.info("Launching application...")
+        print("Launching...")
         demo.launch(server_name="0.0.0.0", server_port=7860, share=True, show_error=True)
 
-    except KeyboardInterrupt:
-        logger.info("Application stopped by user")
-        print("\nApplication stopped by user")
     except Exception as e:
-        logger.error(f"Application failed to start: {e}")
-        logger.error(f"Full traceback: {traceback.format_exc()}")
-        print(f"Application failed to start: {e}")
-        print("Check logs for detailed error information.")
+        logger.error(f"Startup failed: {e}")
+        print(f"Startup failed: {e}")
 
 if __name__ == "__main__":
     main()