Update app.py

app.py

@@ -1,6 +1,6 @@
 # ==============================================================================
-#  API de Análise de Textos com FastAPI — VERSÃO PROFISSIONAL
-#  Totalmente reescrita para estabilidade, paralelismo seguro e isolamento.
+#  API do AetherMap — VERSÃO IMPERIAL 3.0
+#  Backend aprimorado com análises por cluster e dados para gráficos detalhados.
 # ==============================================================================
 
 import numpy as np
@@ -28,6 +28,7 @@ BATCH_SIZE = 256
 UMAP_N_NEIGHBORS = 30
 HDBSCAN_MIN_SIZE = 50
 
+# Lista de stopwords expandida e mantida
 STOP_WORDS_PT = [
     'de','a','o','que','e','do','da','em','um','para','é','com','não','uma','os','no',
     'se','na','por','mais','as','dos','como','mas','foi','ao','ele','das','tem','à',
@@ -54,205 +55,176 @@ STOP_WORDS_PT = [
 ]
 
 # ==============================================================================
-# MODELO — Carregado uma vez e reaproveitado (seguro e imutável)
+# MODELO — Carregado uma vez e reaproveitado
 # ==============================================================================
-
 @lru_cache(maxsize=1)
 def load_model():
     device = "cuda" if torch.cuda.is_available() else "cpu"
     print(f"[MODEL] Carregando modelo '{DEFAULT_MODEL}' em: {device}")
     return SentenceTransformer(DEFAULT_MODEL, device=device)
 
-
 # ==============================================================================
-# FUNÇÃO: Preparar textos
+# FUNÇÕES AUXILIARES DE ANÁLISE (Isoladas e reutilizáveis)
 # ==============================================================================
-
 def preparar_textos(file_bytes: bytes, n_samples: int) -> List[str]:
     linhas = file_bytes.decode("utf-8", errors="ignore").splitlines()
     textos = [s for line in linhas if (s := line.strip()) and len(s.split()) > 3]
     return textos[:n_samples]
 
-
-# ==============================================================================
-# FUNÇÃO: Pipeline principal (um por requisição, seguro)
-# ==============================================================================
-
 def processar_pipeline(textos: List[str]) -> (pd.DataFrame, np.ndarray):
     print(f"[PIPELINE] Iniciando pipeline para {len(textos)} textos...")
-
     model = load_model()
-
-    # Embeddings
-    print("[PIPELINE] Gerando embeddings...")
-    embeddings = model.encode(
-        textos,
-        batch_size=BATCH_SIZE,
-        show_progress_bar=False,
-        convert_to_numpy=True
-    )
-
-    # UMAP
-    print("[PIPELINE] Reduzindo dimensionalidade com UMAP...")
-    reducer = umap.UMAP(
-        n_components=3,
-        n_neighbors=UMAP_N_NEIGHBORS,
-        min_dist=0.0,
-        metric="cosine",
-        random_state=42
-    )
+    embeddings = model.encode(textos, batch_size=BATCH_SIZE, show_progress_bar=False, convert_to_numpy=True)
+    
+    reducer = umap.UMAP(n_components=3, n_neighbors=UMAP_N_NEIGHBORS, min_dist=0.0, metric="cosine", random_state=42)
     emb_3d = reducer.fit_transform(embeddings)
-
-    # Normalize
     emb_3d = StandardScaler().fit_transform(emb_3d)
-
-    # HDBSCAN
-    print("[PIPELINE] Clusterizando com HDBSCAN...")
+    
     clusterer = hdbscan.HDBSCAN(min_cluster_size=HDBSCAN_MIN_SIZE)
     clusters = clusterer.fit_predict(emb_3d)
-
+    
     df = pd.DataFrame({
-        "x": emb_3d[:, 0],
-        "y": emb_3d[:, 1],
-        "z": emb_3d[:, 2],
-        "full_text": textos,
-        "cluster": clusters.astype(str)
+        "x": emb_3d[:, 0], "y": emb_3d[:, 1], "z": emb_3d[:, 2],
+        "full_text": textos, "cluster": clusters.astype(str)
     })
-
-    del reducer, clusterer, emb_3d
-    gc.collect()
-
+    
+    del reducer, clusterer, emb_3d; gc.collect()
     return df, embeddings
 
-
-# ==============================================================================
-# FUNÇÃO: Métricas globais do corpus
-# ==============================================================================
-
+# <<< MODIFICAÇÃO >>> Retorna dados para gráficos
 def calcular_metricas(textos: List[str]) -> Dict[str, Any]:
     print("[METRICAS] Calculando métricas globais...")
+    if not textos: return {}
 
-    # Riqueza lexical
+    vectorizer_count = CountVectorizer(stop_words=STOP_WORDS_PT, max_features=20000)
+    vectorizer_tfidf = TfidfVectorizer(stop_words=STOP_WORDS_PT, max_features=20000)
+    
     try:
-        vectorizer_count = CountVectorizer(stop_words=STOP_WORDS_PT, max_features=20000)
-        vectorizer_count.fit(textos)
-        riqueza = len(vectorizer_count.get_feature_names_out())
-    except ValueError:
-        riqueza = 0
-
-    # TF-IDF
-    try:
-        vectorizer_tfidf = TfidfVectorizer(stop_words=STOP_WORDS_PT, max_features=20000)
+        counts_matrix = vectorizer_count.fit_transform(textos)
         tfidf_matrix = vectorizer_tfidf.fit_transform(textos)
-        vocab = vectorizer_tfidf.get_feature_names_out()
-
-        soma = tfidf_matrix.sum(axis=0).A1
-        top_idx = np.argsort(soma)[-10:][::-1]
-        palavras_relevantes = [vocab[i] for i in top_idx]
-    except ValueError:
-        palavras_relevantes = []
-
-    # Entropia
-    try:
-        contagens = vectorizer_count.transform(textos).sum(axis=0).A1
-        ent = entropy(contagens / contagens.sum(), base=2)
-    except Exception:
-        ent = 0.0
-
+    except ValueError: # Corpus vazio ou só com stopwords
+        return {"riqueza_lexical": 0, "top_tfidf_palavras": [], "top_frequencia_palavras": [], "entropia": 0.0}
+
+    # Métricas de Frequência
+    vocab_count = vectorizer_count.get_feature_names_out()
+    contagens = counts_matrix.sum(axis=0).A1
+    top_idx_freq = np.argsort(contagens)[-10:][::-1]
+    top_frequencia = [{"palavra": vocab_count[i], "contagem": int(contagens[i])} for i in top_idx_freq]
+
+    # Métricas de TF-IDF
+    vocab_tfidf = vectorizer_tfidf.get_feature_names_out()
+    soma_tfidf = tfidf_matrix.sum(axis=0).A1
+    top_idx_tfidf = np.argsort(soma_tfidf)[-10:][::-1]
+    top_tfidf = [{"palavra": vocab_tfidf[i], "score": round(float(soma_tfidf[i]), 4)} for i in top_idx_tfidf]
+    
     return {
-        "riqueza_lexical": int(riqueza),
-        "palavras_relevantes": palavras_relevantes,
-        "entropia": float(ent)
+        "riqueza_lexical": len(vocab_count),
+        "top_tfidf_palavras": top_tfidf,
+        "top_frequencia_palavras": top_frequencia,
+        "entropia": float(entropy(contagens / contagens.sum(), base=2))
     }
 
-
-# ==============================================================================
-# FUNÇÃO: Duplicados exatos e semânticos
-# ==============================================================================
-
+# <<< MODIFICAÇÃO >>> Retorna dados para o histograma
 def encontrar_duplicados(df: pd.DataFrame, embeddings: np.ndarray) -> Dict[str, Any]:
     print("[DUPLICADOS] Detectando duplicados...")
-
-    # Duplicados exatos
+    
     mask = df["full_text"].duplicated(keep=False)
-    df_dup = df[mask]
-
-    grupos_exatos = {}
-    if not df_dup.empty:
-        grupos_exatos = {
-            texto: [int(i) for i in indices]
-            for texto, indices in df_dup.groupby("full_text").groups.items()
-        }
-
-    # Duplicados semânticos (limite)
+    grupos_exatos = {t: [int(i) for i in idxs] for t, idxs in df[mask].groupby("full_text").groups.items()}
+    
     pares_semanticos = []
-    limite = 5000
-
-    if len(embeddings) < limite:
+    histograma = {"bins": [], "contagens": []}
+    
+    if 2 < len(embeddings) < 5000:
         sim = cosine_similarity(embeddings)
-        triu = np.triu_indices_from(sim, k=1)
-        pares = np.where(sim[triu] > 0.98)[0]
+        triu_indices = np.triu_indices_from(sim, k=1)
+        sim_vetor = sim[triu_indices]
 
-        for i in pares:
-            idx1, idx2 = triu[0][i], triu[1][i]
+        # Pares para a lista de duplicados
+        pares_idx = np.where(sim_vetor > 0.98)[0]
+        for i in pares_idx:
+            idx1, idx2 = triu_indices[0][i], triu_indices[1][i]
             if df["full_text"].iloc[idx1] != df["full_text"].iloc[idx2]:
                 pares_semanticos.append({
-                    "doc1_idx": int(idx1),
-                    "doc2_idx": int(idx2),
+                    "doc1_idx": int(idx1), "doc2_idx": int(idx2),
                     "similaridade": float(sim[idx1, idx2]),
-                    "texto1": df["full_text"].iloc[idx1],
-                    "texto2": df["full_text"].iloc[idx2],
+                    "texto1": df["full_text"].iloc[idx1], "texto2": df["full_text"].iloc[idx2],
                 })
+        
+        # Histograma para o gráfico
+        contagens, bin_edges = np.histogram(sim_vetor, bins=np.arange(0.8, 1.01, 0.05))
+        histograma["bins"] = [f"{b:.2f}-{e:.2f}" for b, e in zip(bin_edges[:-1], bin_edges[1:])]
+        histograma["contagens"] = contagens.tolist()
 
     return {
         "grupos_exatos": grupos_exatos,
-        "pares_semanticos": pares_semanticos
+        "pares_semanticos": pares_semanticos,
+        "similaridade_histograma": histograma
     }
 
+# <<< NOVA FUNÇÃO >>> Cria o brasão de armas de cada cluster
+def analisar_clusters(df: pd.DataFrame) -> Dict[str, Any]:
+    print("[CLUSTERS] Analisando clusters individualmente...")
+    analise = {}
+    ids_clusters_validos = sorted([c for c in df["cluster"].unique() if c != "-1"], key=int)
+
+    for cid in ids_clusters_validos:
+        textos_cluster = df[df["cluster"] == cid]["full_text"].tolist()
+        if len(textos_cluster) < 2: continue
+        
+        try:
+            vectorizer = TfidfVectorizer(stop_words=STOP_WORDS_PT, max_features=1000)
+            tfidf_matrix = vectorizer.fit_transform(textos_cluster)
+            vocab = vectorizer.get_feature_names_out()
+            soma = tfidf_matrix.sum(axis=0).A1
+            top_idx = np.argsort(soma)[-5:][::-1]
+            top_palavras = [{"palavra": vocab[i], "score": round(float(soma[i]), 4)} for i in top_idx]
+        except ValueError:
+            top_palavras = []
+        
+        analise[cid] = {
+            "num_documentos": len(textos_cluster),
+            "top_palavras": top_palavras
+        }
+    return analise
 
 # ==============================================================================
 # FASTAPI — DEFINIÇÃO DA API
 # ==============================================================================
-
-app = FastAPI(
-    title="API do AetherMap (Versão Profissional)",
-    version="2.0.0",
-)
+app = FastAPI(title="API do AetherMap (Versão Imperial)", version="3.0.0")
 
 @app.post("/process/")
-async def process_api(
-    n_samples: int = Form(10000),
-    file: UploadFile = File(...)
-):
+async def process_api(n_samples: int = Form(10000), file: UploadFile = File(...)):
     print(f"[API] Requisição recebida para {file.filename} ({n_samples} amostras).")
-
     try:
         file_bytes = await file.read()
-
         textos = preparar_textos(file_bytes, n_samples)
-        if not textos:
-            raise HTTPException(status_code=400, detail="Nenhum texto válido encontrado.")
+        if not textos: raise HTTPException(status_code=400, detail="Nenhum texto válido encontrado.")
 
         df, embeddings = processar_pipeline(textos)
-        metricas = calcular_metricas(df["full_text"].tolist())
-        duplicados = encontrar_duplicados(df, embeddings)
+        
+        # <<< MODIFICAÇÃO >>> Chamando todas as novas e aprimoradas funções de análise
+        metricas_globais = calcular_metricas(df["full_text"].tolist())
+        analise_de_duplicados = encontrar_duplicados(df, embeddings)
+        analise_por_cluster = analisar_clusters(df)
 
         n_clusters = len(df["cluster"].unique()) - (1 if "-1" in df["cluster"].unique() else 0)
-        n_ruido = (df["cluster"] == "-1").sum()
+        n_ruido = int((df["cluster"] == "-1").sum())
 
+        # <<< MODIFICAÇÃO >>> Montando a resposta imperial, rica em dados
         resposta = {
             "metadata": {
                 "filename": file.filename,
-                "num_documents_processed": int(len(df)),
+                "num_documents_processed": len(df),
                 "n_samples_requested": n_samples,
-                "num_clusters_found": int(n_clusters),
-                "num_noise_points": int(n_ruido),
+                "num_clusters_found": n_clusters,
+                "num_noise_points": n_ruido,
             },
-            "metrics": metricas,
-            "duplicates": duplicados,
+            "metrics": metricas_globais,
+            "duplicates": analise_de_duplicados,
+            "cluster_analysis": analise_por_cluster, # NOVO
             "plot_data": df[["x", "y", "z", "cluster", "full_text"]].to_dict("records"),
         }
-
+        
         print("[API] Processamento finalizado com sucesso.")
         return resposta
 
@@ -260,4 +232,4 @@ async def process_api(
         import traceback
         print("[ERRO] ERRO CRÍTICO NA REQUISIÇÃO:", e)
         traceback.print_exc()
-        raise HTTPException(status_code=500, detail=f"Erro interno do servidor: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Erro interno do servidor: {str(e)}")