sklearn has been imported

README.md

@@ -5,7 +5,7 @@ emoji: 🤖
 colorFrom: gray
 colorTo: gray
 sdk: gradio
-sdk_version: 4.27.0
+sdk_version: 4.28.0
 app_file: app.py
 pinned: true
 header: mini
@@ -19,8 +19,8 @@ tags:
   - computer-vision
   - face-recognition
 ---
-# Face Recognition
-Match and identify faces with help of a comprehensive dataset of facial emeddings.
+# Face Match
+Upload an image, and the system will find the most similar face in our dataset.
 
 ## Dataset
 ### Details

app.py

@@ -1,185 +1,118 @@
-import os, sys, uuid
-import requests
-import tempfile
-import datetime
-import gradio as gr
-import face_recognition
+import os
 import numpy as np
 import pandas as pd
+from PIL import Image
 from huggingface_hub import HfFileSystem, hf_hub_download
-from PIL import Image, UnidentifiedImageError
-from io import BytesIO
-
-# Constants
-hf_token = os.environ.get("HF_TOKEN")
-space_subdomain = os.environ['SPACE_SUBDOMAIN']
-dataset = os.environ['DATASET']
-hf_file_system = HfFileSystem()
-max_distance = 1.0
-timeout = 30
+import face_recognition
+import gradio as gr
+from sklearn.metrics import euclidean_distances
 
-# Function to get images with authentication
-def get_image_with_auth(file_name):
-    image_path = hf_hub_download(repo_id=dataset, repo_type="dataset", filename=file_name, use_auth_token=hf_token)
-    img = Image.open(image_path)
-    return img
+# Environment Variables
+HF_TOKEN = os.getenv("HF_TOKEN")
+HF_DATASET = os.getenv('HF_DATASET')
 
-# Load dataset
-with hf_file_system.open(f'datasets/{dataset}/metadata.csv', revision='main', token=True) as file:
-    df = pd.read_csv(file)
+# Hugging Face File System for authentication
+fs = HfFileSystem()
 
-# Convert string embeddings to numpy arrays
-def convert_embeddings(embedding_str):
-    embedding = np.fromstring(embedding_str.strip('[]'), sep=',')
-    return embedding
+# Load and prepare dataset
+def load_dataset():
+    """Load dataset metadata and embeddings, converting embeddings to numpy arrays."""
+    with fs.open(f'datasets/{HF_DATASET}/metadata.csv', revision='main', token=True) as f:
+        df = pd.read_csv(f)
+    df['embeddings'] = df['embeddings'].apply(lambda x: np.fromstring(x.strip('[]'), sep=','))
+    return df
 
-df['embeddings'] = df['embeddings'].apply(convert_embeddings)
+df = load_dataset()
 
-# Load image from URL
-def load_image_from_url(url, timeout=timeout):
-    try:
-        response = requests.get(url, timeout=timeout)
-        response.raise_for_status()  # Raises an HTTPError for certain status codes
-        img = Image.open(BytesIO(response.content)).convert('RGB')
-        return img
-    except requests.exceptions.Timeout:
-        # Handle the timeout differently, maybe retry or return a specific message
-        raise ValueError("The request timed out. Please try again later.")
-    except requests.exceptions.HTTPError as e:
-        if e.response.status_code == 429:
-            raise ValueError("Too many requests: please wait a moment and try again.")
-        else:
-            raise ValueError(f"HTTP error: {e}")
-    except requests.exceptions.RequestException as e:
-        raise ValueError(f"Error fetching image from URL: {e}")
-    except UnidentifiedImageError:
-        raise ValueError("Cannot identify image file. Ensure the URL points to a valid image.")
+# Function to fetch images with authentication
+def get_image_with_auth(file_name):
+    """Retrieve an image using Hugging Face's hub with authentication."""
+    image_path = hf_hub_download(repo_id=HF_DATASET, repo_type="dataset", filename=file_name, token=HF_TOKEN)
+    return Image.open(image_path)
 
-        
-# Compute facial embeddings for the uploaded image
+# Utility function to load and process image
 def get_embedding(image):
