Upload 5 files

api.py

@@ -49,6 +49,50 @@ class JobStatus(str, Enum):
 
 jobs: Dict[str, dict] = {}
 
+def hierarchical_cluster_with_min_size(X, max_groups: int, min_cluster_size: int):
+    """
+    Clustering jerárquico aglomerativo que produce hasta max_groups clusters.
+    Filtra clusters con menos de min_cluster_size muestras (marcados como -1/ruido).
+    
+    Args:
+        X: Array de embeddings (N, D)
+        max_groups: Número máximo de clusters a formar
+        min_cluster_size: Tamaño mínimo de cluster válido
+        
+    Returns:
+        Array de labels (N,) donde -1 indica ruido
+    """
+    import numpy as np
+    from scipy.cluster.hierarchy import linkage, fcluster
+    from collections import Counter
+    
+    if len(X) == 0:
+        return np.array([])
+    
+    if len(X) < min_cluster_size:
+        # Si hay menos muestras que el mínimo, todo es ruido
+        return np.full(len(X), -1, dtype=int)
+    
+    # Linkage usando distancia euclidiana con método 'ward'
+    Z = linkage(X, method='ward', metric='euclidean')
+    
+    # Cortar el dendrograma en max_groups clusters
+    labels = fcluster(Z, t=max_groups, criterion='maxclust')
+    
+    # fcluster devuelve labels 1-indexed, convertir a 0-indexed
+    labels = labels - 1
+    
+    # Filtrar clusters pequeños
+    label_counts = Counter(labels)
+    filtered_labels = []
+    for lbl in labels:
+        if label_counts[lbl] >= min_cluster_size:
+            filtered_labels.append(lbl)
+        else:
+            filtered_labels.append(-1)  # Ruido
+    
+    return np.array(filtered_labels, dtype=int)
+
 @app.get("/")
 def root():
     return {"ok": True, "service": "veureu-engine"}
