Update app.py

app.py

@@ -1,10 +1,7 @@
-# Install required packages with version locking
-from google.colab import drive
-drive.mount('/content/drive')
-!pip install deepface==0.0.79 tensorflow==2.10.0 opencv-python-headless==4.7.0.72
+# Installation commands (run these first in Colab)
+# !pip install deepface==0.0.79 tensorflow==2.10.0 opencv-python-headless==4.7.0.72 gradio==3.50.2
 
 import gradio as gr
-import json
 import cv2
 import numpy as np
 from deepface import DeepFace
@@ -12,105 +9,113 @@ import matplotlib.pyplot as plt
 from PIL import Image
 import tempfile
 import os
-import pandas as pd
 import shutil
+import pandas as pd
+
+# Google Drive integration (for Colab)
+try:
+    from google.colab import drive
+    drive.mount('/content/drive')
+except:
+    pass
 
-def verify_faces(img1, img2, threshold=0.70, model="VGG-Face"):
+def verify_faces(img1, img2, threshold=0.6, model="VGG-Face"):
     temp_dir = tempfile.mkdtemp()
-    img1_path = os.path.join(temp_dir, "image1.jpg")
-    img2_path = os.path.join(temp_dir, "image2.jpg")
-    
     try:
         # Save images
+        img1_path = os.path.join(temp_dir, "img1.jpg")
+        img2_path = os.path.join(temp_dir, "img2.jpg")
         Image.fromarray(img1).save(img1_path) if isinstance(img1, np.ndarray) else img1.save(img1_path)
         Image.fromarray(img2).save(img2_path) if isinstance(img2, np.ndarray) else img2.save(img2_path)
 
-        # Verify faces with proper API parameters
+        # Verify faces
         result = DeepFace.verify(
-            img1_path=img1_path, 
+            img1_path=img1_path,
             img2_path=img2_path,
             model_name=model,
-            distance_metric="cosine",
-            threshold=threshold
+            distance_metric="cosine"
         )
-        
+
         # Create visualization
         fig, ax = plt.subplots(1, 2, figsize=(10, 5))
-        for idx, path in enumerate([img1_path, img2_path]):
+        for i, path in enumerate([img1_path, img2_path]):
             img = cv2.cvtColor(cv2.imread(path), cv2.COLOR_BGR2RGB)
-            ax[idx].imshow(img)
-            ax[idx].set_title(f"Image {idx+1}")
-            ax[idx].axis("off")
-        
-        confidence = round((1 - result["distance"]) * 100, 2)
-        plt.suptitle(f"{'✅ MATCH' if result['verified'] else '❌ NO MATCH'}\nConfidence: {confidence}%", 
-                    fontsize=14, y=1.05)
+            ax[i].imshow(img)
+            ax[i].axis('off')
+            ax[i].set_title(f"Image {i+1}")
         
+        verified = result['distance'] <= threshold
+        plt.suptitle(f"{'✅ MATCH' if verified else '❌ NO MATCH'}\nDistance: {result['distance']:.4f}")
         return fig, result
     
     except Exception as e:
         return None, {"error": str(e)}
-    
     finally:
         shutil.rmtree(temp_dir, ignore_errors=True)
 
-def find_faces(query_img, db_folder, threshold=0.70, model="VGG-Face"):
+def find_faces(query_img, db_input, threshold=0.6, model="VGG-Face"):
     temp_dir = tempfile.mkdtemp()
-    query_path = os.path.join(temp_dir, "query.jpg")
-    
     try:
         # Save query image
+        query_path = os.path.join(temp_dir, "query.jpg")
         Image.fromarray(query_img).save(query_path) if isinstance(query_img, np.ndarray) else query_img.save(query_path)
 
-        # Handle database path
-        if isinstance(db_folder, str):
-            db_path = db_folder
+        # Handle database input
+        if isinstance(db_input, str):
+            db_path = db_input
         else:
             db_path = os.path.join(temp_dir, "db")
             os.makedirs(db_path, exist_ok=True)
-            for i, file in enumerate(db_folder):
+            for i, file in enumerate(db_input):
                 ext = os.path.splitext(file.name)[1]
                 shutil.copy(file.name, os.path.join(db_path, f"img_{i}{ext}"))
 
