Initial commit: MegaFace facial recognition system

Add complete facial recognition server with:
- DeepFace-based face detection and embedding generation
- Voyager vector similarity search indices
- SQLite performer database integration
- Gradio web interface
- ArcFace model weights and configurations
- Project documentation and dependencies

.deepface/weights/arcface_weights.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6336979c0c602cae08d1122a66f4dfb862d059bbcd8ef80306aef2b2249b0c93
+size 137026640

.deepface/weights/yolov8n-face.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d545bf1add5aa736a4febac4f4f9245a6d596cd0fe70d5d57989fe0cb9e626ca
+size 6389512

.gitattributes

@@ -0,0 +1,48 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.db filter=lfs diff=lfs merge=lfs -text
+face.json filter=lfs diff=lfs merge=lfs -text
+.deepface/weights/yolov8n-face.pt filter=lfs diff=lfs merge=lfs -text
+.deepface/weights/face_recognition_sface_2021dec.onnx filter=lfs diff=lfs merge=lfs -text
+.deepface/weights/res10_300x300_ssd_iter_140000.caffemodel filter=lfs diff=lfs merge=lfs -text
+.deepface/weights/centerface.onnx filter=lfs diff=lfs merge=lfs -text
+.deepface/weights/deploy.prototxt filter=lfs diff=lfs merge=lfs -text
+.deepface/weights/facenet512_weights.h5 filter=lfs diff=lfs merge=lfs -text
+.deepface/weights/retinaface.h5 filter=lfs diff=lfs merge=lfs -text
+.deepface/weights/face_detection_yunet_2023mar.onnx filter=lfs diff=lfs merge=lfs -text
+.deepface/weights/arcface_weights.h5 filter=lfs diff=lfs merge=lfs -text
+face_arc.voy filter=lfs diff=lfs merge=lfs -text
+face_facenet.voy filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,5 @@
+.venv
+flagged
+temp.jpg
+__pycache__
+data/performers.json

.python-version

@@ -0,0 +1 @@
+3.11

README.md

@@ -0,0 +1,14 @@
+---
+title: Stashface
+emoji: 👀
+colorFrom: indigo
+colorTo: purple
+sdk: gradio
+sdk_version: 5.25.2
+app_file: app.py
+python_version: 3.11
+pinned: false
+license: mit
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,23 @@
+import os
+
+# Set DeepFace home directory
+os.environ["DEEPFACE_HOME"] = "."
+os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
+
+from models.data_manager import DataManager
+from web.interface import WebInterface
+
+def main():
+    """Main entry point for the application"""
+    # Initialize data manager
+    data_manager = DataManager(
+        faces_path="data/faces.json",
+        arc_index_path="data/face_arc.voy"
+    )
+
+    # Initialize and launch web interface
+    web_interface = WebInterface(data_manager, default_threshold=0.5)
+    web_interface.launch(server_name="0.0.0.0", server_port=7860, share=False)
+
+if __name__ == "__main__":
+    main()

data/face_arc.voy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0ae15849f24e304e8a86dd125d0ff72169b5af4febafc9e24ed48dbbb0cfe68f
+size 322825475

data/peeps.db

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fa96f486d191c8adb48bc4735d81cb08bba1e7b7ad1c32320ccc80d46a6646c2
+size 146644992

models/__init__.py

@@ -0,0 +1 @@
+# models package 

models/data_manager.py

