Upload 3 files

face_classifier.py

@@ -1,215 +1,260 @@
-"""
-Face Classifier Module
-Valida caras y detecta género usando DeepFace para filtrar falsos positivos
-y asignar nombres automáticos según el género detectado.
-"""
-import logging
-from typing import Optional, Dict, Any
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Configuración de thresholds
-# FACE_CONFIDENCE_THRESHOLD: Confianza mínima para aceptar una cara
-# Valores: 0.3 = permisivo (acepta muchos falsos positivos)
-#          0.6 = balanceado
-#          0.8 = estricto (elimina falsos positivos pero puede perder caras reales)
-#          0.85 = MUY estricto (solo caras muy claras)
-FACE_CONFIDENCE_THRESHOLD = 0.85  # MUY ESTRICTO: eliminar camisetas, letreros, etc.
-GENDER_NEUTRAL_THRESHOLD = 0.2    # Diferencia mínima para género neutro
-
-
-def validate_and_classify_face(image_path: str) -> Optional[Dict[str, Any]]:
-    """
-    Valida si és una cara real i detecta el gènere usant DeepFace.
-    
-    Args:
-        image_path: Ruta a la imagen de la cara
-    
-    Returns:
-        Dict amb: {
-            'is_valid_face': bool,          # True si és una cara amb confiança alta
-            'face_confidence': float,        # Score de detecció de cara (0-1)
-            'gender': 'Man' | 'Woman' | 'Neutral',
-            'gender_confidence': float,      # Score de confiança del gènere (0-1)
-            'man_prob': float,
-            'woman_prob': float
-        }
-        o None si falla completament
-    """
-    try:
-        import cv2
-        import numpy as np
-        from deepface import DeepFace
-        
-        print(f"[DeepFace] Analitzant: {image_path}")
-        
-        # PREPROCESAMIENTO: Normalizar iluminación y mejorar contraste
-        # Esto reduce el impacto de luz/oscuridad en la detección
-        img = cv2.imread(str(image_path))
-        if img is None:
-            print(f"[DeepFace] No se pudo cargar la imagen: {image_path}")
-            return None
-            
-        # Convertir a escala de grises (más robusto para detección)
-        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
-        
-        # CLAHE: Adaptive Histogram Equalization
-        # Normaliza el contraste de forma local, reduciendo efectos de luz
-        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
-        normalized = clahe.apply(gray)
-        
-        # Volver a BGR para DeepFace
-        normalized_bgr = cv2.cvtColor(normalized, cv2.COLOR_GRAY2BGR)
-        
-        # Guardar imagen preprocesada temporalmente
-        import tempfile
-        import os
-        temp_dir = tempfile.gettempdir()
-        temp_path = os.path.join(temp_dir, f"normalized_{os.path.basename(image_path)}")
-        cv2.imwrite(temp_path, normalized_bgr)
-        
-        print(f"[DeepFace] Imagen preprocesada con CLAHE: {temp_path}")
-        
-        # Analitzar gènere amb detecció de cara (usando imagen normalizada)
-        result = DeepFace.analyze(
-            img_path=temp_path,
-            actions=['gender'],
-            enforce_detection=True,  # Intentar detectar cara
-            detector_backend='opencv',
-            silent=True
-        )
-        
-        # Limpiar archivo temporal
-        try:
-            os.remove(temp_path)
-        except:
-            pass
-        
-        # DeepFace pot retornar llista si detecta múltiples cares
-        if isinstance(result, list):
-            print(f"[DeepFace] Resultado es lista con {len(result)} elementos")
-            result = result[0] if result else None
-        
-        if not result:
-            print(f"[DeepFace] No s'ha detectat cap cara")
-            return {
-                'is_valid_face': False,
-                'face_confidence': 0.0,
-                'gender': 'Neutral',
-                'gender_confidence': 0.0,
-                'man_prob': 0.0,
-                'woman_prob': 0.0
-            }
-        
-        # LOG: Ver estructura completa del resultado
-        print(f"[DeepFace] Resultado completo de analyze: {result}")
-        
-        # Extreure informació de gènere
-        gender_info = result.get('gender', {})
-        print(f"[DeepFace] gender_info type: {type(gender_info)}, value: {gender_info}")
-        
-        if isinstance(gender_info, dict):
-            # DeepFace retorna percentatges, convertir a 0-1
-            man_prob = gender_info.get('Man', 0) / 100.0
-            woman_prob = gender_info.get('Woman', 0) / 100.0
-            print(f"[DeepFace] Extraído de dict - Man: {man_prob:.3f}, Woman: {woman_prob:.3f}")
-        else:
-            # Fallback si el format és diferent
-            print(f"[DeepFace] gender_info NO es dict, usando fallback 0.5/0.5")
-            man_prob = 0.5
-            woman_prob = 0.5
-        
-        # Determinar gènere basat en les probabilitats
-        gender_diff = abs(man_prob - woman_prob)
-        
-        print(f"[DeepFace] Diferencia Man-Woman: {gender_diff:.3f} (threshold neutral={GENDER_NEUTRAL_THRESHOLD})")
-        
-        # Si la diferència és petita (< threshold), considerar neutre
-        if gender_diff < GENDER_NEUTRAL_THRESHOLD:
-            gender = 'Neutral'
-            gender_confidence = 0.5
-            print(f"[DeepFace] → Asignado NEUTRAL (diferencia {gender_diff:.3f} < {GENDER_NEUTRAL_THRESHOLD})")
-        else:
-            gender = 'Man' if man_prob > woman_prob else 'Woman'
-            gender_confidence = max(man_prob, woman_prob)
-            print(f"[DeepFace] → Asignado {gender.upper()} (man_prob={man_prob:.3f}, woman_prob={woman_prob:.3f})")
-        
-        # Confiança de detecció de cara
-        # DeepFace no proporciona score directamente en analyze(), pero si retornó resultado
-        # asumimos que es cara válida con confianza alta
-        face_confidence = result.get('face_confidence', 0.9)  # Default alto si detecta
-        
-        # Si DeepFace va retornar resultat, assumir que és cara vàlida
-        is_valid_face = True
-        
-        print(f"[DeepFace] ===== RESUMEN FINAL =====")
-        print(f"[DeepFace]   is_valid_face: {is_valid_face}")
-        print(f"[DeepFace]   face_confidence: {face_confidence:.3f}")
-        print(f"[DeepFace]   gender: {gender}")
-        print(f"[DeepFace]   gender_confidence: {gender_confidence:.3f}")
-        print(f"[DeepFace]   man_prob: {man_prob:.3f}")
-        print(f"[DeepFace]   woman_prob: {woman_prob:.3f}")
-        print(f"[DeepFace] ==========================")
-        
-        return {
-            'is_valid_face': is_valid_face,
-            'face_confidence': face_confidence,
-            'gender': gender,
-            'gender_confidence': gender_confidence,
-            'man_prob': man_prob,
-            'woman_prob': woman_prob
-        }
-        
-    except ValueError as e:
-        # ValueError significa que no es va detectar cara
-        print(f"[DeepFace] No s'ha detectat cara (ValueError): {e}")
-        return {
-            'is_valid_face': False,
-            'face_confidence': 0.0,
-            'gender': 'Neutral',
-            'gender_confidence': 0.0,
-            'man_prob': 0.0,
-            'woman_prob': 0.0
-        }
-    except Exception as e:
-        print(f"[DeepFace] Error validant cara: {e}")
-        return None
-
-
-def get_random_catalan_name_by_gender(gender: str, seed_value: str = "") -> str:
-    """
-    Genera un nom català aleatori basat en el gènere.
-    
-    Args:
-        gender: 'Man', 'Woman', o 'Neutral'
-        seed_value: Valor per fer el random determinista (opcional)
-    
-    Returns:
-        Nom català
-    """
-    noms_home = [
-        "Jordi", "Marc", "Pau", "Pere", "Joan", "Josep", "David", "Guillem", "Albert",
-        "Arnau", "Martí", "Bernat", "Oriol", "Roger", "Pol", "Lluís", "Sergi", "Carles", "Xavier"
-    ]
-    noms_dona = [
-        "Maria", "Anna", "Laura", "Marta", "Cristina", "Núria", "Montserrat", "Júlia", "Sara", "Carla",
-        "Alba", "Elisabet", "Rosa", "Gemma", "Sílvia", "Teresa", "Irene", "Laia", "Marina", "Bet"
-    ]
-    noms_neutre = ["Àlex", "Andrea", "Francis", "Cris", "Noa"]
-    
-    # Seleccionar llista segons gènere
-    if gender == 'Woman':
-        noms = noms_dona
-    elif gender == 'Man':
-        noms = noms_home
-    else:  # Neutral
-        noms = noms_neutre
-    
-    # Usar hash del seed per seleccionar nom de forma determinista
-    if seed_value:
-        hash_val = hash(seed_value)
-        return noms[abs(hash_val) % len(noms)]
-    else:
-        import random
-        return random.choice(noms)
+"""
+Face Classifier Module
+Valida caras y detecta género usando DeepFace para filtrar falsos positivos
+y asignar nombres automáticos según el género detectado.
+"""
+import logging
+from typing import Optional, Dict, Any
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Configuración de thresholds
+# FACE_CONFIDENCE_THRESHOLD: Confianza mínima para aceptar una cara
+# Valores: 0.5 = permisivo (acepta muchos falsos positivos)
+#          0.7 = balanceado
+#          0.85 = estricto (elimina falsos positivos pero puede perder caras reales)
+#          0.92 = MUY estricto (solo caras muy claras)
+FACE_CONFIDENCE_THRESHOLD = 0.92  # MUY ESTRICTO: preferir perder caras a tener falsos positivos
+GENDER_NEUTRAL_THRESHOLD = 0.2    # Diferencia mínima para género neutro
+
+# Configuración adicional de filtrado
+MIN_FACE_SIZE_PIXELS = 48         # Tamaño mínimo de cara en píxeles (ancho o alto)
+MAX_ASPECT_RATIO = 2.0            # Proporción máxima ancho/alto (caras reales ~0.7-1.3)
+MIN_ASPECT_RATIO = 0.5            # Proporción mínima ancho/alto
+
+
+def validate_and_classify_face(image_path: str) -> Optional[Dict[str, Any]]:
+    """
+    Valida si és una cara real i detecta el gènere usant DeepFace.
+    Usa extract_faces() para obtener score de confianza REAL de detección.
+    
+    Args:
+        image_path: Ruta a la imagen de la cara
+    
+    Returns:
+        Dict amb: {
+            'is_valid_face': bool,          # True si és una cara amb confiança alta
+            'face_confidence': float,        # Score de detecció de cara (0-1)
+            'gender': 'Man' | 'Woman' | 'Neutral',
+            'gender_confidence': float,      # Score de confiança del gènere (0-1)
+            'man_prob': float,
+            'woman_prob': float,
+            'rejection_reason': str | None   # Motivo de rechazo si is_valid_face=False
+        }
+        o None si falla completament
+    """
+    try:
+        import cv2
+        import numpy as np
+        from deepface import DeepFace
+        
+        print(f"[DeepFace] Analitzant: {image_path}")
+        
+        # Cargar imagen para verificaciones de tamaño
+        img = cv2.imread(str(image_path))
+        if img is None:
+            print(f"[DeepFace] No se pudo cargar la imagen: {image_path}")
+            return None
+        
+        img_height, img_width = img.shape[:2]
+        print(f"[DeepFace] Tamaño imagen: {img_width}x{img_height}")
+        
+        # VERIFICACIÓN 1: Tamaño mínimo de imagen
+        if img_width < MIN_FACE_SIZE_PIXELS or img_height < MIN_FACE_SIZE_PIXELS:
+            print(f"[DeepFace] ✗ RECHAZADA: Imagen demasiado pequeña ({img_width}x{img_height} < {MIN_FACE_SIZE_PIXELS}px)")
+            return {
+                'is_valid_face': False,
+                'face_confidence': 0.0,
+                'gender': 'Neutral',
+                'gender_confidence': 0.0,
+                'man_prob': 0.0,
+                'woman_prob': 0.0,
+                'rejection_reason': f'Imagen demasiado pequeña ({img_width}x{img_height})'
+            }
+        
+        # VERIFICACIÓN 2: Proporción de la imagen (caras reales tienen proporción ~0.7-1.3)
+        aspect_ratio = img_width / img_height
+        if aspect_ratio > MAX_ASPECT_RATIO or aspect_ratio < MIN_ASPECT_RATIO:
+            print(f"[DeepFace] ✗ RECHAZADA: Proporción anómala ({aspect_ratio:.2f}, esperado {MIN_ASPECT_RATIO}-{MAX_ASPECT_RATIO})")
+            return {
+                'is_valid_face': False,
+                'face_confidence': 0.0,
+                'gender': 'Neutral',
+                'gender_confidence': 0.0,
+                'man_prob': 0.0,
+                'woman_prob': 0.0,
+                'rejection_reason': f'Proporción anómala ({aspect_ratio:.2f})'
+            }
+        
+        # PASO 1: Usar extract_faces() para obtener score de confianza REAL
+        # Este es el método correcto para obtener el confidence score de detección
+        print(f"[DeepFace] Ejecutando extract_faces() para obtener confidence score...")
+        
+        try:
+            faces = DeepFace.extract_faces(
+                img_path=str(image_path),
+                detector_backend='retinaface',  # Más preciso que opencv
+                enforce_detection=True,
+                align=True
+            )
+            
+            if not faces:
+                print(f"[DeepFace] ✗ extract_faces() no detectó ninguna cara")
+                return {
+                    'is_valid_face': False,
+                    'face_confidence': 0.0,
+                    'gender': 'Neutral',
+                    'gender_confidence': 0.0,
+                    'man_prob': 0.0,
+                    'woman_prob': 0.0,
+                    'rejection_reason': 'No se detectó cara con retinaface'
+                }
+            
+            # Tomar la cara con mayor confianza
+            best_face = max(faces, key=lambda f: f.get('confidence', 0))
+            face_confidence = best_face.get('confidence', 0.0)
+            facial_area = best_face.get('facial_area', {})
+            
+            print(f"[DeepFace] extract_faces() encontró {len(faces)} cara(s)")
+            print(f"[DeepFace] Mejor cara - confidence: {face_confidence:.4f}")
+            print(f"[DeepFace] Facial area: {facial_area}")
+            
+            # VERIFICACIÓN 3: Score de confianza de detección
+            if face_confidence < FACE_CONFIDENCE_THRESHOLD:
+                print(f"[DeepFace] ✗ RECHAZADA: Confianza baja ({face_confidence:.4f} < {FACE_CONFIDENCE_THRESHOLD})")
+                return {
+                    'is_valid_face': False,
+                    'face_confidence': face_confidence,
+                    'gender': 'Neutral',
+                    'gender_confidence': 0.0,
+                    'man_prob': 0.0,
+                    'woman_prob': 0.0,
+                    'rejection_reason': f'Confianza baja ({face_confidence:.4f})'
+                }
+            
+            # VERIFICACIÓN 4: Tamaño del área facial detectada
+            face_w = facial_area.get('w', 0)
+            face_h = facial_area.get('h', 0)
+            if face_w < MIN_FACE_SIZE_PIXELS * 0.5 or face_h < MIN_FACE_SIZE_PIXELS * 0.5:
+                print(f"[DeepFace] ✗ RECHAZADA: Área facial muy pequeña ({face_w}x{face_h})")
+                return {
+                    'is_valid_face': False,
+                    'face_confidence': face_confidence,
+                    'gender': 'Neutral',
+                    'gender_confidence': 0.0,
+                    'man_prob': 0.0,
+                    'woman_prob': 0.0,
+                    'rejection_reason': f'Área facial muy pequeña ({face_w}x{face_h})'
+                }
+                
+        except ValueError as e:
+            print(f"[DeepFace] ✗ extract_faces() ValueError: {e}")
+            return {
+                'is_valid_face': False,
+                'face_confidence': 0.0,
+                'gender': 'Neutral',
+                'gender_confidence': 0.0,
+                'man_prob': 0.0,
+                'woman_prob': 0.0,
+                'rejection_reason': f'extract_faces falló: {e}'
+            }
+        
+        # PASO 2: Analizar género (solo si pasó las verificaciones anteriores)
+        print(f"[DeepFace] ✓ Cara válida, analizando género...")
+        
+        try:
+            result = DeepFace.analyze(
+                img_path=str(image_path),
+                actions=['gender'],
+                enforce_detection=False,  # Ya verificamos que hay cara
+                detector_backend='skip',  # Saltar detección, ya la hicimos
+                silent=True
+            )
+            
+            if isinstance(result, list):
+                result = result[0] if result else {}
+            
+            gender_info = result.get('gender', {})
+            
+            if isinstance(gender_info, dict):
+                man_prob = gender_info.get('Man', 0) / 100.0
+                woman_prob = gender_info.get('Woman', 0) / 100.0
+            else:
+                man_prob = 0.5
+                woman_prob = 0.5
+            
+            gender_diff = abs(man_prob - woman_prob)
+            
+            if gender_diff < GENDER_NEUTRAL_THRESHOLD:
+                gender = 'Neutral'
+                gender_confidence = 0.5
+            else:
+                gender = 'Man' if man_prob > woman_prob else 'Woman'
+                gender_confidence = max(man_prob, woman_prob)
+                
+        except Exception as e:
+            print(f"[DeepFace] Análisis de género falló: {e}, usando valores neutros")
+            gender = 'Neutral'
+            gender_confidence = 0.5
+            man_prob = 0.5
+            woman_prob = 0.5
+        
+        print(f"[DeepFace] ===== RESUMEN FINAL =====")
+        print(f"[DeepFace]   ✓ is_valid_face: True")
+        print(f"[DeepFace]   face_confidence: {face_confidence:.4f} (threshold: {FACE_CONFIDENCE_THRESHOLD})")
+        print(f"[DeepFace]   gender: {gender}")
+        print(f"[DeepFace]   gender_confidence: {gender_confidence:.3f}")
+        print(f"[DeepFace] ==========================")
+        
+        return {
+            'is_valid_face': True,
+            'face_confidence': face_confidence,
+            'gender': gender,
+            'gender_confidence': gender_confidence,
+            'man_prob': man_prob,
+            'woman_prob': woman_prob,
+            'rejection_reason': None
+        }
+        
+    except Exception as e:
+        print(f"[DeepFace] Error validant cara: {e}")
+        return None
+
+
+def get_random_catalan_name_by_gender(gender: str, seed_value: str = "") -> str:
+    """
+    Genera un nom català aleatori basat en el gènere.
+    
+    Args:
+        gender: 'Man', 'Woman', o 'Neutral'
+        seed_value: Valor per fer el random determinista (opcional)
+    
+    Returns:
+        Nom català
+    """
+    noms_home = [
+        "Jordi", "Marc", "Pau", "Pere", "Joan", "Josep", "David", "Guillem", "Albert",
+        "Arnau", "Martí", "Bernat", "Oriol", "Roger", "Pol", "Lluís", "Sergi", "Carles", "Xavier"
+    ]
+    noms_dona = [
+        "Maria", "Anna", "Laura", "Marta", "Cristina", "Núria", "Montserrat", "Júlia", "Sara", "Carla",
+        "Alba", "Elisabet", "Rosa", "Gemma", "Sílvia", "Teresa", "Irene", "Laia", "Marina", "Bet"
+    ]
+    noms_neutre = ["Àlex", "Andrea", "Francis", "Cris", "Noa"]
+    
+    # Seleccionar llista segons gènere
+    if gender == 'Woman':
+        noms = noms_dona
+    elif gender == 'Man':
+        noms = noms_home
+    else:  # Neutral
+        noms = noms_neutre
+    
+    # Usar hash del seed per seleccionar nom de forma determinista
+    if seed_value:
+        hash_val = hash(seed_value)
+        return noms[abs(hash_val) % len(noms)]
+    else:
+        import random
+        return random.choice(noms)