Upload 3 files

api_client.py

@@ -4,8 +4,9 @@ import requests
 import base64
 import zipfile
 import io
-from typing import Iterable, Dict, Any, Tuple
+from typing import Iterable, Dict, Any, Tuple, Optional
 from PIL import Image
+import numpy as np
 
 class APIClient:
     """
@@ -482,11 +483,30 @@ def describe_image_with_svision(image_path: str, is_face: bool = True) -> Tuple[
         
         full_description = result.strip() if result else ""
         
-        # Limpiar prefijos no deseados como "user", "assistant", etc.
-        for prefix in ["user:", "user ", "assistant:", "assistant ", "User:", "User ", "Assistant:", "Assistant "]:
-            if full_description.startswith(prefix):
-                full_description = full_description[len(prefix):].strip()
-                break
+        # Limpiar prefijos no deseados de forma más agresiva
+        # Lista de prefijos comunes que aparecen
+        prefixes_to_remove = [
+            "user:", "user ", "user\n", "user\t",
+            "assistant:", "assistant ", "assistant\n",
+            "User:", "User ", "User\n",
+            "Assistant:", "Assistant ", "Assistant\n",
+            "system:", "system ",
+        ]
+        
+        # Intentar limpiar múltiples veces por si hay varios prefijos
+        cleaned = False
+        for _ in range(3):  # Máximo 3 iteraciones
+            original = full_description
+            for prefix in prefixes_to_remove:
+                if full_description.lower().startswith(prefix.lower()):
+                    full_description = full_description[len(prefix):].strip()
+                    cleaned = True
+                    break
+            if original == full_description:
+                break  # No hubo cambios, salir
+        
+        # Limpiar espacios en blanco múltiples y saltos de línea al inicio
+        full_description = full_description.lstrip()
         
         if not full_description:
             return ("", "")
@@ -526,3 +546,71 @@ def describe_image_with_svision(image_path: str, is_face: bool = True) -> Tuple[
         import traceback
         traceback.print_exc()
         return ("", "")
+
+
+def validate_face_with_deepface(image_path: str) -> Optional[Dict[str, Any]]:
+    """
+    Valida si una imagen contiene una cara real usando DeepFace.
+    
+    Returns:
+        Dict con: {
+            'is_face': bool,
+            'gender': 'Man' | 'Woman' | None,
+            'confidence': float,
+            'age': int | None
+        }
+        o None si falla la detección
+    """
+    try:
+        from deepface import DeepFace
+        
+        print(f"[DeepFace] Analitzant imatge: {image_path}")
+        
+        # Analizar la imagen para detectar atributos
+        # enforce_detection=False permite continuar aunque no detecte cara
+        result = DeepFace.analyze(
+            img_path=image_path,
+            actions=['gender', 'age'],
+            enforce_detection=True,  # Forzar detección de cara
+            detector_backend='opencv',  # Usar opencv (más rápido)
+            silent=True
+        )
+        
+        # DeepFace puede devolver lista si detecta múltiples caras
+        if isinstance(result, list):
+            result = result[0] if result else None
+        
+        if not result:
+            print(f"[DeepFace] No s'ha detectat cap cara")
+            return {'is_face': False, 'gender': None, 'confidence': 0.0, 'age': None}
+        
+        # Extraer información
+        gender_info = result.get('gender', {})
+        age = result.get('age')
+        
+        # DeepFace devuelve probabilidades para Man y Woman
+        if isinstance(gender_info, dict):
+            man_prob = gender_info.get('Man', 0)
+            woman_prob = gender_info.get('Woman', 0)
+            gender = 'Man' if man_prob > woman_prob else 'Woman'
+            confidence = max(man_prob, woman_prob)
+        else:
+            gender = str(gender_info) if gender_info else None
+            confidence = 0.5
+        
+        print(f"[DeepFace] Resultat: gender={gender}, confidence={confidence:.2f}, age={age}")
+        
+        return {
+            'is_face': True,
+            'gender': gender,
+            'confidence': confidence,
+            'age': age
+        }
+        
+    except ValueError as e:
+        # ValueError significa que no se detectó cara
+        print(f"[DeepFace] No s'ha detectat cara: {e}")
+        return {'is_face': False, 'gender': None, 'confidence': 0.0, 'age': None}
+    except Exception as e:
+        print(f"[DeepFace] Error validant cara: {e}")
+        return None

app.py

@@ -100,6 +100,28 @@ def get_all_catalan_names():
                  "Alba", "Elisabet", "Rosa", "Gemma", "Sílvia", "Teresa", "Irene", "Laia", "Marina", "Bet"]
     return noms_home, noms_dona
 
+def get_random_catalan_name_by_gender(is_woman: bool, seed_value: str = "") -> str:
+    """
+    Genera un nom català aleatori basat en el gènere.
+    
+    Args:
+        is_woman: True si és dona, False si és home
+        seed_value: Valor per fer el random determinista (opcional)
+    
+    Returns:
+        Nom català
+    """
+    noms_home, noms_dona = get_all_catalan_names()
+    noms = noms_dona if is_woman else noms_home
+    
+    # Usar hash del seed para seleccionar nombre 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)
+
 def get_catalan_name_for_speaker(speaker_label: int, used_names_home: list = None, used_names_dona: list = None) -> str:
     """
     Genera un nom català per a un speaker, reutilitzant noms de caras si estan disponibles.