@@ -70,14 +114,14 @@ async def process_video(
 async def create_initial_casting(
     background_tasks: BackgroundTasks,
     video: UploadFile = File(...),
-    epsilon: float = Form(...),
-    min_cluster_size: int = Form(...),
-    voice_epsilon: float = Form(0.5),
-    voice_min_cluster_size: int = Form(2),
+    max_groups: int = Form(5),
+    min_cluster_size: int = Form(3),
+    voice_max_groups: int = Form(5),
+    voice_min_cluster_size: int = Form(3),
     max_frames: int = Form(100),
 ):
     """
-    Crea un job para procesar el vídeo de forma asíncrona.
+    Crea un job para procesar el vídeo de forma asíncrona usando clustering jerárquico.
     Devuelve un job_id inmediatamente.
     """
     # Guardar vídeo en carpeta de datos
@@ -95,9 +139,9 @@ async def create_initial_casting(
         "status": JobStatus.QUEUED,
         "video_path": str(dst_video),
         "video_name": video_name,
-        "epsilon": float(epsilon),
+        "max_groups": int(max_groups),
         "min_cluster_size": int(min_cluster_size),
-        "voice_epsilon": float(voice_epsilon),
+        "voice_max_groups": int(voice_max_groups),
         "voice_min_cluster_size": int(voice_min_cluster_size),
         "max_frames": int(max_frames),
         "created_at": datetime.now().isoformat(),
@@ -173,10 +217,10 @@ def process_video_job(job_id: str):
         
         video_path = job["video_path"]
         video_name = job["video_name"]
-        epsilon = job["epsilon"]
-        min_cluster_size = job["min_cluster_size"]
-        v_epsilon = float(job.get("voice_epsilon", epsilon))
-        v_min_cluster = int(job.get("voice_min_cluster_size", min_cluster_size))
+        max_groups = int(job.get("max_groups", 5))
+        min_cluster_size = int(job.get("min_cluster_size", 3))
+        v_max_groups = int(job.get("voice_max_groups", 5))
+        v_min_cluster = int(job.get("voice_min_cluster_size", 3))
         
         # Crear estructura de carpetas
         base = TEMP_ROOT / video_name
@@ -328,13 +372,11 @@ def process_video_job(job_id: str):
             print(f"[{job_id}] ✓ Frames con caras: {frames_with_faces}")
             print(f"[{job_id}] ✓ Caras detectadas (embeddings): {len(embeddings)}")
 
-            # Clustering DBSCAN de caras como en 'originales'
-            from sklearn.cluster import DBSCAN
+            # Clustering jerárquico de caras
             if embeddings:
                 Xf = np.array(embeddings)
-                f_eps = float(epsilon)
-                f_min = max(1, int(min_cluster_size))
-                labels = DBSCAN(eps=f_eps, min_samples=f_min, metric='euclidean').fit(Xf).labels_.tolist()
+                labels = hierarchical_cluster_with_min_size(Xf, max_groups, min_cluster_size).tolist()
+                print(f"[{job_id}] Clustering jerárquico de caras: {len(set([l for l in labels if l >= 0]))} clusters")
             else:
                 labels = []
 
@@ -472,16 +514,14 @@ def process_video_job(job_id: str):
                 except Exception as _efb:
                     print(f"[{job_id}] WARN - Audio minimal fallback failed: {_efb}")
 
-            # Clustering de voces (DBSCAN sobre embeddings válidos)
-            from sklearn.cluster import DBSCAN
+            # Clustering jerárquico de voces sobre embeddings válidos
             import numpy as np
             voice_embeddings = [seg.get("voice_embedding") for seg in audio_segments if seg.get("voice_embedding")]
             if voice_embeddings:
                 try:
                     Xv = np.array(voice_embeddings)
-                    v_eps = float(v_epsilon)
-                    v_min = max(1, int(v_min_cluster))
-                    v_labels = DBSCAN(eps=v_eps, min_samples=v_min, metric='euclidean').fit(Xv).labels_.tolist()
+                    v_labels = hierarchical_cluster_with_min_size(Xv, v_max_groups, v_min_cluster).tolist()
+                    print(f"[{job_id}] Clustering jerárquico de voz: {len(set([l for l in v_labels if l >= 0]))} clusters")
                 except Exception as _e:
                     print(f"[{job_id}] WARN - Voice clustering failed: {_e}")
                     v_labels = []
@@ -686,17 +726,16 @@ def serve_scene_file(video_name: str, scene_id: str, filename: str):
 @app.post("/detect_scenes")
 async def detect_scenes(
     video: UploadFile = File(...),
-    epsilon: float = Form(0.5),
-    min_cluster_size: int = Form(2),
+    max_groups: int = Form(5),
+    min_cluster_size: int = Form(3),
     frame_interval_sec: float = Form(0.5),
 ):
     """
-    Detecta clústers d'escenes mitjançant clustering de histogrames de color.
+    Detecta clústers d'escenes mitjançant clustering jeràrquic d'histogrames de color.
     Retorna una llista de scene_clusters estructurada de forma similar a characters.
     """
     import cv2
     import numpy as np
-    from sklearn.cluster import DBSCAN
 
     # Guardar el vídeo temporalment
     video_name = Path(video.filename).stem
@@ -740,7 +779,8 @@ async def detect_scenes(
         return {"scene_clusters": []}
 
     X = np.array(frames)
-    labels = DBSCAN(eps=float(epsilon), min_samples=int(min_cluster_size), metric='euclidean').fit(X).labels_.tolist()
+    labels = hierarchical_cluster_with_min_size(X, max_groups, min_cluster_size).tolist()
+    print(f"Scene clustering jeràrquic: {len(set([l for l in labels if l >= 0]))} clusters")
 
     # Agrupar per etiqueta (>=0)
     clusters = {}

character_detection.py

@@ -3,7 +3,7 @@ Character Detection Module
 Integra el trabajo de Ana para detección de personajes mediante:
 1. Extracción de caras y embeddings
 2. Extracción de voces y embeddings
-3. Clustering con DBSCAN
+3. Clustering jerárquico aglomerativo
 4. Generación de carpetas por personaje
 """
 import cv2
@@ -12,8 +12,9 @@ import json
 import logging
 import shutil
 from pathlib import Path
-from sklearn.cluster import DBSCAN
 import numpy as np
+from scipy.cluster.hierarchy import linkage, fcluster
+from collections import Counter
 from typing import List, Dict, Any, Tuple
 
 # Imports de las herramientas de vision y audio desde los módulos de la raíz
@@ -171,30 +172,43 @@ class CharacterDetector:
         logger.info("Extracción de escenas deshabilitada temporalmente")
         return []
     
-    def cluster_faces(self, embeddings_caras: List[Dict], epsilon: float, min_samples: int) -> np.ndarray:
+    def cluster_faces(self, embeddings_caras: List[Dict], max_groups: int, min_samples: int) -> np.ndarray:
         """
-        Agrupa caras similares usando DBSCAN.
-        Basado en get_face_clusters de Ana.
+        Agrupa caras similares usando clustering jerárquico aglomerativo.
         
         Args:
             embeddings_caras: Lista de embeddings de caras
-            epsilon: Parámetro eps de DBSCAN
-            min_samples: Parámetro min_samples de DBSCAN
+            max_groups: Número máximo de clusters a formar
+            min_samples: Tamaño mínimo de cluster válido
         
         Returns:
-            Array de labels (cluster asignado a cada cara)
+            Array de labels (cluster asignado a cada cara, -1 para ruido)
         """
         if not embeddings_caras:
             return np.array([])
         
-        logger.info(f"Clustering {len(embeddings_caras)} caras con eps={epsilon}, min_samples={min_samples}")
+        logger.info(f"Clustering {len(embeddings_caras)} caras con max_groups={max_groups}, min_samples={min_samples}")
         
         # Extraer solo los embeddings
         X = np.array([cara['embeddings'] for cara in embeddings_caras])
         
-        # DBSCAN clustering
-        clustering = DBSCAN(eps=epsilon, min_samples=min_samples, metric='euclidean').fit(X)
-        labels = clustering.labels_
+        if len(X) < min_samples:
+            # Si hay menos muestras que el mínimo, todo es ruido
+            return np.full(len(X), -1, dtype=int)
+        
+        # Clustering jerárquico con método ward
+        Z = linkage(X, method='ward', metric='euclidean')
+        labels = fcluster(Z, t=max_groups, criterion='maxclust') - 1  # 0-indexed
+        
+        # Filtrar clusters pequeños
+        label_counts = Counter(labels)
+        filtered_labels = []
+        for lbl in labels:
+            if label_counts[lbl] >= min_samples:
+                filtered_labels.append(lbl)
+            else:
+                filtered_labels.append(-1)
+        labels = np.array(filtered_labels, dtype=int)
         
         # Contar clusters (excluyendo ruido -1)
         n_clusters = len(set(labels)) - (1 if -1 in labels else 0)
@@ -289,13 +303,13 @@ class CharacterDetector:
         
         return analysis_path
     
-    def detect_characters(self, epsilon: float = 0.5, min_cluster_size: int = 2,
+    def detect_characters(self, max_groups: int = 5, min_cluster_size: int = 3,
                           *, start_offset_sec: float = 3.0, extract_every_sec: float = 0.5) -> Tuple[List[Dict], Path, np.ndarray, List[Dict[str, Any]]]:
         """
-        Pipeline completo de detección de personajes.
+        Pipeline completo de detección de personajes con clustering jerárquico.
         
         Args:
-            epsilon: Parámetro epsilon para DBSCAN
+            max_groups: Número máximo de clusters a formar
             min_cluster_size: Tamaño mínimo de cluster
         
         Returns:
@@ -314,7 +328,7 @@ class CharacterDetector:
         analysis_path = self.save_analysis_json(embeddings_caras, embeddings_voices, embeddings_escenas)
         
         # 5. Clustering de caras
-        labels = self.cluster_faces(embeddings_caras, epsilon, min_cluster_size)
+        labels = self.cluster_faces(embeddings_caras, max_groups, min_cluster_size)
         
         # 6. Crear carpetas de personajes
         characters = self.create_character_folders(embeddings_caras, labels)
@@ -324,16 +338,16 @@ class CharacterDetector:
 
 # Función de conveniencia para usar en el API
 def detect_characters_from_video(video_path: str, output_base: str, 
-                                 epsilon: float = 0.5, min_cluster_size: int = 2,
+                                 max_groups: int = 5, min_cluster_size: int = 3,
                                  video_name: str = None,
                                  *, start_offset_sec: float = 3.0, extract_every_sec: float = 0.5) -> Dict[str, Any]:
     """
-    Función de alto nivel para detectar personajes en un vídeo.
+    Función de alto nivel para detectar personajes en un vídeo usando clustering jerárquico.
     
     Args:
         video_path: Ruta al vídeo
         output_base: Directorio base para guardar resultados
-        epsilon: Parámetro epsilon para DBSCAN
+        max_groups: Número máximo de clusters a formar
         min_cluster_size: Tamaño mínimo de cluster
         video_name: Nombre del vídeo (para construir URLs)
     
@@ -341,7 +355,7 @@ def detect_characters_from_video(video_path: str, output_base: str,
         Dict con resultados: {"characters": [...], "analysis_path": "..."}
     """
     detector = CharacterDetector(video_path, Path(output_base), video_name=video_name)
-    characters, analysis_path, labels, embeddings_caras = detector.detect_characters(epsilon, min_cluster_size,
+    characters, analysis_path, labels, embeddings_caras = detector.detect_characters(max_groups, min_cluster_size,
                                                                                     start_offset_sec=start_offset_sec,
                                                                                     extract_every_sec=extract_every_sec)