-    face_encodings = face_recognition.face_encodings(np.array(image))
-    if face_encodings:
-        return face_encodings[0]
-    else:
-        raise ValueError("No faces detected in the image or unsupported image format.")
+    """Generate facial embeddings from an image using the face_recognition library."""
+    encodings = face_recognition.face_encodings(np.array(image))
+    return encodings[0] if encodings else None
 
-# Find the most similar faces
+# Matching face using sklearn
 def find_matching_face(embedding, df):
-    df['distance'] = df['embeddings'].apply(lambda x: np.linalg.norm(x - embedding))
-    best_match = df.sort_values('distance').iloc[0]
-    return best_match, best_match['distance']
+    """Find the most similar face in the dataset using Euclidean distance."""
+    embeddings_matrix = np.stack(df['embeddings'].values)
+    distances = euclidean_distances([embedding], embeddings_matrix)[0]
+    min_index = np.argmin(distances)
+    return df.iloc[min_index], distances[min_index]
+
+# Determine the quality of the match
+def categorize_similarity(distance):
+    """Categorize the similarity based on the Euclidean distance."""
+    if distance < 0.3:
+        return "Very High Match"
+    elif distance < 0.5:
+        return "High Match"
+    elif distance < 0.7:
+        return "Moderate Match"
+    elif distance < 1.0:
+        return "Low Match"
+    else:
+        return "Very Low Match"
 
-# The main function to recognize face and return the most similar face from the dataset
+# Main function to process the face matching
 def recognize_face(input_image_path):
-    try:
-        # Get initiated time
-        start_time = datetime.datetime.now()
-        
-        # Load the input image directly from the provided path
-        input_image = Image.open(input_image_path)
-        
-        # Compute facial embeddings for the uploaded image
-        embedding = get_embedding(input_image)
-
-        # Find the most similar face in the dataset and the distance score
-        most_similar_face, output_score = find_matching_face(embedding, df)
-
-        # Normalize the distance and convert it to a similarity percentage
-        output_percentage = max(0, (1 - (output_score / max_distance))) * 100
-
-        # Categorise the similarity percentages
-        if output_percentage > 55:
-            output_similarity = "very high"
-        elif output_percentage > 53:
-            output_similarity = "high"
-        elif output_percentage > 50:
-            output_similarity = "medium"
-        elif output_percentage > 48:
-            output_similarity = "low"
-        else:
-            output_similarity = "very low"
-
-        # Retrieve image using the file name from the dataset
-        similar_face_image = get_image_with_auth(most_similar_face['file_name'])
-
-        # Generate a unique filename and save the file in the expected Gradio directory
-        unique_filename = str(uuid.uuid4()) + ".jpg"
-        gradio_tmp_dir = "/tmp/gradio/"
-        os.makedirs(gradio_tmp_dir, exist_ok=True)
-        file_path = os.path.join(gradio_tmp_dir, unique_filename)
-        similar_face_image.save(file_path)
-
-        # Get name of the matching face
-        output_name = f"{most_similar_face['text']}"
-
-        # Get the similarity percentage
-        output_percentage = f"{output_percentage:.2f}%"
-
-        # Construct the URL using the unique filename
-        output_image = file_path
-
-        # Get completed time
-        end_time = datetime.datetime.now()
-        
-        # YAML script showing input and outputs
-        output_code = (f'''```yaml
-inputs:
-  - time: "{start_time}"
-  - image: "{input_image_path}"
-outputs:
-  - time: "{end_time}"
-  - image: "{most_similar_face['file_name']}"
-  - name: "{output_name}"
-  - similarity: "{output_similarity}"
-```''')
-
-        # print output code
-        print(output_code)
-
-        print(f"procentage: {output_percentage}")
-
-        # Return the outputs
-        return output_image, output_code
-    
-    except Exception as e:
-        output_code = f'''error: "{e}"'''
-        return None, output_code
+    """Process an uploaded image to find the most similar face in the dataset."""
+    input_image = Image.open(input_image_path).convert('RGB')
+    embedding = get_embedding(input_image)
+    if embedding is None:
+        return None, "No face detected."
+    most_similar_face, distance = find_matching_face(embedding, df)
+    match_quality = categorize_similarity(distance)
+    similar_face_image_path = get_image_with_auth(most_similar_face['file_name'])
+    info_message = f'''```yaml
+input:
+- image: "{input_image_path}"
+output:
+- name: "{most_similar_face['text']}"
+- quality: "{match_quality}" 
+- distance: {100 * (1 - distance)}
+```
+'''
+    print(info_message)
+    return similar_face_image_path, info_message
 
