Upload 2 files

api.py

@@ -51,8 +51,12 @@ jobs: Dict[str, dict] = {}
 
 def normalize_face_lighting(image):
     """
-    Normaliza el brillo de una imagen de cara usando CLAHE.
-    Esto reduce el impacto de diferentes condiciones de iluminación en los embeddings.
+    Normaliza el brillo de una imagen de cara usando técnicas combinadas:
+    1. CLAHE para ecualización adaptativa
+    2. Normalización de rango para homogeneizar brillo general
+    
+    Esto reduce el impacto de diferentes condiciones de iluminación en los embeddings
+    y en la visualización de las imágenes.
     
     Args:
         image: Imagen BGR (OpenCV format)
@@ -61,13 +65,28 @@ def normalize_face_lighting(image):
         Imagen normalizada en el mismo formato
     """
     import cv2
-    # Convertir a LAB color space (más robusto para iluminación)
+    import numpy as np
+    
+    # Paso 1: Convertir a LAB color space (más robusto para iluminación)
     lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
     l, a, b = cv2.split(lab)
     
-    # Aplicar CLAHE (Contrast Limited Adaptive Histogram Equalization) al canal L
-    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
-    l_normalized = clahe.apply(l)
+    # Paso 2: Aplicar CLAHE (Contrast Limited Adaptive Histogram Equalization) al canal L
+    # Usar clipLimit más alto para normalización más agresiva
+    clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8, 8))
+    l_clahe = clahe.apply(l)
+    
+    # Paso 3: Normalizar el rango del canal L para asegurar distribución uniforme
+    # Esto garantiza que todas las imágenes tengan un rango de brillo similar
+    l_min, l_max = l_clahe.min(), l_clahe.max()
+    if l_max > l_min:
+        # Estirar el histograma al rango completo [0, 255]
+        l_normalized = ((l_clahe - l_min) * 255.0 / (l_max - l_min)).astype(np.uint8)
+    else:
+        l_normalized = l_clahe
+    
+    # Paso 4: Aplicar suavizado suave para reducir ruido introducido por la normalización
+    l_normalized = cv2.GaussianBlur(l_normalized, (3, 3), 0)
     
     # Recombinar canales
     lab_normalized = cv2.merge([l_normalized, a, b])
@@ -78,7 +97,8 @@ def normalize_face_lighting(image):
 
 def hierarchical_cluster_with_min_size(X, max_groups: int, min_cluster_size: int):
     """
-    Clustering jerárquico aglomerativo que produce hasta max_groups clusters.
+    Clustering jerárquico aglomerativo con selección óptima del 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).
     
     Args:
@@ -91,6 +111,7 @@ def hierarchical_cluster_with_min_size(X, max_groups: int, min_cluster_size: int
     """
     import numpy as np
     from scipy.cluster.hierarchy import linkage, fcluster
+    from sklearn.metrics import silhouette_score
     from collections import Counter
     
     if len(X) == 0:
@@ -103,8 +124,37 @@ def hierarchical_cluster_with_min_size(X, max_groups: int, min_cluster_size: 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')
+    # Encontrar el número óptimo de clusters usando silhouette score
+    best_n_clusters = 2
+    best_score = -1
+    
+    # Probar diferentes números de clusters (de 2 a max_groups)
+    max_to_try = min(max_groups, len(X) - 1)  # No puede haber más clusters que muestras
+    
+    if max_to_try >= 2:
+        for n_clusters in range(2, max_to_try + 1):
+            trial_labels = fcluster(Z, t=n_clusters, criterion='maxclust') - 1
+            
+            # Calcular cuántos clusters válidos tendríamos después del filtrado
+            trial_counts = Counter(trial_labels)
+            valid_clusters = sum(1 for count in trial_counts.values() if count >= min_cluster_size)
+            
+            # Solo evaluar si hay al menos 2 clusters válidos
+            if valid_clusters >= 2:
+                try:
+                    score = silhouette_score(X, trial_labels, metric='euclidean')
+                    # Penalizar ligeramente configuraciones con muchos clusters para evitar overfitting
+                    adjusted_score = score - (n_clusters * 0.01)
+                    
+                    if adjusted_score > best_score:
+                        best_score = adjusted_score
+                        best_n_clusters = n_clusters
+                except:
+                    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}")
+    labels = fcluster(Z, t=best_n_clusters, criterion='maxclust')
     
     # fcluster devuelve labels 1-indexed, convertir a 0-indexed
     labels = labels - 1
