Update preprocessing_router.py

preprocessing_router.py

@@ -21,6 +21,9 @@ from storage.media_routers import upload_video
 import svision_client
 import asr_client
 
+from sklearn.cluster import KMeans
+from sklearn.neighbors import KNeighborsClassifier
+
 
 ROOT = Path("/tmp/veureu")
 ROOT.mkdir(parents=True, exist_ok=True)
@@ -890,22 +893,74 @@ def process_video_job(job_id: str):
                 print(f"[{job_id}] \u2713 {len(audio_segments)} segmentos de audio procesados")
                 
                 # Cluster voice embeddings
-                print(voice_embeddings)
                 if voice_embeddings:
-                    print(f"[{job_id}] Clustering jer\u00e1rquico de voz...")
-                    print(f"[{job_id}]   - voice_embeddings: {len(voice_embeddings)} embeddings")
-                    print(f"[{job_id}]   - par\u00e1metros: voice_max_groups={voice_max_groups}, voice_min_cluster_size={voice_min_cluster_size}")
+                    print(f"[{job_id}] Clustering KMeans+KNN de voz (forzado)...")
+                    print(f"[{job_id}]   - voice_embeddings: {len(voice_embeddings)}")
+                    print(f"[{job_id}]   - parámetros: grupos={voice_max_groups}, max_por_cluster={voice_min_cluster_size}")
+                
+                    # ------------------------------
+                    # NORMALIZAR EMBEDDINGS
+                    # ------------------------------
                     Xv = np.array(voice_embeddings)
                     Xv = Xv / np.linalg.norm(Xv, axis=1, keepdims=True)
-                    print(f"[{job_id}]   - shape Xv: {Xv.shape}")
-                    voice_labels = hierarchical_cluster_with_min_size(
-                        Xv, voice_max_groups, voice_min_cluster_size, voice_sensitivity
-                    ).tolist()
-                    n_voice_clusters = len(set([l for l in voice_labels if l >= 0]))
-                    print(f"[{job_id}]   - voice_labels: {voice_labels}")
-                    print(f"[{job_id}] \u2713 Clustering de voz: {n_voice_clusters} clusters de {len(voice_embeddings)} muestras")
-                else:
-                    print(f"[{job_id}] \u26a0\ufe0f No hay voice_embeddings para clustering")
+                
+                    N = len(Xv)
+                    K = max(1, voice_max_groups)   # número mínimo de clusters
+                    MAX_PER_CLUSTER = max(1, voice_min_cluster_size)
+                
+                    # ------------------------------
+                    # STEP 1: KMEANS FORZADO
+                    # ------------------------------
+                    from sklearn.cluster import KMeans
+                
+                    km = KMeans(n_clusters=K, n_init=10, random_state=42)
+                    labels = km.fit_predict(Xv)
+                
+                    print(f"[{job_id}]   - Inicial: {labels.tolist()}")
+                
+                    # ------------------------------
+                    # STEP 2: REBALANCEO CON KNN SI HAY CLUSTERS SOBRECARGADOS
+                    # ------------------------------
+                    from sklearn.neighbors import KNeighborsClassifier
+                
+                    for iteration in range(10):  # máximo 10 ajustes
+                        sizes = {c: np.sum(labels == c) for c in range(K)}
+                        bad_clusters = [c for c, s in sizes.items() if s > MAX_PER_CLUSTER]
+                
+                        print(f"[{job_id}]   - Iter {iteration}: tamaños={sizes}")
+                
+                        if not bad_clusters:
+                            break  # Todo OK, ningún cluster supera el límite
+                
+                        # Entrenar KNN usando SOLO clusters válidos
+                        good_indices = []
+                        for c in range(K):
+                            idx = np.where(labels == c)[0]
+                            if len(idx) <= MAX_PER_CLUSTER:
+                                good_indices.extend(idx)
+                
+                        if len(good_indices) == 0:
+                            print(f"[{job_id}]   - No hay clusters válidos para KNN, abortando rebalanceo.")
+                            break
+                
+                        knn = KNeighborsClassifier(n_neighbors=min(3, len(good_indices)))
+                        knn.fit(Xv[good_indices], labels[good_indices])
+                
+                        # Reasignar elementos excedentes
+                        for c in bad_clusters:
+                            idx = np.where(labels == c)[0]
+                            excess = idx[MAX_PER_CLUSTER:]  # los que sobran
+                
+                            for i in excess:
+                                new_lab = knn.predict([Xv[i]])[0]
+                                labels[i] = new_lab
+                
+                    voice_labels = labels.tolist()
+                    n_voice_clusters = len(set(voice_labels))
+                
+                    print(f"[{job_id}]   - Final voice_labels: {voice_labels}")
+                    print(f"[{job_id}] ✓ Clustering voz final: {n_voice_clusters} clusters")
+
                 
                 diarization_info = {
                     "num_segments": len(audio_segments),