-def update_code(output_code):
+def update(output_info):
     return gr.update(visible=True)
 
-css = '''
-.gradio-container { max-width: 700px !important; }
-.source-selection { display: none !important; }
-.svelte-1pijsyv { border-radius: 0 !important; }
-.clear { max-width: 140px; }
-.submit { max-width: 240px; }
-'''
-
-# Gradio Blocks UI
-with gr.Blocks(css=css) as demo:
-    with gr.Row(equal_height=False):
+# Gradio setup
+with gr.Blocks(
+    analytics_enabled=False,
+    title="Face Match",
+    css='''  
+    .gradio-container { max-width: 700px !important; }
+    .source-selection { display: none !important; }
+    #clear { max-width: 140px; }
+    #submit { max-width: 240px; }
+    .svelte-1pijsyv { border-radius: 0 !important; }
+    .svelte-s6ybro { display: none !important; }
+    '''
+) as demo:
+    title = gr.HTML("<h1><center>Face Match</center></h1>")
+    subtitle = gr.HTML("<h3><center>Upload an image, and the system will find the most similar face in our dataset.</center></h3>")
+    with gr.Row():
         with gr.Column():
-            title = gr.HTML('''<h1><center>Face Match</center></h1>''', elem_classes="title")
-            subtitle = gr.HTML('''<h3><center>Upload an Image to Identify Faces</center></h3>''', elem_classes="subtitle")
+            with gr.Group():
+                with gr.Row(equal_height=True):
+                    input_image = gr.Image(type="filepath", show_label=False, interactive=True)
+                    output_image = gr.Image(type="filepath", show_label=False, interactive=False, show_share_button=False, show_download_button=False)
+                with gr.Row():
+                    output_info = gr.Markdown(visible=False)
             with gr.Row():
-                with gr.Column():
-                    with gr.Group():
-                        with gr.Row(equal_height=True):
-                            input_image = gr.Image(label="Input", show_label=False, type="filepath", interactive=True, elem_classes="image")
-                            output_image = gr.Image(label="Output", show_label=False, type="filepath", interactive=False, elem_classes="image")
-                        with gr.Row():
-                            output_code = gr.Markdown(visible=False, elem_classes="code")
-                    with gr.Row():
-                        clear = gr.ClearButton([input_image, output_image, output_code], elem_classes="clear")
-                        submit = gr.Button("Submit", variant="primary", elem_classes="submit")
-                    with gr.Row(): 
-                        examples = gr.Examples(["examples/0001.png", "examples/0002.png", "examples/0003.png", "examples/0004.png"], input_image)
-                
-    
-    output_image.change(fn=update_code, inputs=output_code, outputs=output_code)
-    submit.click(fn=recognize_face, inputs=input_image, outputs=[output_image, output_code])
-
-# Launch the Gradio UI
-demo.launch(server_name="0.0.0.0", server_port=7860, debug=True, show_api=False)
+                clear = gr.ClearButton([input_image, output_image, output_info], elem_id="clear", elem_classes="button")
+                submit = gr.Button("Submit", variant="primary", elem_id="submit", elem_classes="button")
+            with gr.Row(): 
+                examples = gr.Examples(["examples/0001.png", "examples/0002.png", "examples/0003.png", "examples/0004.png"], input_image)
+    output_image.change(fn=update, inputs=output_info, outputs=output_info)
+    submit.click(fn=recognize_face, inputs=input_image, outputs=[output_image, output_info])
+
+# Launch
+demo.launch(show_api=False)

requirements.txt

@@ -2,4 +2,5 @@ gradio
 face_recognition
 numpy
 pillow
-pandas
+pandas
+scikit-learn