Upload 4 files

app.py

@@ -308,6 +308,25 @@ def process_photos_face_filter_only(job_id, upload_dir, session_id=None):
                 'timestamp': timestamp
             })
 
+        # Also include photos that had processing errors
+        for error_photo in filter_results.get('error_photos', []):
+            filename = os.path.basename(error_photo['path'])
+            timestamp = None
+            try:
+                from photo_selector.utils import get_photo_timestamp
+                dt = get_photo_timestamp(error_photo['path'])
+                if dt:
+                    timestamp = dt.timestamp()
+            except:
+                pass
+            unmatched_photos.append({
+                'filename': filename,
+                'best_similarity': 0,
+                'num_faces': 0,
+                'timestamp': timestamp,
+                'error': error_photo.get('error', 'Processing error')
+            })
+
         # Sort unmatched by timestamp
         unmatched_photos.sort(key=lambda x: x.get('timestamp') or 0)
 
@@ -494,6 +513,11 @@ def process_drive_with_parallel_face_detection(job_id, folder_id, upload_dir, fa
         print(f"  - Photos with your child: {len(matched_photos)}")
         print(f"  - Photos without match: {len(unmatched_photos)}")
         print(f"  - Photos with no faces: {len(no_faces_photos)}")
+        print(f"  - Photos with errors: {len(error_photos)}")
+        if error_photos:
+            print(f"  [ERRORS] First 5 error photos:")
+            for ep in error_photos[:5]:
+                print(f"    - {os.path.basename(ep['path'])}: {ep.get('error', 'Unknown error')}")
 
         # Now create thumbnails and prepare review data
         processing_jobs[job_id]['progress'] = 75
@@ -542,6 +566,16 @@ def process_drive_with_parallel_face_detection(job_id, folder_id, upload_dir, fa
                 'num_faces': 0
             })
 