-        # Find faces with corrected API parameters
-        dfs = DeepFace.find(
-            img_path=query_path,
-            db_path=db_path,
-            model_name=model,
-            distance_metric="cosine",
-            enforce_detection=False,
-            silent=True
-        )
-        
-        # Process results
+        # Find faces
+        try:
+            dfs = DeepFace.find(
+                img_path=query_path,
+                db_path=db_path,
+                model_name=model,
+                distance_metric="cosine",
+                silent=True
+            )
+        except:
+            return None, {"error": "No faces found in database"}
+
         df = dfs[0] if isinstance(dfs, list) else dfs
         df = df[df['distance'] <= threshold].sort_values('distance')
-        
+
         # Create visualization
-        fig, axes = plt.subplots(1, min(4, len(df)) if len(df) > 0 else plt.subplots(1, 1))
-        axes[0].imshow(cv2.cvtColor(cv2.imread(query_path), cv2.COLOR_BGR2RGB))
-        axes[0].set_title("Query Image")
-        
-        for idx, (_, row) in enumerate(df.head(3).iterrows()):
-            if idx >= len(axes)-1: break
-            match_img = cv2.cvtColor(cv2.imread(row['identity']), cv2.COLOR_BGR2RGB)
-            axes[idx+1].imshow(match_img)
-            axes[idx+1].set_title(f"Match {idx+1}\n{row['distance']:.2f}")
+        num_matches = min(4, len(df))
+        fig, axes = plt.subplots(1, num_matches + 1, figsize=(15, 5))
         
+        # Show query image
+        query_img = cv2.cvtColor(cv2.imread(query_path), cv2.COLOR_BGR2RGB)
+        axes[0].imshow(query_img)
+        axes[0].set_title("Query")
+        axes[0].axis('off')
+
+        # Show matches
+        for i in range(num_matches):
+            if i >= len(df): break
+            match_path = df.iloc[i]['identity']
+            match_img = cv2.cvtColor(cv2.imread(match_path), cv2.COLOR_BGR2RGB)
+            axes[i+1].imshow(match_img)
+            axes[i+1].set_title(f"Match {i+1}\n{df.iloc[i]['distance']:.4f}")
+            axes[i+1].axis('off')
+
         return fig, df[['identity', 'distance']].to_dict('records')
     
     except Exception as e:
         return None, {"error": str(e)}
-    
     finally:
         shutil.rmtree(temp_dir, ignore_errors=True)
 
-def analyze_face(img, actions=['age', 'gender', 'race', 'emotion']):
+def analyze_face(img, actions=['age', 'gender', 'emotion']):
     temp_dir = tempfile.mkdtemp()
-    img_path = os.path.join(temp_dir, "analyze.jpg")
-    
     try:
         # Save image
+        img_path = os.path.join(temp_dir, "analyze.jpg")
         Image.fromarray(img).save(img_path) if isinstance(img, np.ndarray) else img.save(img_path)
 
         # Analyze face
@@ -120,80 +125,85 @@ def analyze_face(img, actions=['age', 'gender', 'race', 'emotion']):
             enforce_detection=False,
             detector_backend='opencv'
         )
-        
+
         # Process results
         results = results if isinstance(results, list) else [results]
         fig = plt.figure(figsize=(10, 5))
         
-        # Display main image
+        # Show image
         plt.subplot(121)
-        plt.imshow(cv2.cvtColor(cv2.imread(img_path), cv2.COLOR_BGR2RGB))
+        img_display = cv2.cvtColor(cv2.imread(img_path), cv2.COLOR_BGR2RGB)
+        plt.imshow(img_display)
         plt.title("Input Image")
         plt.axis('off')
-        
-        # Display attributes
+
+        # Show attributes
         plt.subplot(122)
-        attrs = {k:v for res in results for k,v in res.items() if k != 'region'}
-        plt.barh(list(attrs.keys()), list(attrs.values()))
+        attributes = {k: v for res in results for k, v in res.items() if k != 'region'}
+        plt.barh(list(attributes.keys()), list(attributes.values()))
         plt.title("Analysis Results")
