Upload api.py

api.py

@@ -154,9 +154,9 @@ def normalize_face_lighting(image):
     normalized = cv2.cvtColor(lab_normalized, cv2.COLOR_LAB2BGR)
     return normalized
 
-def hierarchical_cluster_with_min_size(X, max_groups: int, min_cluster_size: int):
+def hierarchical_cluster_with_min_size(X, max_groups: int, min_cluster_size: int, sensitivity: float = 0.5) -> np.ndarray:
     """
-    Clustering jerárquico aglomerativo con selección óptima del número de clusters.
+    Clustering jerárquico con silhouette score para encontrar automáticamente el mejor número de clusters.
     Selecciona automáticamente el mejor número de clusters (hasta max_groups) usando silhouette score.
     Filtra clusters con menos de min_cluster_size muestras (marcados como -1/ruido).
     
@@ -164,6 +164,10 @@ def hierarchical_cluster_with_min_size(X, max_groups: int, min_cluster_size: int
         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
+        sensitivity: Sensibilidad del clustering (0.0-1.0)
+                    - 0.0 = muy agresivo (menos clusters)
+                    - 0.5 = balanceado (recomendado)
+                    - 1.0 = muy permisivo (más clusters)
         
     Returns:
         Array de labels (N,) donde -1 indica ruido
@@ -203,10 +207,12 @@ def hierarchical_cluster_with_min_size(X, max_groups: int, min_cluster_size: int
             if valid_clusters >= 2:
                 try:
                     score = silhouette_score(X, trial_labels, metric='cosine')
-                    # Penalizar configuraciones con muchos clusters para evitar overfitting
-                    # Penalización MUY fuerte para reducir duplicados de la misma persona
-                    # Valores: 0.05 = fuerte, 0.07 = muy fuerte, 0.10 = extremo
-                    adjusted_score = score - (n_clusters * 0.07)
+                    # Penalización dinámica basada en sensibilidad:
+                    # - sensitivity=0.0 → penalty=0.14 (muy agresivo, menos clusters)
+                    # - sensitivity=0.5 → penalty=0.07 (balanceado, recomendado)
+                    # - sensitivity=1.0 → penalty=0.01 (permisivo, más clusters)
+                    penalty = 0.14 - (sensitivity * 0.13)
+                    adjusted_score = score - (n_clusters * penalty)
                     
                     if adjusted_score > best_score:
                         best_score = adjusted_score
@@ -215,7 +221,8 @@ def hierarchical_cluster_with_min_size(X, max_groups: int, min_cluster_size: int
                     pass  # Si falla el cálculo, ignorar esta configuración
     
     # Usar el número óptimo de clusters encontrado
-    print(f"Clustering óptimo: {best_n_clusters} clusters (de máximo {max_groups}), silhouette score: {best_score:.3f}")
+    penalty = 0.14 - (sensitivity * 0.13)
+    print(f"Clustering óptimo: {best_n_clusters} clusters (de máximo {max_groups}), sensitivity={sensitivity:.2f}, penalty={penalty:.3f}, silhouette={best_score:.3f}")
     labels = fcluster(Z, t=best_n_clusters, criterion='maxclust')
     
     # fcluster devuelve labels 1-indexed, convertir a 0-indexed
@@ -255,8 +262,10 @@ async def create_initial_casting(
     video: UploadFile = File(...),
     max_groups: int = Form(default=3),
     min_cluster_size: int = Form(default=3),
+    face_sensitivity: float = Form(default=0.5),
     voice_max_groups: int = Form(default=3),
     voice_min_cluster_size: int = Form(default=3),
+    voice_sensitivity: float = Form(default=0.5),
     max_frames: int = Form(default=100),
 ):
     """
@@ -280,8 +289,10 @@ async def create_initial_casting(
         "video_name": video_name,
         "max_groups": int(max_groups),
         "min_cluster_size": int(min_cluster_size),
+        "face_sensitivity": float(face_sensitivity),
         "voice_max_groups": int(voice_max_groups),
         "voice_min_cluster_size": int(voice_min_cluster_size),
+        "voice_sensitivity": float(voice_sensitivity),
         "max_frames": int(max_frames),
         "created_at": datetime.now().isoformat(),
         "results": None,
@@ -358,8 +369,10 @@ def process_video_job(job_id: str):
         video_name = job["video_name"]
         max_groups = int(job.get("max_groups", 5))
         min_cluster_size = int(job.get("min_cluster_size", 3))
+        face_sensitivity = float(job.get("face_sensitivity", 0.5))
         v_max_groups = int(job.get("voice_max_groups", 5))
         v_min_cluster = int(job.get("voice_min_cluster_size", 3))
+        voice_sensitivity = float(job.get("voice_sensitivity", 0.5))
         
         # Crear estructura de carpetas
         base = TEMP_ROOT / video_name
@@ -521,7 +534,7 @@ def process_video_job(job_id: str):
             # Clustering jerárquico de caras
             if embeddings:
                 Xf = np.array(embeddings)
-                labels = hierarchical_cluster_with_min_size(Xf, max_groups, min_cluster_size).tolist()
+                labels = hierarchical_cluster_with_min_size(Xf, max_groups, min_cluster_size, face_sensitivity).tolist()
                 print(f"[{job_id}] Clustering jerárquico de caras: {len(set([l for l in labels if l >= 0]))} clusters")
             else:
                 labels = []
@@ -781,7 +794,7 @@ def process_video_job(job_id: str):
             if voice_embeddings:
                 try:
                     Xv = np.array(voice_embeddings)
-                    v_labels = hierarchical_cluster_with_min_size(Xv, v_max_groups, v_min_cluster).tolist()
+                    v_labels = hierarchical_cluster_with_min_size(Xv, v_max_groups, v_min_cluster, voice_sensitivity).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}")
@@ -994,6 +1007,7 @@ async def detect_scenes(
     video: UploadFile = File(...),
     max_groups: int = Form(default=3),
     min_cluster_size: int = Form(default=3),
+    scene_sensitivity: float = Form(default=0.5),
     frame_interval_sec: float = Form(default=0.5),
 ):
     """
@@ -1045,7 +1059,7 @@ async def detect_scenes(
         return {"scene_clusters": []}
 
     X = np.array(frames)
-    labels = hierarchical_cluster_with_min_size(X, max_groups, min_cluster_size).tolist()
+    labels = hierarchical_cluster_with_min_size(X, max_groups, min_cluster_size, scene_sensitivity).tolist()
     initial_clusters = len(set([l for l in labels if l >= 0]))
     print(f"Scene clustering jeràrquic inicial: {initial_clusters} clusters")