@@ -694,8 +716,8 @@ if page == "Processar vídeo nou":
                 
                 # Botón para generar descripción con svision
                 if st.button("🎨 Generar descripció amb Salamandra Vision", key=f"svision_{key_prefix}"):
-                    with st.spinner("Generant descripció..."):
-                        from api_client import describe_image_with_svision
+                    with st.spinner("Validant i generant descripció..."):
+                        from api_client import describe_image_with_svision, validate_face_with_deepface
                         import os as _os2
                         import tempfile
                         import requests as _req
@@ -709,25 +731,44 @@ if page == "Processar vídeo nou":
                                     tmp.write(resp.content)
                                     tmp_path = tmp.name
                                 
-                                # Llamar a svision
-                                desc, name = describe_image_with_svision(tmp_path, is_face=True)
+                                # PASO 1: Validar con DeepFace
+                                validation = validate_face_with_deepface(tmp_path)
                                 
-                                # Guardar en keys temporales para aplicar en el siguiente render
-                                if desc:
-                                    st.session_state[pending_desc_key] = desc
-                                    log(f"[SVISION] Descripció generada per {ch.get('id', 'unknown')}: {desc[:100]}")
-                                    st.success("✅ Descripció generada!")
+                                if validation and validation.get('is_face'):
+                                    # Es una cara válida
+                                    gender = validation.get('gender')
+                                    confidence = validation.get('confidence', 0)
+                                    age = validation.get('age')
+                                    
+                                    log(f"[DEEPFACE] Cara vàlida: gender={gender}, confidence={confidence:.2f}, age={age}")
+                                    
+                                    # PASO 2: Generar nombre basado en género
+                                    if not st.session_state.get(name_key):
+                                        # Determinar género para el nombre
+                                        is_woman = gender == 'Woman'
+                                        generated_name = get_random_catalan_name_by_gender(is_woman, ch.get('id', ''))
+                                        st.session_state[pending_name_key] = generated_name
+                                        log(f"[NAME] Nom generat: {generated_name} (gender={gender})")
+                                    
+                                    # PASO 3: Llamar a svision para descripción
+                                    desc, _ = describe_image_with_svision(tmp_path, is_face=True)
+                                    
+                                    # Guardar en keys temporales para aplicar en el siguiente render
+                                    if desc:
+                                        st.session_state[pending_desc_key] = desc
+                                        log(f"[SVISION] Descripció generada per {ch.get('id', 'unknown')}: {desc[:100]}")
+                                        st.success(f"✅ Cara vàlida detectada! ({gender}, {int(age) if age else '?'} anys)")
+                                    else:
+                                        st.warning("⚠️ No s'ha pogut generar una descripció.")
+                                    
+                                    # Limpiar archivo temporal
+                                    _os2.unlink(tmp_path)
+                                    st.rerun()
                                 else:
-                                    st.warning("⚠️ No s'ha pogut generar una descripció.")
-                                
-                                # Si se generó un nombre, también guardarlo
-                                if name:
-                                    st.session_state[pending_name_key] = name
-                                    log(f"[SVISION] Nom generat per {ch.get('id', 'unknown')}: {name}")
-                                
-                                # Limpiar archivo temporal
-                                _os2.unlink(tmp_path)
-                                st.rerun()
+                                    # No es una cara válida
+                                    log(f"[DEEPFACE] ✗ Imatge descartada - no és una cara vàlida")
+                                    st.error("❌ Aquesta imatge no sembla ser una cara vàlida. Considera eliminar aquest clúster.")
+                                    _os2.unlink(tmp_path)
                             else:
                                 st.error(f"No s'ha pogut descarregar la imatge (status: {resp.status_code})")
                         except Exception as e:

requirements.txt

@@ -7,4 +7,6 @@ pydub
 python-dotenv
 gradio_client  # Para llamar al space svision
 Pillow         # Para procesar imágenes antes de enviar a svision
-# Forzar rebuild 2025-10-31
+deepface       # Para validar caras y detectar género/edad
+tf-keras       # Dependencia de deepface (necesita TensorFlow/Keras)
+# Forzar rebuild 2025-11-01