funcionando con DEeepface

.gitignore

@@ -0,0 +1,13 @@
+.env
+.venv
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+/venv
+/embeddings
+/batches
+/metadata.csv
+/metadata.csv.gz
+/metadata.csv.gz.part

app.py

@@ -15,6 +15,29 @@ import shutil
 import tarfile
 import tensorflow as tf
 
+# Configuración de GPU
+print("Dispositivos GPU disponibles:", tf.config.list_physical_devices('GPU'))
+
+# Configurar memoria GPU
+gpus = tf.config.list_physical_devices('GPU')
+if gpus:
+    try:
+        # Permitir crecimiento de memoria
+        for gpu in gpus:
+            tf.config.experimental.set_memory_growth(gpu, True)
+        print("✅ GPU configurada correctamente")
+        
+        # Configurar para usar solo GPU
+        tf.config.set_visible_devices(gpus[0], 'GPU')
+        print(f"✅ Usando GPU: {gpus[0]}")
+    except RuntimeError as e:
+        print(f"⚠️ Error configurando GPU: {e}")
+else:
+    print("⚠️ No se detectó GPU, usando CPU")
+
+# Configurar para usar mixed precision
+tf.keras.mixed_precision.set_global_policy('mixed_float16')
+
 # 🔁 Limpiar almacenamiento temporal si existe
 def clean_temp_dirs():
     print("🧹 Limpiando carpetas temporales...")
@@ -28,7 +51,7 @@ def clean_temp_dirs():
 clean_temp_dirs()
 
 # 📁 Parámetros
-DATASET_ID = "Segizu/facial-recognition"
+DATASET_ID = "Segizu/facial-recognition-preview"
 EMBEDDINGS_SUBFOLDER = "embeddings"
 LOCAL_EMB_DIR = Path("embeddings")
 LOCAL_EMB_DIR.mkdir(exist_ok=True)
@@ -48,8 +71,47 @@ def get_folder_size(path):
     return total / (1024 ** 3)
 
 def preprocess_image(img: Image.Image) -> np.ndarray:
-    img_rgb = img.convert("RGB")
-    img_resized = img_rgb.resize((160, 160), Image.Resampling.LANCZOS)
+    # Convertir a RGB si no lo es
+    if img.mode != 'RGB':
+        img = img.convert('RGB')
+    
+    # Obtener la orientación EXIF si existe
+    try:
+        exif = img._getexif()
+        if exif is not None:
+            orientation = exif.get(274)  # 274 es el tag de orientación en EXIF
+            if orientation is not None:
+                # Rotar la imagen según la orientación EXIF
+                if orientation == 3:
+                    img = img.rotate(180, expand=True)
+                elif orientation == 6:
+                    img = img.rotate(270, expand=True)
+                elif orientation == 8:
+                    img = img.rotate(90, expand=True)
+    except:
+        pass  # Si no hay EXIF o hay error, continuamos con la imagen original
+    
+    # Intentar detectar la orientación del rostro
+    try:
+        # Convertir a array numpy para DeepFace
+        img_array = np.array(img)
+        # Detectar rostros con GPU
+        face_objs = DeepFace.extract_faces(
+            img_path=img_array,
+            target_size=(160, 160),
+            detector_backend='retinaface',
+            enforce_detection=False
+        )
+        
+        if face_objs and len(face_objs) > 0:
+            # Si se detecta un rostro, usar la imagen detectada
+            img_array = face_objs[0]['face']
+            return img_array
+    except:
+        pass  # Si falla la detección, continuamos con el procesamiento normal
+    
+    # Si no se detectó rostro o falló la detección, redimensionar la imagen original
+    img_resized = img.resize((160, 160), Image.Resampling.LANCZOS)
     return np.array(img_resized)
 
 # ✅ Cargar CSV desde el dataset
@@ -60,7 +122,6 @@ dataset = load_dataset(
     column_names=["image"],
     header=0
 )
-@GPU 
 def build_database():
     print(f"📊 Uso actual de almacenamiento temporal INICIO: {get_folder_size('.'):.2f} GB")
     print("🔄 Generando embeddings...")
@@ -171,49 +232,109 @@ def build_database():
 
 # 🔍 Buscar similitudes
 def find_similar_faces(uploaded_image: Image.Image):
+    if uploaded_image is None:
+        return [], "⚠ Por favor, sube una imagen primero"
+        
     try:
+        print("🔄 Procesando imagen de entrada...")
+        # Convertir a RGB si no lo es
+        if uploaded_image.mode != 'RGB':
+            uploaded_image = uploaded_image.convert('RGB')
+        
+        # Mostrar dimensiones de la imagen
+        print(f"📐 Dimensiones de la imagen: {uploaded_image.size}")
+        
         img_processed = preprocess_image(uploaded_image)