@@ -0,0 +1,118 @@
+import json
+import os
+import sqlite3
+from typing import Dict, Any, Optional
+from voyager import Index, Space, StorageDataType
+
+class DataManager:
+    def __init__(self, faces_path: str = "data/faces.json",
+                 arc_index_path: str = "data/face_arc.voy",
+                 performers_db_path: str = "data/peeps.db"):
+        """
+        Initialize the data manager.
+        
+        Parameters:
+        faces_path: Path to the faces.json file
+        performers_zip: Path to the performers zip file
+        facenet_index_path: Path to the facenet index file
+        arc_index_path: Path to the arc index file
+        """
+        self.faces_path = faces_path
+        self.arc_index_path = arc_index_path
+        self.performers_db_path = performers_db_path
+        
+        # Initialize indices
+        self.index_arc = Index(Space.Cosine, num_dimensions=512, storage_data_type=StorageDataType.E4M3)
+        
+        # Load data
+        self.faces = {}
+        self.load_data()
+    
+    def load_data(self):
+        """Load all data from files"""
+        self._load_faces()
+        self._load_indices()
+    
+    def _load_faces(self):
+        """Load faces from JSON file"""
+        try:
+            with open(self.faces_path, 'r') as f:
+                self.faces = json.load(f)
+        except Exception as e:
+            print(f"Error loading faces: {e}")
+            self.faces = {}
+    
+    def _load_indices(self):
+        """Load face recognition indices"""
+        try:
+            with open(self.arc_index_path, 'rb') as f:
+                self.index_arc = self.index_arc.load(f)
+        except Exception as e:
+            print(f"Error loading indices: {e}")
+    
+    def get_performer_data(self, image_filename: str) -> Optional[Dict[str, str]]:
+        """
+        Look up performer data by image filename
+        
+        Parameters:
+        image_filename: The image filename to look up
+        
+        Returns:
+        Dict with name, url, and image_url or None if not found
+        """
+        try:
+            # Create a new connection for each query to avoid threading issues
+            with sqlite3.connect(self.performers_db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute('SELECT slug, url FROM performers WHERE image_filename = ?', (image_filename,))
+                result = cursor.fetchone()
+                if result:
+                    return {
+                        'name': result[0],
+                        'url': result[1]
+                    }
+                return None
+        except Exception as e:
+            print(f"Error querying performer database: {e}")
+            return None
+    
+    def get_performer_info(self, id: str, confidence: float) -> Optional[Dict[str, Any]]:
+        """
+        Get performer information from the database
+        
+        Parameters:
+        stash_id: Stash ID of the performer
+        confidence: Confidence score (0-1)
+        
+        Returns:
+        Dictionary with performer information or None if not found
+        """
+
+        confidence_int = int(confidence * 100)
+        filename = os.path.basename(id)
+        
+        # Try to get performer data from database
+        performer_data = self.get_performer_data(filename)
+        name = filename.replace('.jpg', '').replace('.png', '').replace('.jpeg', '')
+
+        if performer_data:
+            if performer_data['name'] != "NULL":
+                name = performer_data['name'] or name
+            url = performer_data['url']
+        else:
+            url = None
+
+        image_url = 'https://meta4allphotos.s3.us-west-1.amazonaws.com/' + id
+        
+        return {  
+            'id': id,
+            "name": name,
+            "confidence": confidence_int,
+            'image': image_url,
+            'distance': confidence_int,
+            'url': url
+        }
+    
+    def query_arc_index(self, embedding, limit):
+        """Query the arc index with an embedding"""
+        return self.index_arc.query(embedding, limit) 

models/face_recognition.py

@@ -0,0 +1,134 @@
+import numpy as np
+from typing import Dict, List, Tuple
+
+from deepface import DeepFace
+from deepface.modules import modeling, preprocessing
+
+class EnsembleFaceRecognition:
+    def __init__(self, model_weights: Dict[str, float] = None):
+        """
+        Initialize ensemble face recognition system.
+        
+        Parameters:
+        model_weights: Dictionary mapping model names to their weights
+                        If None, all models are weighted equally
+        """
+        self.model_weights = model_weights or {}
+        self.boost_factor = 1.8
+
+    def normalize_distances(self, distances: np.ndarray) -> np.ndarray:
+        """Normalize distances to [0,1] range within each model's predictions"""
+        min_dist = np.min(distances)
+        max_dist = np.max(distances)
+        if max_dist == min_dist:
+            return np.zeros_like(distances)
+        return (distances - min_dist) / (max_dist - min_dist) 
+    
+    def compute_model_confidence(self, 
+                                distances: np.ndarray,
+                                temperature: float = 0.1) -> np.ndarray:
+        """Convert distances to confidence scores for a single model"""
+        normalized_distances = self.normalize_distances(distances)
+        exp_distances = np.exp(-normalized_distances / temperature)
+        return exp_distances / np.sum(exp_distances)
+    
+    def _preprocess_face_batch(self, faces: np.ndarray, target_size: Tuple[int, int], normalization: str) -> np.ndarray:
+        """Preprocess a batch of face images for model inference"""
+        batch_size = faces.shape[0]
+        processed_faces = []
+        
+        for i in range(batch_size):
+            face = faces[i]
+            # Convert RGB to BGR (DeepFace expects BGR)
+            face = face[:, :, ::-1]
+            
+            # Resize to model input size
+            resized = preprocessing.resize_image(face, target_size)
+            
+            # Normalize
+            normalized = preprocessing.normalize_input(resized, normalization)
+            
+            processed_faces.append(normalized)
+        
+        # Stack into batch and remove the extra dimension added by resize_image
+        batch = np.vstack(processed_faces)
+        return batch
+    
+    def get_face_embeddings_batch(self, faces: np.ndarray) -> Dict[str, np.ndarray]:
+        """Get face embeddings for a batch of images efficiently
+        
+        Args:
+            faces: np.ndarray of shape (batch_size, height, width, channels)
+            
+        Returns:
+            Dict with 'facenet' and 'arc' keys containing batched embeddings
+        """
+        # Load models (cached by DeepFace)
+        arcface_model = modeling.build_model(task="facial_recognition", model_name="ArcFace")
+        
+        # Preprocess faces for each model
+        arcface_batch = self._preprocess_face_batch(faces, arcface_model.input_shape, "ArcFace")
+        
+        # Get embeddings using direct model inference (bypassing DeepFace.represent)
+        arcface_embeddings = arcface_model.model(arcface_batch, training=False).numpy()
+        
+        return {
+            'arc': arcface_embeddings
+        }
+    
+    def ensemble_prediction(self,
+                            model_predictions: Dict[str, Tuple[List[str], List[float]]],
+                            temperature: float = 0.1,
+                            min_agreement: float = 0.5) -> List[Tuple[str, float]]:
+        """
+        Combine predictions from multiple models.
+        
+        Parameters:
+        model_predictions: Dictionary mapping model names to their (distances, names) predictions
+        temperature: Temperature parameter for softmax scaling
+        min_agreement: Minimum agreement threshold between models
+        
+        Returns:
+        final_predictions: List of (name, confidence) tuples
+        """
+        # Initialize vote counting
+        vote_dict = {}
+        confidence_dict = {}
+        
+        # Process each model's predictions
+        for model_name, (names, distances) in model_predictions.items():
+            # Get model weight (default to 1.0 if not specified)
+            model_weight = self.model_weights.get(model_name, 1.0)
+            
+            # Compute confidence scores for this model
+            confidences = self.compute_model_confidence(np.array(distances), temperature)
+
+            # Add weighted votes for top prediction
+            top_name = names[0]
+            top_confidence = confidences[0]
+            
+            vote_dict[top_name] = vote_dict.get(top_name, 0) + model_weight
+            confidence_dict[top_name] = confidence_dict.get(top_name, [])
+            confidence_dict[top_name].append(top_confidence)
+
+        # Normalize votes
+        total_weight = sum(self.model_weights.values()) if self.model_weights else len(model_predictions)
+        
+        # Compute final results with minimum agreement check
+        final_results = []
+        for name, votes in vote_dict.items():
+            normalized_votes = votes / total_weight
+            # Only include results that meet minimum agreement threshold
+            if normalized_votes >= min_agreement:
+                avg_confidence = np.mean(confidence_dict[name])
+                final_score = normalized_votes * avg_confidence * self.boost_factor
+                final_score = min(final_score, 1.0)  # Cap at 1.0
+                final_results.append((name, final_score))
+
+        # Sort by final score
+        final_results.sort(key=lambda x: x[1], reverse=True)
+        return final_results
+
+def extract_faces(image):
+    """Extract faces from an image using DeepFace"""
+    return DeepFace.extract_faces(image, detector_backend="yolov8")

models/image_processor.py

@@ -0,0 +1,81 @@
+import io
+import base64
+import numpy as np
+
+from models.face_recognition import EnsembleFaceRecognition, extract_faces
+
+
+
+def get_face_predictions(face, ensemble, data_manager, results):
+    """
+    Get predictions for a single face
+    
+    Parameters:
+    face: Face image array
+    ensemble: EnsembleFaceRecognition instance
+    data_manager: DataManager instance
+    results: Number of results to return
+    
+    Returns:
+    List of (name, confidence) tuples
+    """
+    # Create batch with original and flipped images
+    face_batch = np.stack([face, face[:, ::-1, :]], axis=0)
+
+    # Get embeddings for both orientations in one batch call
+    embeddings_batch = ensemble.get_face_embeddings_batch(face_batch)
+    arc = np.mean(embeddings_batch['arc'], axis=0)
+    
+    # Get predictions from both models
+    query_limit = max(results, 50)
+    arc_raw = data_manager.query_arc_index(arc, query_limit)
+
+    return ensemble.ensemble_prediction({'arc': arc_raw})
+
+
+def image_search_performers(image, data_manager, threshold=0.5, results=3):
+    """
+    Search for multiple performers in an image
+    
+    Parameters:
+    image: PIL Image object
+    data_manager: DataManager instance
+    threshold: Confidence threshold
+    results: Number of results to return
+    
+    Returns:
+    List of dictionaries with face image and performer information
+    """
+    image_array = np.array(image)
+    ensemble = EnsembleFaceRecognition({"arc": 1.0})
+
+    try:
+        faces = extract_faces(image_array)
+    except ValueError:
+        raise ValueError("No faces found")
+
+    response = []
+    for face in faces:
+        predictions = get_face_predictions(face['face'], ensemble, data_manager, results)
+        
+        # Crop and encode face image
+        area = face['facial_area']
+        cimage = image.crop((area['x'], area['y'], area['x'] + area['w'], area['y'] + area['h']))
+        buf = io.BytesIO()
+        cimage.save(buf, format='JPEG')
+        im_b64 = base64.b64encode(buf.getvalue()).decode('ascii')
+
+        # Get performer information
+        performers = []
+        for name, confidence in predictions:
+            performer_info = data_manager.get_performer_info(data_manager.faces[name], confidence)
+            if performer_info:
+                performers.append(performer_info)
+
+        response.append({
+            'image': im_b64,
+            'area': area,
+            'confidence': face['confidence'],
+            'performers': performers
+        })
+    return response

pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "stashface"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "deepface",
+    "gradio==5.25.2",
+    "mediapipe>=0.10.21",
+    "pyzipper==0.3.6",
+    "retina-face==0.0.17",
+    "tensorflow==2.14.1",
+    "tf-keras==2.14.1",
+    "ultralytics==8.3.69",
+    "voyager==2.1.0",
+]
+
+[tool.uv.sources]
+deepface = { git = "https://github.com/serengil/deepface.git", rev = "cc484b54be5188eb47faf132995af16a871d70b9" }