-        
+        plt.tight_layout()
+
         return fig, results
     
     except Exception as e:
         return None, {"error": str(e)}
-    
     finally:
         shutil.rmtree(temp_dir, ignore_errors=True)
 
-# Gradio interface
-with gr.Blocks(title="Face Analysis Tool", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🔍 Face Analysis Toolkit")
+# Gradio Interface
+with gr.Blocks(title="Face Recognition Toolkit", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🧑💻 Face Recognition Toolkit")
     
     with gr.Tabs():
         with gr.Tab("Verify Faces"):
-            gr.Markdown("## Compare two faces")
             with gr.Row():
-                img1 = gr.Image(type="pil", label="First Face")
-                img2 = gr.Image(type="pil", label="Second Face")
-            thresh = gr.Slider(0.1, 1.0, 0.6, label="Matching Threshold")
-            model = gr.Dropdown(["VGG-Face", "Facenet", "OpenFace"], value="VGG-Face")
-            verify_btn = gr.Button("Compare Faces")
-            result_plot = gr.Plot()
-            result_json = gr.JSON()
+                img1 = gr.Image(label="First Image", type="pil")
+                img2 = gr.Image(label="Second Image", type="pil")
+            verify_threshold = gr.Slider(0.1, 1.0, 0.6, label="Match Threshold")
+            verify_model = gr.Dropdown(["VGG-Face", "Facenet", "OpenFace"], value="VGG-Face")
+            verify_btn = gr.Button("Verify Faces")
+            verify_output = gr.Plot()
+            verify_json = gr.JSON()
             
             verify_btn.click(
-                verify_faces, 
-                [img1, img2, thresh, model], 
-                [result_plot, result_json]
+                verify_faces,
+                [img1, img2, verify_threshold, verify_model],
+                [verify_output, verify_json]
             )
-        
+
         with gr.Tab("Find Faces"):
-            gr.Markdown("## Find similar faces in database")
-            query = gr.Image(type="pil", label="Query Image")
-            db = gr.Textbox("/content/drive/MyDrive/db", label="Database Path")
-            files = gr.File(file_count="multiple", label="Or upload files")
-            find_btn = gr.Button("Search Faces")
-            matches_plot = gr.Plot()
-            matches_json = gr.JSON()
+            query_img = gr.Image(label="Query Image", type="pil")
+            db_input = gr.Textbox("/content/drive/MyDrive/db", label="Database Path")
+            db_files = gr.File(file_count="multiple", label="Or Upload Images")
+            find_threshold = gr.Slider(0.1, 1.0, 0.6, label="Similarity Threshold")
+            find_model = gr.Dropdown(["VGG-Face", "Facenet", "OpenFace"], value="VGG-Face")
+            find_btn = gr.Button("Find Matches")
+            find_output = gr.Plot()
+            find_json = gr.JSON()
             
             find_btn.click(
-                find_faces, 
-                [query, db, thresh, model], 
-                [matches_plot, matches_json]
+                find_faces,
+                [query_img, db_input, find_threshold, find_model],
+                [find_output, find_json]
             )
-            files.change(lambda x: None, [files], [db])
-        
+            db_files.change(lambda x: None, db_files, db_input)
+
         with gr.Tab("Analyze Face"):
-            gr.Markdown("## Analyze facial attributes")
-            inp_img = gr.Image(type="pil", label="Input Image")
+            analyze_img = gr.Image(label="Input Image", type="pil")
+            analyze_actions = gr.CheckboxGroup(
+                ["age", "gender", "emotion", "race"], 
+                value=["age", "gender", "emotion"],
+                label="Analysis Features"
+            )
             analyze_btn = gr.Button("Analyze")
-            analysis_plot = gr.Plot()
-            analysis_json = gr.JSON()
+            analyze_output = gr.Plot()
+            analyze_json = gr.JSON()
             
             analyze_btn.click(
-                analyze_face, 
-                [inp_img], 
-                [analysis_plot, analysis_json]
+                analyze_face,
+                [analyze_img, analyze_actions],
+                [analyze_output, analyze_json]
             )
 
 demo.launch()