-        query_embedding = DeepFace.represent(
-            img_path=img_processed,
-            model_name="Facenet",
-            enforce_detection=False
-        )[0]["embedding"]
+        print("✅ Imagen preprocesada correctamente")
+        
+        # Intentar primero con enforce_detection=True
+        try:
+            query_embedding = DeepFace.represent(
+                img_path=img_processed,
+                model_name="Facenet",
+                enforce_detection=True,
+                detector_backend='retinaface'
+            )[0]["embedding"]
+            print("✅ Rostro detectado con enforce_detection=True")
+        except Exception as e:
+            print(f"⚠ No se pudo detectar rostro con enforce_detection=True, intentando con False: {str(e)}")
+            # Si falla, intentar con enforce_detection=False
+            query_embedding = DeepFace.represent(
+                img_path=img_processed,
+                model_name="Facenet",
+                enforce_detection=False,
+                detector_backend='retinaface'
+            )[0]["embedding"]
+            print("✅ Embedding generado con enforce_detection=False")
+        
         del img_processed
         gc.collect()
+        
     except Exception as e:
+        print(f"❌ Error en procesamiento de imagen: {str(e)}")
         return [], f"⚠ Error procesando imagen: {str(e)}"
 
     similarities = []
+    print("🔍 Buscando similitudes en la base de datos...")
 
     try:
         embedding_files = [
             f for f in list_repo_files(DATASET_ID, repo_type="dataset", token=HF_TOKEN)
-            if f.startswith(f"{EMBEDDINGS_SUBFOLDER}/") and f.endswith(".pkl")
+            if f.startswith(f"{EMBEDDINGS_SUBFOLDER}/") and f.endswith(".tar.gz")
         ]
+        print(f"📁 Encontrados {len(embedding_files)} archivos de embeddings")
     except Exception as e:
+        print(f"❌ Error obteniendo archivos: {str(e)}")
         return [], f"⚠ Error obteniendo archivos: {str(e)}"
 
-    for file_path in embedding_files:
-        try:
-            file_bytes = requests.get(
-                f"https://huggingface.co/datasets/{DATASET_ID}/resolve/main/{file_path}",
-                headers=headers,
-                timeout=10
-            ).content
-            record = pickle.loads(file_bytes)
-
-            name = record["name"]
-            img = record["img"]
-            emb = record["embedding"]
-
-            dist = np.linalg.norm(np.array(query_embedding) - np.array(emb))
-            sim_score = 1 / (1 + dist)
-            similarities.append((sim_score, name, np.array(img)))
+    # Procesar en lotes para mejor rendimiento
+    batch_size = 10
+    for i in range(0, len(embedding_files), batch_size):
+        batch_files = embedding_files[i:i + batch_size]
+        print(f"📦 Procesando lote {i//batch_size + 1}/{(len(embedding_files) + batch_size - 1)//batch_size}")
+        
+        for file_path in batch_files:
+            try:
+                file_bytes = requests.get(
+                    f"https://huggingface.co/datasets/{DATASET_ID}/resolve/main/{file_path}",
+                    headers=headers,
+                    timeout=30
+                ).content
+                
+                # Crear un archivo temporal para el tar.gz
+                temp_archive = Path("temp_archive.tar.gz")
+                with open(temp_archive, "wb") as f:
+                    f.write(file_bytes)
+                
+                # Extraer el contenido
+                with tarfile.open(temp_archive, "r:gz") as tar:
+                    tar.extractall(path="temp_extract")
+                
+                # Procesar cada archivo .pkl en el tar
+                for pkl_file in Path("temp_extract").glob("*.pkl"):
+                    with open(pkl_file, "rb") as f:
+                        record = pickle.load(f)
+                    
+                    name = record["name"]
+                    img = record["img"]
+                    emb = record["embedding"]
+
+                    dist = np.linalg.norm(np.array(query_embedding) - np.array(emb))
+                    sim_score = 1 / (1 + dist)
+                    similarities.append((sim_score, name, np.array(img)))
+                
+                # Limpiar archivos temporales
+                shutil.rmtree("temp_extract")
+                temp_archive.unlink()
+                
+            except Exception as e:
+                print(f"⚠ Error procesando {file_path}: {e}")
+                continue
 
-        except Exception as e:
-            print(f"⚠ Error con {file_path}: {e}")
-            continue
+    if not similarities:
+        return [], "⚠ No se encontraron similitudes en la base de datos"
 
+    print(f"✅ Encontradas {len(similarities)} similitudes")
     similarities.sort(reverse=True)
     top = similarities[:5]
     gallery = [(img, f"{name} - Similitud: {sim:.2f}") for sim, name, img in top]
@@ -234,5 +355,5 @@ with gr.Blocks() as demo:
         build_btn = gr.Button("⚙️ Construir base de embeddings (usa GPU)")
         build_btn.click(fn=build_database, inputs=[], outputs=[])
 
-demo.launch()
+demo.launch(share=True)
 

requirements.txt

@@ -1,4 +1,4 @@
-gradio==4.14.0
+gradio==3.50.2
 numpy
 Pillow
 opencv-python-headless
@@ -6,7 +6,9 @@ opencv-python-headless
 # DeepFace desde GitHub
 git+https://github.com/serengil/deepface.git
 
-# Fixes para RetinaFace
-tensorflow==2.12.0
+# TensorFlow con soporte GPU
+tensorflow-gpu==2.15.0
 tf-keras
-spaces
+spaces
+datasets
+pydantic>=2.0.0,<3.0.0