web/__init__.py

@@ -0,0 +1 @@
+# web package 

web/interface.py

@@ -0,0 +1,323 @@
+import gradio as gr
+import base64
+import io
+from PIL import Image as PILImage
+
+from models.data_manager import DataManager
+from models.image_processor import (
+    image_search_performers,
+)
+
+class WebInterface:
+    def __init__(self, data_manager: DataManager, default_threshold: float = 0.5):
+        """
+        Initialize the web interface.
+
+        Parameters:
+        data_manager: DataManager instance
+        default_threshold: Default confidence threshold
+        """
+        self.data_manager = data_manager
+        self.default_threshold = default_threshold
+
+    def multiple_image_search(self, img):
+        """Wrapper for the multiple image search function"""
+        try:
+            # Use default values: threshold=0.5, results=3
+            return image_search_performers(img, self.data_manager, 0.5, 3)
+        except ValueError as e:
+            if "No faces found" in str(e):
+                return {"error": "No faces detected in the uploaded image. Please try uploading an image with visible faces."}
+            else:
+                raise e
+
+    def format_results_for_visual_display(self, json_results):
+        """
+        Convert JSON results to visual components for better UX
+        
+        Parameters:
+        json_results: List of face detection results from image_search_performers
+        
+        Returns:
+        tuple: (gallery_images, html_content)
+        """
+        if not json_results:
+            return [], "<p>No faces detected or no matches found.</p>"
+        
+        # Handle error case
+        if isinstance(json_results, dict) and "error" in json_results:
+            error_html = f"""
+            <div class="performer-card">
+                <div class="face-info">
+                    <h3 style="color: #ff6b6b;">Error</h3>
+                    <p>{json_results['error']}</p>
+                </div>
+            </div>
+            """
+            return [], error_html
+        
+        gallery_images = []
+        html_parts = []
+        
+        html_parts.append("""
+        <style>
+        body, .gradio-container {
+            background-color: #1e1e1e !important;
+            color: #d4d4d4 !important;
+        }
+        .performer-card {
+            border: 1px solid #404040;
+            border-radius: 12px;
+            padding: 24px;
+            margin: 16px 0;
+            background: #2d2d2d;
+            box-shadow: 0 4px 12px rgba(0,0,0,0.3);
+            color: #d4d4d4;
+        }
+        .face-info {
+            background: #3c3c3c;
+            padding: 20px;
+            border-radius: 8px;
+            margin-bottom: 24px;
+            border: 1px solid #4a4a4a;
+            display: flex;
+            align-items: flex-start;
+            gap: 20px;
+        }
+        .face-info-content {
+            flex: 1;
+        }
+        .face-info h3 {
+            color: #ffffff;
+            margin-top: 0;
+            font-size: 1.4em;
+        }
+        .performer-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(350px, 1fr));
+            gap: 24px;
+            margin-top: 16px;
+        }
+        .performer-item {
+            border: 1px solid #4a4a4a;
+            border-radius: 12px;
+            padding: 24px;
+            background: #333333;
+            text-align: center;
+            transition: all 0.3s ease;
+            box-shadow: 0 2px 8px rgba(0,0,0,0.2);
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+        }
+        .performer-item:hover {
+            border-color: #569cd6;
+            box-shadow: 0 4px 16px rgba(0,0,0,0.4);
+            transform: translateY(-2px);
+        }
+        .performer-image {
+            width: 120px;
+            height: 120px;
+            border-radius: 12px;
+            object-fit: cover;
+            margin: 0 auto 16px auto;
+            display: block;
+            border: 2px solid #4a4a4a;
+            transition: all 0.3s ease;
+            text-align: center;
+        }
+        .performer-image:hover {
+            border-color: #569cd6;
+            transform: scale(1.05);
+        }
+        .performer-item h4 {
+            color: #ffffff;
+            margin: 16px 0 8px 0;
+            font-size: 1.2em;
+        }
+        .performer-item h4 a {
+            color: #569cd6;
+            text-decoration: none;
+            transition: color 0.3s ease;
+        }
+        .performer-item h4 a:hover {
+            color: #9cdcfe;
+            text-decoration: underline;
+        }
+        .performer-item p {
+            color: #cccccc;
+            margin: 8px 0;
+        }
+        .performer-item small {
+            color: #999999;
+        }
+        .confidence-bar {
+            background: #404040;
+            border-radius: 12px;
+            overflow: hidden;
+            height: 28px;
+            margin: 12px 0;
+            border: 1px solid #4a4a4a;
+            width: 100%;
+            max-width: 200px;
+        }
+        .confidence-fill {
+            height: 100%;
+            transition: width 0.5s ease;
+            text-align: center;
+            line-height: 28px;
+            color: white;
+            font-size: 13px;
+            font-weight: bold;
+            text-shadow: 0 1px 2px rgba(0,0,0,0.5);
+        }
+        .high-confidence { 
+            background: linear-gradient(135deg, #4caf50, #66bb6a);
+        }
+        .medium-confidence { 
+            background: linear-gradient(135deg, #ff9800, #ffb74d);
+        }
+        .low-confidence { 
+            background: linear-gradient(135deg, #f44336, #ef5350);
+        }
+        .face-info p strong {
+            color: #9cdcfe;
+        }
+        .country-flag {
+            font-size: 1.2em;
+            margin-right: 6px;
+            vertical-align: middle;
+        }
+        </style>
+        """)
+        
+        for i, face_result in enumerate(json_results):
+            # Convert base64 face image to PIL for gallery
+            try:
+                face_image_data = base64.b64decode(face_result['image'])
+                face_pil = PILImage.open(io.BytesIO(face_image_data))
+                gallery_images.append(face_pil)
+            except Exception as e:
+                print(f"Error decoding face image: {e}")
+                continue
+            
+            # Create HTML for this face
+            face_confidence = face_result['confidence']
+            performers = face_result['performers']
+            
+            # Create base64 data URL for the detected face image
+            face_image_b64 = f"data:image/jpeg;base64,{face_result['image']}"
+            
+            html_parts.append(f"""
+            <div class="performer-card">
+                <div class="face-info">
+                    <div class="detected-face">
+                        <img src="{face_image_b64}" alt="Detected Face {i+1}" style="width: 120px; height: 120px; border-radius: 12px; object-fit: cover; border: 2px solid #569cd6; box-shadow: 0 4px 12px rgba(0,0,0,0.3);">
+                    </div>
+                    <div class="face-info-content">
+                        <h3>Face {i+1}</h3>
+                        <p><strong>Detection Confidence:</strong> {face_confidence:.1%}</p>
+                        <p><strong>Matches Found:</strong> {len(performers)}</p>
+                    </div>
+                </div>
+            """)
+            
+            if performers:
+                html_parts.append('<div class="performer-grid">')
+                for performer in performers:
+                    confidence_class = "high-confidence" if performer['confidence'] >= 80 else "medium-confidence" if performer['confidence'] >= 60 else "low-confidence"
+                    
+                    # Create performer name with link if URL exists
+                    performer_name = performer['name']
+                    if performer.get('url'):
+                        performer_name = f'<a href="{performer["url"]}" target="_blank">{performer["name"]}</a>'
+                    
+                    html_parts.append(f"""
+                    <div class="performer-item">
+                        <img src="{performer['image']}" alt="{performer['name']}" class="performer-image" onerror="this.style.display='none'">
+                        <h4>{performer_name}</h4>
+                        <div class="confidence-bar">
+                            <div class="confidence-fill {confidence_class}" style="width: {performer['confidence']}%">
+                                {performer['confidence']}%
+                            </div>
+                        </div>
+                        <p><small>Distance: {performer.get('distance', 'N/A')}</small></p>
+                    </div>
+                    """)
+                html_parts.append('</div>')
+            else:
+                html_parts.append('<p><em>No performer matches found for this face.</em></p>')
+            
+            html_parts.append('</div>')
+        
+        return gallery_images, ''.join(html_parts)
+
+    def multiple_image_search_with_visual(self, img):
+        """
+        Enhanced search function that returns both JSON and visual components
+        
+        Returns:
+        tuple: (json_results, gallery_images, html_content)
+        """
+        try:
+            json_results = self.multiple_image_search(img)
+            gallery_images, html_content = self.format_results_for_visual_display(json_results)
+            return json_results, gallery_images, html_content
+        except Exception as e:
+            error_msg = f"<div class='performer-card'><h3>Error</h3><p>{str(e)}</p></div>"
+            return [], [], error_msg
+
+    def _create_visual_search_interface(self):
+        """Create the visual search interface"""
+        with gr.Blocks() as interface:
+            gr.Markdown("# Who is in the photo?")
+            gr.Markdown("Upload an image of a person(s) and we'll show you who it is with photos and details.")
+
+            with gr.Row():
+                with gr.Column():
+                    img_input = gr.Image(type="pil")
+                    search_btn = gr.Button("Search")
+
+                with gr.Column():
+                    performer_info = gr.HTML(
+                        label="Performer Information",
+                        value="<p>Upload an image and click search to see results.</p>"
+                    )
+
+            def visual_search_wrapper(img):
+                """Wrapper that returns only visual components"""
+                json_results, gallery_images, html_content = self.multiple_image_search_with_visual(img)
+                return html_content
+
+            search_btn.click(
+                fn=visual_search_wrapper,
+                inputs=[img_input],
+                outputs=[performer_info],
+                api_name="multiple_image_search_with_visual"
+            )
+
+        return interface
+    
+
+    def launch(self, server_name="0.0.0.0", server_port=7860, share=True):
+        """Launch the web interface"""
+        with gr.Blocks(
+            css="""
+            .gradio-container {
+                background-color: #1e1e1e !important;
+                color: #d4d4d4 !important;
+            }
+            .dark {
+                --background-fill-primary: #2d2d2d;
+                --background-fill-secondary: #3c3c3c;
+                --border-color-primary: #404040;
+                --block-title-text-color: #ffffff;
+                --body-text-color: #d4d4d4;
+            }
+            """
+        ) as demo:
+            with gr.Tabs():
+                with gr.TabItem("Visual Search"):
+                        self._create_visual_search_interface()
+
+        demo.queue().launch(server_name=server_name, server_port=server_port, share=share, ssr_mode=False)