+        # Also add error photos to unmatched (so they're visible to user)
+        for error_photo in error_photos:
+            filename = os.path.basename(error_photo['path'])
+            unmatched_data.append({
+                'filename': filename,
+                'best_similarity': 0,
+                'num_faces': 0,
+                'error': error_photo.get('error', 'Processing error')
+            })
+
         # Store results
         review_data = {
             'total_uploaded': total_files[0],
@@ -744,7 +778,7 @@ def save_photos_by_month(job_id, upload_dir, selected_photos, rejected_photos, m
         return None
 
 
-def process_photos_quality_selection(job_id, upload_dir, quality_mode, similarity_threshold, confirmed_photos, face_data_cache=None):
+def process_photos_quality_selection(job_id, upload_dir, quality_mode, similarity_threshold, confirmed_photos, face_data_cache=None, embedding_model='siglip'):
     """
     Phase 2: Month-based category-aware photo selection.
     Selects ~40 best photos per month with category diversity.
@@ -752,6 +786,7 @@ def process_photos_quality_selection(job_id, upload_dir, quality_mode, similarit
     Args:
         face_data_cache: Dict of filename -> {'num_faces': int, 'face_bboxes': list}
                         Cached face data from Step 2 to avoid re-detection
+        embedding_model: 'siglip' or 'clip' - which embedding model to use
     """
     face_data_cache = face_data_cache or {}
     try:
@@ -761,14 +796,20 @@ def process_photos_quality_selection(job_id, upload_dir, quality_mode, similarit
         print(f"[Job {job_id}] Confirmed photos: {len(confirmed_photos)}")
         print(f"[Job {job_id}] Quality mode: {quality_mode}")
         print(f"[Job {job_id}] Similarity threshold: {similarity_threshold}")
+        print(f"[Job {job_id}] Embedding model: {embedding_model.upper()}")
 
         processing_jobs[job_id]['status'] = 'processing'
         processing_jobs[job_id]['progress'] = 5
-        processing_jobs[job_id]['message'] = 'Loading AI models...'
+        processing_jobs[job_id]['message'] = f'Loading {embedding_model.upper()} model...'
 
-        # Import the new monthly selector
-        from photo_selector.siglip_embeddings import SigLIPEmbedder
+        # Import the appropriate embedder based on selection
         from photo_selector.monthly_selector import MonthlyPhotoSelector
+        if embedding_model == 'clip':
+            from photo_selector.clip_embeddings import CLIPEmbedder as Embedder
+            model_display_name = 'CLIP'
+        else:
+            from photo_selector.siglip_embeddings import SigLIPEmbedder as Embedder
+            model_display_name = 'SigLIP'
 
         # Determine target per month based on quality mode
         if quality_mode == 'keep_more':
@@ -782,11 +823,11 @@ def process_photos_quality_selection(job_id, upload_dir, quality_mode, similarit
 
         # Step 1: Generate embeddings for confirmed photos
         processing_jobs[job_id]['progress'] = 10
-        processing_jobs[job_id]['message'] = 'Analyzing photos with SigLIP AI...'
+        processing_jobs[job_id]['message'] = f'Analyzing photos with {model_display_name}...'
 
-        print(f"[Job {job_id}] Generating SigLIP embeddings for {len(confirmed_photos)} photos...")
+        print(f"[Job {job_id}] Generating {model_display_name} embeddings for {len(confirmed_photos)} photos...")
 
-        embedder = SigLIPEmbedder()
+        embedder = Embedder()
         embeddings = {}
 
         for i, filename in enumerate(confirmed_photos):
@@ -1844,11 +1885,64 @@ def import_from_drive_reupload(dataset_name):
                 print(f"[Job {job_id}] Loaded {len(matcher.reference_embeddings)} reference embeddings")
 
             # Match uploaded files with saved face results
+            # Google Drive filenames differ from browser upload:
+            # 1. Duplicates: IMG_5197(1).JPG vs IMG_51971.JPG
+            # 2. Spaces: IMG_6970 Copy.JPG vs IMG_6970_Copy.JPG
+            import re
+            def normalize_filename(filename):
+                """Normalize Google Drive filename to match browser upload format."""
+                # Step 1: Convert (N) suffix to N (Google Drive duplicate handling)
+                match = re.match(r'^(.+)\((\d+)\)(\.[^.]+)$', filename)
+                if match:
+                    base, num, ext = match.groups()
+                    filename = f"{base}{num}{ext}"
+                # Step 2: Apply secure_filename (spaces -> underscores, etc.)
+                return secure_filename(filename)
+
             filtered_photos = face_results.get('filtered_photos', [])
             uploaded_set = set(uploaded_filenames)
-            matched_photos = [p for p in filtered_photos if p.get('filename') in uploaded_set]
+            saved_filenames_set = {p.get('filename') for p in filtered_photos}
+
+            # Create mapping: normalized_name -> actual_uploaded_name
+            normalized_to_uploaded = {normalize_filename(f): f for f in uploaded_filenames}
+
+            matched_photos = []
+            for p in filtered_photos:
+                saved_filename = p.get('filename')
+                actual_filename = None
+
+                # Try direct match first
+                if saved_filename in uploaded_set:
+                    actual_filename = saved_filename
+                # Try normalized match (saved name matches normalized uploaded name)
+                elif saved_filename in normalized_to_uploaded:
+                    actual_filename = normalized_to_uploaded[saved_filename]
+
+                if actual_filename:
+                    # Use actual uploaded filename for the photo entry
+                    photo_entry = p.copy()
+                    photo_entry['filename'] = actual_filename
+                    photo_entry['thumbnail'] = get_thumbnail_name(actual_filename)
+                    matched_photos.append(photo_entry)
+
+            # Debug: Find unmatched photos
+            matched_saved = {p.get('filename') for p in filtered_photos if p.get('filename') in uploaded_set or p.get('filename') in normalized_to_uploaded}
+            unmatched_from_saved = [p.get('filename') for p in filtered_photos if p.get('filename') not in matched_saved]
+            matched_uploaded = {m['filename'] for m in matched_photos}
+            unmatched_from_uploaded = [f for f in uploaded_filenames if f not in matched_uploaded]
 
             print(f"[Job {job_id}] Matched {len(matched_photos)} of {len(filtered_photos)} photos")
+            print(f"[Job {job_id}] DEBUG: {len(unmatched_from_saved)} saved photos NOT found in uploaded files:")
+            for fname in unmatched_from_saved[:20]:  # Show first 20
+                print(f"  [SAVED NOT IN UPLOAD] '{fname}'")
+            if len(unmatched_from_saved) > 20:
+                print(f"  ... and {len(unmatched_from_saved) - 20} more")
+
+            print(f"[Job {job_id}] DEBUG: {len(unmatched_from_uploaded)} uploaded files NOT found in saved data:")
+            for fname in unmatched_from_uploaded[:20]:  # Show first 20
+                print(f"  [UPLOAD NOT IN SAVED] '{fname}'")
+            if len(unmatched_from_uploaded) > 20:
+                print(f"  ... and {len(unmatched_from_uploaded) - 20} more")
 
             # Create review data
             review_data = {
@@ -2677,6 +2771,11 @@ def confirm_selection(job_id):
     if len(confirmed_photos) == 0:
         return jsonify({'error': 'At least one photo must be selected'}), 400
 
+    # Get embedding model selection (default to siglip)
+    embedding_model = data.get('embedding_model', 'siglip')
+    if embedding_model not in ['siglip', 'clip']:
+        embedding_model = 'siglip'
+
     # Get processing parameters from job
     quality_mode = job.get('quality_mode', 'balanced')
     similarity_threshold = job.get('similarity_threshold', 0.92)
@@ -2717,7 +2816,7 @@ def confirm_selection(job_id):
     # Start phase 2 processing
     thread = threading.Thread(
         target=process_photos_quality_selection,
-        args=(job_id, upload_dir, quality_mode, similarity_threshold, confirmed_photos, face_data_cache)
+        args=(job_id, upload_dir, quality_mode, similarity_threshold, confirmed_photos, face_data_cache, embedding_model)
     )
     thread.start()
 

photo_selector/clip_embeddings.py

@@ -0,0 +1,241 @@
+"""
+CLIP embeddings for photo clustering.
+CLIP (Contrastive Language-Image Pre-training) by OpenAI.
+
+Uses ViT-B/32 by default (512-dim embeddings)
+"""
+
+import os
+import numpy as np
+from pathlib import Path
+from PIL import Image
+import torch
+from typing import List, Dict, Tuple, Optional
+
+# Try to import CLIP
+try:
+    import clip
+    CLIP_AVAILABLE = True
+except ImportError:
+    CLIP_AVAILABLE = False
+    print("CLIP not installed. Run: pip install git+https://github.com/openai/CLIP.git")
+
+# HEIC support
+try:
+    from pillow_heif import register_heif_opener
+    register_heif_opener()
+except ImportError:
+    pass
+
+
+class CLIPEmbedder:
+    """Generate CLIP embeddings for photos."""
+
+    def __init__(self, model_name: str = "ViT-B/32", device: str = None):
+        """
+        Initialize the CLIP model.
+
+        Args:
+            model_name: CLIP model variant. Options:
+                - "ViT-B/32" (512-dim, fastest)
+                - "ViT-B/16" (512-dim, better quality)
+                - "ViT-L/14" (768-dim, best quality)
+                - "ViT-L/14@336px" (768-dim, highest resolution)
+            device: 'cuda' or 'cpu', auto-detected if None
+        """
+        if not CLIP_AVAILABLE:
+            raise ImportError("CLIP is required. Install with: pip install git+https://github.com/openai/CLIP.git")
+
+        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+        print(f"Loading CLIP model '{model_name}' on {self.device}...")
+
+        self.model, self.preprocess = clip.load(model_name, device=self.device)
+        self.model.eval()
+        self.embedding_dim = self.model.visual.output_dim
+        self.model_name = model_name
+
+        print(f"CLIP loaded. Embedding dimension: {self.embedding_dim}")
+
+    def load_image(self, image_path: str) -> Optional[Image.Image]:
+        """Load and preprocess an image."""
+        try:
+            img = Image.open(image_path)
+            # Convert to RGB if necessary
+            if img.mode != 'RGB':
+                img = img.convert('RGB')
+            return img
+        except Exception as e:
+            print(f"Error loading {image_path}: {e}")
+            return None
+
+    def get_embedding(self, image: Image.Image) -> np.ndarray:
+        """Get CLIP embedding for a single image."""
+        with torch.no_grad():
+            image_input = self.preprocess(image).unsqueeze(0).to(self.device)
+            embedding = self.model.encode_image(image_input)
+            # Normalize the embedding
+            embedding = embedding / embedding.norm(dim=-1, keepdim=True)
+            return embedding.cpu().numpy().flatten()
+
+    def get_embeddings_batch(self, images: List[Image.Image], batch_size: int = 32) -> np.ndarray:
+        """Get CLIP embeddings for a batch of images."""
+        all_embeddings = []
+
+        for i in range(0, len(images), batch_size):
+            batch_images = images[i:i + batch_size]
+
+            with torch.no_grad():
+                # Preprocess all images in batch
+                image_inputs = torch.stack([self.preprocess(img) for img in batch_images]).to(self.device)
+                embeddings = self.model.encode_image(image_inputs)
+
+                # Normalize
+                embeddings = embeddings / embeddings.norm(dim=-1, keepdim=True)
+                all_embeddings.append(embeddings.cpu().numpy())
+
+        return np.vstack(all_embeddings)
+
+    def process_folder(self, folder_path: str,
+                       image_extensions: set = None,
+                       batch_size: int = 32,
+                       use_batching: bool = True) -> Dict[str, np.ndarray]:
+        """
+        Process all images in a folder and generate embeddings.
+
+        Args:
+            folder_path: Path to folder containing images
+            image_extensions: Set of valid extensions
+            batch_size: Number of images to process at once
+            use_batching: Whether to use batch processing (faster but more memory)
+
+        Returns:
+            Dictionary mapping filename to embedding
+        """
+        if image_extensions is None:
+            image_extensions = {'.jpg', '.jpeg', '.png', '.heic', '.heif', '.webp'}
+
+        folder = Path(folder_path)
+        image_files = [f for f in folder.iterdir()
+                       if f.suffix.lower() in image_extensions]
+
+        print(f"Found {len(image_files)} images in {folder_path}")
+
+        embeddings = {}
+        errors = []
+
+        if use_batching and len(image_files) > batch_size:
+            # Batch processing for efficiency
+            print(f"Using batch processing (batch_size={batch_size})...")
+
+            for batch_start in range(0, len(image_files), batch_size):
+                batch_end = min(batch_start + batch_size, len(image_files))
+                batch_files = image_files[batch_start:batch_end]
+
+                print(f"Processing batch [{batch_start+1}-{batch_end}/{len(image_files)}]")
+
+                batch_images = []
+                batch_names = []
+
+                for image_path in batch_files:
+                    try:
+                        img = self.load_image(str(image_path))
+                        if img is not None:
+                            batch_images.append(img)
+                            batch_names.append(image_path.name)
+                    except Exception as e:
+                        errors.append((image_path.name, str(e)))
+
+                if batch_images:
+                    try:
+                        batch_embeddings = self.get_embeddings_batch(batch_images)
+                        for name, emb in zip(batch_names, batch_embeddings):
+                            embeddings[name] = emb
+                    except Exception as e:
+                        print(f"Batch processing failed, falling back to individual: {e}")
+                        for img, name in zip(batch_images, batch_names):
+                            try:
+                                embeddings[name] = self.get_embedding(img)
+                            except Exception as e2:
+                                errors.append((name, str(e2)))
+
+                    # Close images
+                    for img in batch_images:
+                        img.close()
+        else:
+            # Individual processing
+            for i, image_path in enumerate(image_files):
+                if (i + 1) % 10 == 0:
+                    print(f"Processing [{i+1}/{len(image_files)}] {image_path.name}")
+
+                try:
+                    img = self.load_image(str(image_path))
+                    if img is not None:
+                        embedding = self.get_embedding(img)
+                        embeddings[image_path.name] = embedding
+                        img.close()
+                except Exception as e:
+                    errors.append((image_path.name, str(e)))
+
+        print(f"\nProcessed {len(embeddings)} images successfully")
+        if errors:
+            print(f"Errors on {len(errors)} images")
+
+        return embeddings
+
+    def save_embeddings(self, embeddings: Dict[str, np.ndarray],
+                        output_path: str):
+        """Save embeddings to a numpy file."""
+        data = {
+            'filenames': list(embeddings.keys()),
+            'embeddings': np.array(list(embeddings.values())),
+            'model': self.model_name,
+            'embedding_dim': self.embedding_dim
+        }
+        np.savez(output_path, **data)
+        print(f"Saved CLIP embeddings to {output_path}")
+
+    @staticmethod
+    def load_embeddings(input_path: str) -> Dict[str, np.ndarray]:
+        """Load embeddings from a numpy file."""
+        data = np.load(input_path, allow_pickle=True)
+        filenames = data['filenames']
+        embeddings_array = data['embeddings']
+        return {fn: emb for fn, emb in zip(filenames, embeddings_array)}
+
+
+def compute_similarity(emb1: np.ndarray, emb2: np.ndarray) -> float:
+    """Compute cosine similarity between two embeddings."""
+    return float(np.dot(emb1, emb2))
+
+
+def find_similar_photos(embeddings: Dict[str, np.ndarray],
+                        query_filename: str,
+                        top_k: int = 10) -> List[Tuple[str, float]]:
+    """Find most similar photos to a query photo."""
+    query_emb = embeddings[query_filename]
+
+    similarities = []
+    for filename, emb in embeddings.items():
+        if filename != query_filename:
+            sim = compute_similarity(query_emb, emb)
+            similarities.append((filename, sim))
+
+    similarities.sort(key=lambda x: x[1], reverse=True)
+    return similarities[:top_k]
+
+
+if __name__ == "__main__":
+    import sys
+
+    if len(sys.argv) > 1:
+        folder = sys.argv[1]
+    else:
+        print("Usage: python clip_embeddings.py <folder_path>")
+        print("\nThis will generate CLIP embeddings for all images in the folder.")
+        sys.exit(0)
+
+    embedder = CLIPEmbedder()
+    embeddings = embedder.process_folder(folder)
+
+    output_dir = os.path.dirname(os.path.abspath(__file__))
+    embedder.save_embeddings(embeddings, os.path.join(output_dir, "clip_embeddings.npz"))

supabase_storage.py

@@ -44,15 +44,26 @@ def is_supabase_available() -> bool:
 
 
 def _get_dataset_registry(client) -> List[str]:
-    """Get the list of dataset names from the registry file."""
+    """
+    Get the list of dataset names from the registry file.
+    Returns None if there's an error reading (to prevent accidental overwrite).
+    Returns [] only if file doesn't exist yet.
+    """
     try:
         storage = client.storage.from_(BUCKET_NAME)
         response = storage.download("_registry.json")
         registry = json.loads(response.decode('utf-8'))
         return registry.get('datasets', [])
-    except Exception:
-        # Registry doesn't exist yet
-        return []
+    except Exception as e:
+        error_str = str(e).lower()
+        # Only return empty if file doesn't exist (not for other errors)
+        if 'not found' in error_str or '404' in error_str or 'does not exist' in error_str:
+            print("[Supabase] Registry file doesn't exist yet, starting fresh")
+            return []
+        else:
+            # For other errors, return None to prevent accidental overwrite
+            print(f"[Supabase] ERROR reading registry: {e}")
+            return None
 
 
 def _update_dataset_registry(client, dataset_name: str, action: str = 'add'):
@@ -63,6 +74,11 @@ def _update_dataset_registry(client, dataset_name: str, action: str = 'add'):
         # Get current registry
         datasets = _get_dataset_registry(client)
 
+        # If we couldn't read the registry (error, not "not found"), don't overwrite
+        if datasets is None:
+            print(f"[Supabase] Skipping registry update - couldn't read existing registry safely")
+            return
+
         if action == 'add' and dataset_name not in datasets:
             datasets.append(dataset_name)
         elif action == 'remove' and dataset_name in datasets:
@@ -220,6 +236,11 @@ def list_datasets_from_supabase() -> List[Dict[str, Any]]:
         dataset_names = _get_dataset_registry(client)
         print(f"[Supabase] Registry contains: {dataset_names}")
 
+        # If registry read failed (None), return empty to be safe
+        if dataset_names is None:
+            print("[Supabase] Could not read registry, returning empty list")
+            return []
+
         # If registry is empty, try to find existing datasets by checking known names
         # This handles the case where datasets were saved before registry was implemented
         if not dataset_names:

templates/step3_review.html

@@ -835,6 +835,106 @@
                 padding: 40px;
                 color: #666;
             }
+
+            /* Model Selection */
+            .model-selection {
+                background: #f8f9fa;
+                border-radius: 12px;
+                padding: 20px;
+                margin-bottom: 25px;
+                border: 1px solid #e0e0e0;
+            }
+
+            .model-selection-title {
+                font-size: 14px;
+                font-weight: 600;
+                color: #374151;
+                margin-bottom: 12px;
+                display: flex;
+                align-items: center;
+                gap: 8px;
+            }
+
+            .model-options {
+                display: flex;
+                gap: 15px;
+                flex-wrap: wrap;
+            }
+
+            .model-option {
+                flex: 1;
+                min-width: 200px;
+                background: white;
+                border: 2px solid #e0e0e0;
+                border-radius: 10px;
+                padding: 15px;
+                cursor: pointer;
+                transition: all 0.2s;
+            }
+
+            .model-option:hover {
+                border-color: #667eea;
+            }
+
+            .model-option.selected {
+                border-color: #667eea;
+                background: linear-gradient(135deg, rgba(102, 126, 234, 0.05) 0%, rgba(118, 75, 162, 0.05) 100%);
+            }
+
+            .model-option input[type="radio"] {
+                display: none;
+            }
+
+            .model-option-header {
+                display: flex;
+                align-items: center;
+                gap: 10px;
+                margin-bottom: 8px;
+            }
+
+            .model-radio {
+                width: 20px;
+                height: 20px;
+                border: 2px solid #ccc;
+                border-radius: 50%;
+                display: flex;
+                align-items: center;
+                justify-content: center;
+                flex-shrink: 0;
+            }
+
+            .model-option.selected .model-radio {
+                border-color: #667eea;
+            }
+
+            .model-option.selected .model-radio::after {
+                content: '';
+                width: 10px;
+                height: 10px;
+                background: #667eea;
+                border-radius: 50%;
+            }
+
+            .model-name {
+                font-weight: 600;
+                color: #333;
+            }
+
+            .model-badge {
+                font-size: 10px;
+                padding: 2px 8px;
+                border-radius: 10px;
+                background: #4CAF50;
+                color: white;
+                font-weight: 500;
+            }
+
+            .model-description {
+                font-size: 13px;
+                color: #666;
+                line-height: 1.4;
+                margin-left: 30px;
+            }
         </style>
     </head>
     <body>
@@ -982,6 +1082,37 @@
             <div class="proceed-section">
                 <h3>Ready to Continue?</h3>
                 <p>Click below to run quality selection on <strong id="final-count">0</strong> selected photos</p>
+
+                <!-- Model Selection -->
+                <div class="model-selection">
+                    <div class="model-selection-title">
+                        Clustering Model
+                    </div>
+                    <div class="model-options">
+                        <label class="model-option selected" onclick="selectModel('siglip')">
+                            <input type="radio" name="embedding_model" value="siglip" checked>
+                            <div class="model-option-header">
+                                <div class="model-radio"></div>
+                                <span class="model-name">SigLIP</span>
+                                <span class="model-badge">Recommended</span>
+                            </div>
+                            <div class="model-description">
+                                Better for fine-grained visual understanding. 768-dim embeddings.
+                            </div>
+                        </label>
+                        <label class="model-option" onclick="selectModel('clip')">
+                            <input type="radio" name="embedding_model" value="clip">
+                            <div class="model-option-header">
+                                <div class="model-radio"></div>
+                                <span class="model-name">CLIP</span>
+                            </div>
+                            <div class="model-description">
+                                Original OpenAI model. 512-dim embeddings. Good general-purpose.
+                            </div>
+                        </label>
+                    </div>
+                </div>
+
                 <div class="proceed-buttons">
                     <button class="btn btn-success btn-lg" onclick="proceedToSelection()">
                         Continue to Quality Selection &rarr;
@@ -1036,6 +1167,19 @@
             let photoSelections = {};
             let currentModalPhoto = null;
             let unmatchedLoaded = false;
+            let selectedModel = 'siglip';  // Default model
+
+            function selectModel(model) {
+                selectedModel = model;
+                // Update UI
+                document.querySelectorAll('.model-option').forEach(opt => {
+                    opt.classList.remove('selected');
+                    if (opt.querySelector(`input[value="${model}"]`)) {
+                        opt.classList.add('selected');
+                        opt.querySelector('input').checked = true;
+                    }
+                });
+            }
 
             async function loadFilteredPhotos() {
                 showLoading('Loading filtered photos...');
@@ -1267,13 +1411,17 @@
                     return;
                 }
 
-                showLoading('Running quality-based selection...');
+                const modelName = selectedModel === 'clip' ? 'CLIP' : 'SigLIP';
+                showLoading(`Running quality-based selection with ${modelName}...`);
 
                 try {
                     const response = await fetch(`/confirm_selection/${jobId}`, {
                         method: 'POST',
                         headers: { 'Content-Type': 'application/json' },
-                        body: JSON.stringify({ selected_photos: selectedPhotos })
+                        body: JSON.stringify({
+                            selected_photos: selectedPhotos,
+                            embedding_model: selectedModel
+                        })
                     });
 
                     const data = await response.json();