Upload 2 files

app.py

@@ -1,84 +1,55 @@
 import os
-import numpy as np
-import pandas as pd
-from PIL import Image
-from huggingface_hub import HfFileSystem, hf_hub_download
-import face_recognition
+import sys
+import json
+import requests
 import gradio as gr
-from sklearn.metrics import euclidean_distances
+from huggingface_hub import HfFileSystem, hf_hub_download
+from PIL import Image
 
 # Environment Variables
 HF_TOKEN = os.getenv("HF_TOKEN")
 HF_DATASET = os.getenv('HF_DATASET')
+SPACE_SUBDOMAIN = os.environ['SPACE_SUBDOMAIN']
 
-# Hugging Face File System for authentication
-fs = HfFileSystem()
-
-# 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 = load_dataset()
-
-# 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)
 
-# Utility function to load and process image
-def get_embedding(image):
-    """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
+def recognize_face(image):
+    """
+    Function to send either an image URL to the FastAPI backend and receive results.
+    """
+    
+    # Set the URL to your FastAPI endpoint
+    url = 'https://dwancin-face-match-api.hf.space/recognize/'
 
-# Matching face using sklearn
-def find_matching_face(embedding, df):
-    """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]
+    # Prepare the payload with the image data and specify the type
+    payload = {
+        "image": f"https://{SPACE_SUBDOMAIN}.hf.space/file={image}",
+        "type": "url"
+    }
 
-# 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"
+    print(payload)
+
+    
+    # Send POST request to FastAPI server with the image data and type
+    response = requests.post(url, json=payload)
 
-# Main function to process the face matching
-def recognize_face(input_image_path):
-    """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
+    print(response)
+
+    # Process response
+    if response.status_code == 200:
+        response_data = response.json()
+        image_path = response_data.get('image')
+        if image_path:
+            image_file = get_image_with_auth(image_path)
+            formatted_json = json.dumps(response_data, indent=4)
+            return image_file, f"```json\n{formatted_json}\n```"
+        else:
+            return None, "No image path found in response."
+    else:
+        return None, f"Error: {response.status_code} - {response.text}"
 
 def update(output_info):
     return gr.update(visible=True)

requirements.txt

@@ -1,6 +1,3 @@
 gradio
-face_recognition
-numpy
-pillow
-pandas
-scikit-learn
+huggingface_hub
+pillow