Upload 2 files

api.py

@@ -12,6 +12,7 @@ from datetime import datetime
 from typing import Dict
 from enum import Enum
 import os
+import yaml
 
 from video_processing import process_video_pipeline
 from audio_tools import process_audio_for_video, extract_audio_ffmpeg, embed_voice_segments
@@ -80,12 +81,14 @@ def describe_image_with_svision(image_path: str, is_face: bool = True) -> tuple[
         if is_face:
             context = {
                 "task": "describe_person",
-                "instructions": "Descriu la persona en la imatge. Inclou: edat aproximada (jove/adult), gènere, característiques físiques notables (ulleres, barba, bigoti, etc.), expressió i vestimenta."
+                "instructions": "Descriu la persona en la imatge. Inclou: edat aproximada (jove/adult), gènere, característiques físiques notables (ulleres, barba, bigoti, etc.), expressió i vestimenta.",
+                "max_tokens": 256
             }
         else:
             context = {
                 "task": "describe_scene",
-                "instructions": "Descriu l'escena en la imatge. Inclou: tipus de localització (interior/exterior), elements principals, ambient, il·luminació."
+                "instructions": "Descriu aquesta escena breument en 2-3 frases: tipus de localització i elements principals.",
+                "max_tokens": 128
             }
         
         # Llamar a svision
@@ -574,17 +577,28 @@ def process_video_job(job_id: str):
                 best_face = face_detections_sorted[0]
                 best_face_path = faces_root / best_face['file']
                 
-                print(f"[{job_id}] [VALIDATION] Cluster {char_id}: validant millor cara (score={best_face['score']:.0f}px²)")
+                print(f"[{job_id}] [VALIDATION] Cluster {char_id}: validant millor cara (bbox_area={best_face['score']:.0f}px²)")
+                print(f"[{job_id}] [VALIDATION] Cluster {char_id}: millor cara path={best_face_path}")
                 
                 validation = validate_and_classify_face(str(best_face_path))
                 
                 if not validation:
-                    print(f"[{job_id}] [VALIDATION] ✗ Cluster {char_id}: error en validació, eliminant")
+                    print(f"[{job_id}] [VALIDATION] ✗ Cluster {char_id}: error en validació DeepFace, eliminant cluster")
                     continue
                 
+                # Mostrar resultados detallados de DeepFace
+                print(f"[{job_id}] [DEEPFACE RESULT] Cluster {char_id}:")
+                print(f"[{job_id}]   - is_valid_face: {validation['is_valid_face']}")
+                print(f"[{job_id}]   - face_confidence: {validation['face_confidence']:.3f}")
+                print(f"[{job_id}]   - man_prob: {validation['man_prob']:.3f}")
+                print(f"[{job_id}]   - woman_prob: {validation['woman_prob']:.3f}")
+                print(f"[{job_id}]   - gender_diff: {abs(validation['man_prob'] - validation['woman_prob']):.3f}")
+                print(f"[{job_id}]   - gender_assigned: {validation['gender']}")
+                print(f"[{job_id}]   - gender_confidence: {validation['gender_confidence']:.3f}")
+                
                 # PASO 3: Verificar si és una cara vàlida
                 if not validation['is_valid_face'] or validation['face_confidence'] < FACE_CONFIDENCE_THRESHOLD:
-                    print(f"[{job_id}] [VALIDATION] ✗ Cluster {char_id}: score baix ({validation['face_confidence']:.2f}), eliminant tot el clúster")
+                    print(f"[{job_id}] [VALIDATION] ✗ Cluster {char_id}: NO ES UNA CARA VÁLIDA (face_confidence={validation['face_confidence']:.3f} < threshold={FACE_CONFIDENCE_THRESHOLD}), eliminant tot el clúster")
                     continue
                 
                 # PASO 4: És una cara vàlida! Crear carpeta
@@ -624,6 +638,11 @@ def process_video_job(job_id: str):
                 gender = validation['gender']
                 character_name = get_random_catalan_name_by_gender(gender, char_id)
                 
+                print(f"[{job_id}] [NAME GENERATION] Cluster {char_id}:")
+                print(f"[{job_id}]   - Gender detectado: {gender}")
+                print(f"[{job_id}]   - Nombre asignado: {character_name}")
+                print(f"[{job_id}]   - Seed usado: {char_id}")
+                
                 character_data = {
                     "id": char_id,
                     "name": character_name,
@@ -641,9 +660,13 @@ def process_video_job(job_id: str):
                 
                 characters_validated.append(character_data)
                 
-                print(f"[{job_id}] [VALIDATION] ✓ Cluster {char_id}: cara vàlida! "
-                      f"Nom={character_name}, Gender={gender} (conf={validation['gender_confidence']:.2f}), "
-                      f"Mostrant {len(files)}/{total_faces} cares")
+                print(f"[{job_id}] [VALIDATION] ✓ Cluster {char_id}: CARA VÁLIDA!")
+                print(f"[{job_id}]   Nombre: {character_name}")
+                print(f"[{job_id}]   Género: {gender} (man={validation['man_prob']:.3f}, woman={validation['woman_prob']:.3f})")
+                print(f"[{job_id}]   Confianza género: {validation['gender_confidence']:.3f}")
+                print(f"[{job_id}]   Confianza cara: {validation['face_confidence']:.3f}")
+                print(f"[{job_id}]   Caras mostradas: {len(files)}/{total_faces}")
+                print(f"[{job_id}]   Imagen representativa: {best_face_path.name}")
             
             # Estadístiques finals
             eliminated_count = original_cluster_count - len(characters_validated)
@@ -1022,58 +1045,93 @@ async def detect_scenes(
             continue
         clusters.setdefault(int(lbl), []).append(i)
     
-    # VALIDACIÓ: Mesurar robustesa dels clusters i fusionar si són massa similars
+    # VALIDACIÓ MILLORADA: Fusionar clusters molt similars de forma més agressiva
     # Calcular centroides (histograma promig de cada cluster)
     centroids = {}
     for lbl, idxs in clusters.items():
         cluster_histograms = X[idxs]
         centroids[lbl] = np.mean(cluster_histograms, axis=0)
     
-    # Comparar distàncies entre clusters
-    # Si dos clusters tenen una distància euclidiana < threshold, són massa similars
-    SIMILARITY_THRESHOLD = 0.15  # Ajustable: més baix = més estricte
+    print(f"[SCENE VALIDATION] Validant similaritat entre {len(centroids)} clusters...")
     
-    # Calcular matriu de distàncies entre centroides
+    # Thresholds més agressius per fusionar escenes similars
+    SIMILARITY_THRESHOLD = 0.25  # Aumentado de 0.15 a 0.25 (fusiona más)
+    CORRELATION_THRESHOLD = 0.85  # Correlación mínima para considerar similares
+    
+    # Calcular matriu de distàncies i correlacions entre centroides
     cluster_labels = sorted(centroids.keys())
-    distances = {}
+    similarities = {}
+    
     for i, lbl1 in enumerate(cluster_labels):
         for lbl2 in cluster_labels[i+1:]:
+            # Distancia euclidiana (normalizada)
             dist = np.linalg.norm(centroids[lbl1] - centroids[lbl2])
-            distances[(lbl1, lbl2)] = dist
+            
+            # Correlación de Pearson entre histogramas
+            corr = np.corrcoef(centroids[lbl1], centroids[lbl2])[0, 1]
+            
+            # Son similares si:
+            # - Distancia baja (< threshold) O
+            # - Correlación alta (> threshold)
+            are_similar = (dist < SIMILARITY_THRESHOLD) or (corr > CORRELATION_THRESHOLD)
+            
+            similarities[(lbl1, lbl2)] = {
+                'distance': dist,
+                'correlation': corr,
+                'similar': are_similar
+            }
+            
+            if are_similar:
+                print(f"[SCENE VALIDATION] Clusters {lbl1} i {lbl2} són similars: "
+                      f"dist={dist:.3f} (threshold={SIMILARITY_THRESHOLD}), "
+                      f"corr={corr:.3f} (threshold={CORRELATION_THRESHOLD})")
+    
+    # Union-Find para fusionar clusters transitivamente
+    # Si A~B y B~C, entonces A~B~C (todos en el mismo grupo)
+    parent = {lbl: lbl for lbl in cluster_labels}
     
-    # Trobar parelles de clusters massa similars i fusionar-los
-    merged = {}  # mapatge de label_old -> label_new
-    for lbl in cluster_labels:
-        merged[lbl] = lbl
+    def find(x):
+        if parent[x] != x:
+            parent[x] = find(parent[x])  # Path compression
+        return parent[x]
     
-    # Fusionar clusters similars (greedy approach)
-    for (lbl1, lbl2), dist in sorted(distances.items(), key=lambda x: x[1]):
-        if dist < SIMILARITY_THRESHOLD:
-            # Fusionar lbl2 amb lbl1
-            current_lbl1 = merged.get(lbl1, lbl1)
-            current_lbl2 = merged.get(lbl2, lbl2)
-            if current_lbl1 != current_lbl2:
-                # Assignar lbl2 al grup de lbl1
-                for k, v in merged.items():
-                    if v == current_lbl2:
-                        merged[k] = current_lbl1
-                print(f"[SCENE VALIDATION] Fusionant clusters {lbl2} i {lbl1} (distància={dist:.3f})")
+    def union(x, y):
+        root_x = find(x)
+        root_y = find(y)
+        if root_x != root_y:
+            parent[root_y] = root_x
+    
+    # Fusionar todos los clusters similares
+    fusion_count = 0
+    for (lbl1, lbl2), sim in similarities.items():
+        if sim['similar']:
+            union(lbl1, lbl2)
+            fusion_count += 1
     
     # Aplicar fusió als clusters
     new_clusters = {}
     for lbl, idxs in clusters.items():
-        new_lbl = merged[lbl]
-        if new_lbl not in new_clusters:
-            new_clusters[new_lbl] = []
-        new_clusters[new_lbl].extend(idxs)
+        root = find(lbl)
+        if root not in new_clusters:
+            new_clusters[root] = []
+        new_clusters[root].extend(idxs)
+    
+    # Reordenar labels para que sean consecutivos
+    final_clusters_dict = {}
+    for i, (root, idxs) in enumerate(sorted(new_clusters.items())):
+        final_clusters_dict[i] = idxs
     
-    clusters = new_clusters
+    clusters = final_clusters_dict
     final_clusters = len(clusters)
     eliminated = initial_clusters - final_clusters
     
-    if eliminated > 0:
-        print(f"[SCENE VALIDATION] Reduït de {initial_clusters} a {final_clusters} clusters "
-              f"(eliminats {eliminated} clusters massa similars)")
+    print(f"[SCENE VALIDATION] ===== RESULTADO =====")
+    print(f"[SCENE VALIDATION] Clusters inicials: {initial_clusters}")
+    print(f"[SCENE VALIDATION] Fusions realitzades: {fusion_count}")
+    print(f"[SCENE VALIDATION] Clusters finals: {final_clusters}")
+    print(f"[SCENE VALIDATION] Clusters eliminats (fusionats): {eliminated}")
+    print(f"[SCENE VALIDATION] Reducció: {(eliminated/initial_clusters*100):.1f}%")
+    print(f"[SCENE VALIDATION] =======================")
 
     # Escriure imatges representatives per a cada clúster
     base = TEMP_ROOT / video_name / "scenes"
@@ -1110,6 +1168,38 @@ async def detect_scenes(
                     scene_description, scene_name = describe_image_with_svision(str(rep_full_path), is_face=False)
                     if not scene_name:
                         scene_name = f"Escena {lbl+1}"
+                    
+                    # Si tenemos descripción, generar nombre corto con schat
+                    if scene_description:
+                        print(f"Llamando a schat para generar nombre corto de {scene_id}...")
+                        try:
+                            # Usar LLMRouter para llamar a schat
+                            config_path = os.getenv("CONFIG_YAML", "config.yaml")
+                            if os.path.exists(config_path):
+                                with open(config_path, 'r', encoding='utf-8') as f:
+                                    cfg = yaml.safe_load(f) or {}
+                                router = LLMRouter(cfg)
+                                
+                                prompt = f"Basant-te en aquesta descripció d'una escena, genera un nom curt de menys de 3 paraules que la resumeixi:\n\n{scene_description}\n\nNom de l'escena:"
+                                
+                                short_name = router.instruct(
+                                    prompt=prompt,
+                                    system="Ets un assistent que genera noms curts i descriptius per a escenes. Respon NOMÉS amb el nom, sense explicacions.",
+                                    model="salamandra-instruct"
+                                ).strip()
+                                
+                                # Limpiar posibles comillas o puntuación extra
+                                short_name = short_name.strip('"\'.,!?').strip()
+                                
+                                if short_name and len(short_name) > 0:
+                                    scene_name = short_name
+                                    print(f"[schat] Nom generat: {scene_name}")
+                                else:
+                                    print(f"[schat] No s'ha generat nom, usant fallback")
+                        except Exception as e_schat:
+                            print(f"Error generando nombre con schat: {e_schat}")
+                            # Mantener el nombre de svision si schat falla
+                            
                 except Exception as e:
                     print(f"Error describiendo {scene_id}: {e}")
         

face_classifier.py

@@ -48,6 +48,7 @@ def validate_and_classify_face(image_path: str) -> Optional[Dict[str, Any]]:
         
         # DeepFace pot retornar llista si detecta múltiples cares
         if isinstance(result, list):
+            logger.info(f"[DeepFace] Resultado es lista con {len(result)} elementos")
             result = result[0] if result else None
         
         if not result:
@@ -61,39 +62,55 @@ def validate_and_classify_face(image_path: str) -> Optional[Dict[str, Any]]:
                 'woman_prob': 0.0
             }
         
+        # LOG: Ver estructura completa del resultado
+        logger.info(f"[DeepFace] Resultado completo de analyze: {result}")
+        
         # Extreure informació de gènere
         gender_info = result.get('gender', {})
+        logger.info(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
+            logger.info(f"[DeepFace] Extraído de dict - Man: {man_prob:.3f}, Woman: {woman_prob:.3f}")
         else:
             # Fallback si el format és diferent
+            logger.warning(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)
         
+        logger.info(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
+            logger.info(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)
+            logger.info(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 directament, però si va retornar resultat
-        # assumim que és cara vàlida amb confiança alta
-        face_confidence = result.get('face_confidence', 0.9)  # Default alt si detecta
+        # 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
         
-        logger.info(f"[DeepFace] Resultat: gender={gender}, confidence={gender_confidence:.2f}, "
-              f"man={man_prob:.2f}, woman={woman_prob:.2f}")
+        logger.info(f"[DeepFace] ===== RESUMEN FINAL =====")
+        logger.info(f"[DeepFace]   is_valid_face: {is_valid_face}")
+        logger.info(f"[DeepFace]   face_confidence: {face_confidence:.3f}")
+        logger.info(f"[DeepFace]   gender: {gender}")
+        logger.info(f"[DeepFace]   gender_confidence: {gender_confidence:.3f}")
+        logger.info(f"[DeepFace]   man_prob: {man_prob:.3f}")
+        logger.info(f"[DeepFace]   woman_prob: {woman_prob:.3f}")
+        logger.info(f"[DeepFace] ==========================")
         
         return {
             'is_valid_face': is_valid_face,