@@ -258,7 +308,11 @@ def process_video_job(job_id: str):
         # Detección de caras y embeddings (CPU), alineado con 'originales'
         try:
             print(f"[{job_id}] Iniciando detección de personajes (CPU, originales)...")
-            print(f"[{job_id}] Normalización de brillo activada (CLAHE) para reducir impacto de iluminación")
+            print(f"[{job_id}] *** Normalización de brillo ACTIVADA ***")
+            print(f"[{job_id}]   - CLAHE adaptativo (clipLimit=3.0)")
+            print(f"[{job_id}]   - Estiramiento de histograma")
+            print(f"[{job_id}]   - Suavizado Gaussiano")
+            print(f"[{job_id}]   Esto homogeneizará el brillo de todas las caras detectadas")
             import cv2
             import numpy as np
             try:

character_detection.py

@@ -174,7 +174,8 @@ class CharacterDetector:
     
     def cluster_faces(self, embeddings_caras: List[Dict], max_groups: int, min_samples: int) -> np.ndarray:
         """
-        Agrupa caras similares usando clustering jerárquico aglomerativo.
+        Agrupa caras similares usando clustering jerárquico aglomerativo con selección óptima.
+        Selecciona automáticamente el mejor número de clusters usando silhouette score.
         
         Args:
             embeddings_caras: Lista de embeddings de caras
@@ -196,9 +197,36 @@ class CharacterDetector:
             # 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
+        # Linkage usando distancia euclidiana con método 'ward'
         Z = linkage(X, method='ward', metric='euclidean')
-        labels = fcluster(Z, t=max_groups, criterion='maxclust') - 1  # 0-indexed
+        
+        # Encontrar el número óptimo de clusters usando silhouette score
+        from sklearn.metrics import silhouette_score
+        best_n_clusters = 2
+        best_score = -1
+        
+        max_to_try = min(max_groups, len(X) - 1)
+        
+        if max_to_try >= 2:
+            for n_clusters in range(2, max_to_try + 1):
+                trial_labels = fcluster(Z, t=n_clusters, criterion='maxclust') - 1
+                
+                trial_counts = Counter(trial_labels)
+                valid_clusters = sum(1 for count in trial_counts.values() if count >= min_samples)
+                
+                if valid_clusters >= 2:
+                    try:
+                        score = silhouette_score(X, trial_labels, metric='euclidean')
+                        adjusted_score = score - (n_clusters * 0.01)
+                        
+                        if adjusted_score > best_score:
+                            best_score = adjusted_score
+                            best_n_clusters = n_clusters
+                    except:
+                        pass
+        
+        logger.info(f"Clustering óptimo: {best_n_clusters} clusters (de máximo {max_groups}), silhouette: {best_score:.3f}")
+        labels = fcluster(Z, t=best_n_clusters, criterion='maxclust') - 1
         
         # Filtrar clusters pequeños
         label_counts = Counter(labels)
@@ -214,7 +242,7 @@ class CharacterDetector:
         n_clusters = len(set(labels)) - (1 if -1 in labels else 0)
         n_noise = list(labels).count(-1)
         
-        logger.info(f"Clusters encontrados: {n_clusters}, Ruido: {n_noise}")
+        logger.info(f"Clusters válidos encontrados: {n_clusters}, Ruido: {n_noise}")
         return labels
     
     def create_character_folders(self, embeddings_caras: List[Dict], labels: np.ndarray) -> List[Dict[str, Any]]: