s

app.py

@@ -1,85 +1,67 @@
-import gradio as gr
-import face_recognition
-import numpy as np
 import os
+import numpy as np
 from PIL import Image
-import dlib
-
-# Verificar si CUDA está disponible y seleccionar el modelo adecuado
-if dlib.DLIB_USE_CUDA:
-    print("✅ CUDA está disponible. Se usará GPU para reconocimiento facial.")
-    model_used = "cnn"  # Modelo optimizado para GPU
-else:
-    print("⚠ CUDA no está disponible. Se usará CPU para reconocimiento facial.")
-    model_used = "hog"  # Modelo más adecuado para CPU
+import gradio as gr
+from deepface import DeepFace
 
-# 📂 Directorio donde se encuentran las imágenes
+# Ruta de la carpeta con rostros
 IMAGE_DIRECTORY = "dataset_faces/"
 
-def load_images_and_encodings(directory):
-    """
-    Carga las imágenes y extrae sus embeddings.
-    """
-    known_encodings = []
-    known_images = []
-    known_names = []
+# Cargar embeddings de todas las imágenes del dataset
+def build_database():
+    database = []
+    for filename in os.listdir(IMAGE_DIRECTORY):
+        if filename.lower().endswith(('.png', '.jpg', '.jpeg')):
+            path = os.path.join(IMAGE_DIRECTORY, filename)
+            try:
+                representation = DeepFace.represent(img_path=path, model_name="Facenet")[0]["embedding"]
+                database.append((filename, path, representation))
+            except:
+                print(f"❌ No se pudo procesar: {filename}")
+    return database
+
+# Inicializamos base de datos
+database = build_database()
 
-    for filename in os.listdir(directory):
-        if filename.lower().endswith((".jpg", ".png", ".jpeg")):
-            path = os.path.join(directory, filename)
-            image = face_recognition.load_image_file(path)
-            encodings = face_recognition.face_encodings(image, model=model_used)
-            if encodings:  # Si se detecta al menos una cara
-                known_encodings.append(encodings[0])
-                known_images.append(path)
-                known_names.append(filename)
-    return known_encodings, known_images, known_names
+# Comparar imagen cargada con las del dataset
+def find_similar_faces(uploaded_image):
+    try:
+        uploaded_image = np.array(uploaded_image)
+        query_representation = DeepFace.represent(img_path=uploaded_image, model_name="Facenet")[0]["embedding"]
+    except:
+        return [], "⚠ No se detectó un rostro válido en la imagen."
 
-# Cargar los datos de la carpeta de imágenes
-known_encodings, known_images, known_names = load_images_and_encodings(IMAGE_DIRECTORY)
+    similarities = []
+    for name, path, rep in database:
+        distance = np.linalg.norm(np.array(query_representation) - np.array(rep))
+        similarity = 1 / (1 + distance)  # Normalizamos para que 1 = muy similar
+        similarities.append((similarity, name, path))
 
-def find_similar_faces_gradio(uploaded_image):
-    """
-    Dada una imagen subida, busca las imágenes similares del dataset.
-    Devuelve una lista de diccionarios para la galería y un texto con detalles.
-    """
-    if uploaded_image is None:
-        return [], "No se subió ninguna imagen."
-    
-    # Convertir la imagen subida a array de NumPy
-    image_np = np.array(uploaded_image)
-    face_encodings = face_recognition.face_encodings(image_np, model=model_used)
-    if not face_encodings:
-        return [], "⚠ No se detectó ningún rostro en la imagen subida."
-    
-    query_encoding = face_encodings[0]
-    distances = face_recognition.face_distance(known_encodings, query_encoding)
-    sorted_indices = np.argsort(distances)  # Ordenar por similitud (menor distancia = mayor similitud)
-    
-    # Mostrar las 5 imágenes más similares
-    top_n = 5
+    # Ordenar por similitud
+    similarities.sort(reverse=True)
+    top_matches = similarities[:5]
+
+    # Formatear salida para gradio
     gallery_items = []
-    details = ""
-    for idx in sorted_indices[:top_n]:
-        # Abrir la imagen del dataset
-        img = Image.open(known_images[idx])
-        similarity = 1 - distances[idx]  # Definir similitud (valor entre 0 y 1)
-        caption = f"{os.path.basename(known_images[idx])}: Similitud: {similarity:.2f}"
+    text_summary = ""
+    for sim, name, path in top_matches:
+        img = Image.open(path)
+        caption = f"{name} - Similitud: {sim:.2f}"
         gallery_items.append({"image": img, "caption": caption})
-        details += caption + "\n"
-    
-    return gallery_items, details
+        text_summary += caption + "\n"
+
+    return gallery_items, text_summary
 
-# Definir la interfaz con Gradio
+# Interfaz Gradio
 demo = gr.Interface(
-    fn=find_similar_faces_gradio,
-    inputs=gr.Image(label="Sube una imagen", type="pil"),
+    fn=find_similar_faces,
+    inputs=gr.Image(label="📤 Sube una imagen", type="pil"),
     outputs=[
-        gr.Gallery(label="Imágenes similares").style(grid=[2], height="auto"),
-        gr.Textbox(label="Detalles de similitud", lines=5)
+        gr.Gallery(label="📸 Rostros más similares").style(grid=[2], height="auto"),
+        gr.Textbox(label="🧠 Similitud", lines=6)
     ],
-    title="🔍 Buscador de Rostros en un Directorio",
-    description="Sube una imagen y se mostrarán las fotos más similares del directorio."
+    title="🔍 Buscador de Rostros con DeepFace",
+    description="Sube una imagen y te mostrará los rostros más similares desde el directorio `dataset_faces/`."
 )
 
 demo.launch()

apt.txt

@@ -1,4 +0,0 @@
-cmake
-libboost-all-dev
-libgtk-3-dev
-build-essential

requirements.txt

@@ -1,10 +1,5 @@
 gradio
 numpy
 Pillow
+deepface
 opencv-python-headless
-
-# Usa face_recognition desde GitHub
-git+https://github.com/ageitgey/face_recognition.git
-
-# Asegura versión de dlib
-dlib==19.24.0