Update app.py

app.py

@@ -1,168 +1,82 @@
-import gradio as gr
 import pandas as pd
 from sentence_transformers import SentenceTransformer
+from sklearn.cluster import DBSCAN
 from sklearn.metrics.pairwise import cosine_similarity
-import nltk
-from nltk.tokenize import word_tokenize
-from nltk.corpus import stopwords
-from nltk.stem import SnowballStemmer
-from datetime import datetime
-import re
-
-# Descargar recursos de NLTK
-nltk.download('punkt')
-nltk.download('stopwords')
-
-class LiteralEncoder:
-    def __init__(self):
-        # Modelo de embeddings multilingüe
-        self.model = SentenceTransformer('paraphrase-multilingual-mpnet-base-v2')
-        self.stemmer = SnowballStemmer('spanish')
-        self.stop_words = set(stopwords.words('spanish'))
-        self.literal_to_codes = {}
-        self.embeddings = {}
-
-    def preprocess_literal(self, text):
-        """Preprocesa el literal para mejor comparación"""
-        text = str(text).lower().strip()
-        text = re.sub(r'[^\w\s]', ' ', text)
-        tokens = word_tokenize(text)
-        tokens = [self.stemmer.stem(token) for token in tokens 
-                 if token not in self.stop_words]
-        return ' '.join(tokens)
-
-    def train(self, training_df):
-        """Entrena el codificador con los datos de ejemplo"""
-        # Procesar cada literal y sus códigos
-        for _, row in training_df.iterrows():
-            literal = str(row['B']).strip()
-            codes = str(row['C']).strip().split(';')
-            codes = [code.strip() for code in codes]
-            
-            processed_literal = self.preprocess_literal(literal)
-            self.literal_to_codes[literal] = {
-                'codes': codes,
-                'processed': processed_literal
-            }
-
-        # Generar embeddings para todos los literales
-        processed_literals = [v['processed'] for v in self.literal_to_codes.values()]
-        all_embeddings = self.model.encode(processed_literals)
-        
-        for (literal, data), embedding in zip(self.literal_to_codes.items(), all_embeddings):
-            self.literal_to_codes[literal]['embedding'] = embedding
-
-    def encode_literal(self, literal, threshold=0.7):
-        """Codifica un nuevo literal basado en similitud"""
-        processed = self.preprocess_literal(literal)
-        literal_embedding = self.model.encode([processed])[0]
-
-        best_similarity = 0
-        best_match = None
-        best_codes = []
-
-        for train_literal, data in self.literal_to_codes.items():
-            similarity = cosine_similarity(
-                [literal_embedding], 
-                [data['embedding']]
-            )[0][0]
-
-            if similarity > best_similarity:
-                best_similarity = similarity
-                best_match = train_literal
-                best_codes = data['codes']
+import numpy as np
+import gradio as gr
 
-        if best_similarity >= threshold:
-            return {
-                'codes': best_codes,
-                'similarity': best_similarity,
-                'matched_literal': best_match
-            }
+# Cargar el modelo de embeddings
+modelo = SentenceTransformer('all-MiniLM-L6-v2')
+
+# Función para realizar el clustering de las frases
+def obtener_categorias_dinamicas(frases, umbral_similitud=0.5):
+    # Codificar las frases en vectores (embeddings)
+    embeddings = modelo.encode(frases)
+    
+    # Realizar clustering con DBSCAN (puedes cambiar el modelo de clustering si lo prefieres)
+    clustering = DBSCAN(eps=0.5, min_samples=2, metric='cosine').fit(embeddings)
+    
+    # Asignar una categoría para cada frase según el cluster al que pertenece
+    etiquetas = clustering.labels_
+
+    # Agrupar las frases según sus etiquetas (clusters)
+    categorias = {}
+    for i, etiqueta in enumerate(etiquetas):
+        if etiqueta == -1:
+            categoria = "Sin grupo"  # Las que no tienen un grupo asignado (ruido)
         else:
-            return {
-                'codes': [],
-                'similarity': 0,
-                'matched_literal': 'NO_MATCH'
-            }
-
-def process_excel(training_file, new_file, confidence_threshold=0.7):
-    """Procesa los archivos Excel"""
-    try:
-        # Leer archivos
-        training_df = pd.read_excel(training_file.name)
-        new_df = pd.read_excel(new_file.name)
-
-        # Inicializar y entrenar el codificador
-        encoder = LiteralEncoder()
-        encoder.train(training_df)
-
-        # Preparar DataFrame de resultados
-        results_df = new_df.copy()
-        results_df['Códigos_Asignados'] = ''
-        results_df['Literal_Original'] = ''
-        results_df['Score_Similitud'] = 0.0
-
-        # Codificar cada literal nuevo
-        for idx, row in results_df.iterrows():
-            literal = str(row['B'])
-            result = encoder.encode_literal(literal, confidence_threshold)
-            
-            results_df.at[idx, 'Códigos_Asignados'] = (
-                '; '.join(result['codes']) if result['codes'] 
-                else 'SIN_MATCH'
-            )
-            results_df.at[idx, 'Literal_Original'] = result['matched_literal']
-            results_df.at[idx, 'Score_Similitud'] = round(result['similarity'], 3)
-
-        # Generar estadísticas
-        total = len(results_df)
-        matched = len(results_df[results_df['Códigos_Asignados'] != 'SIN_MATCH'])
+            categoria = f"Categoría {etiqueta + 1}"
         
-        stats_df = pd.DataFrame({
-            'Métrica': [
-                'Total Literales',
-                'Literales Codificados',
-                'Sin Coincidencia',
-                'Porcentaje Éxito'
-            ],
-            'Valor': [
-                total,
-                matched,
-                total - matched,
-                f"{(matched/total*100):.1f}%"
-            ]
-        })
-
-        # Guardar resultados
-        output_name = f"codificacion_literales_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
+        if categoria not in categorias:
+            categorias[categoria] = []
+        categorias[categoria].append(frases[i])
+
+    # Ahora, se asigna cada frase a las categorías con similitud suficiente
+    categorias_frases = []
+    for frase in frases:
+        # Calcular la similitud con todas las categorías
+        frase_embedding = modelo.encode([frase])
         
-        with pd.ExcelWriter(output_name) as writer:
-            results_df.to_excel(writer, sheet_name='Resultados', index=False)
-            stats_df.to_excel(writer, sheet_name='Resumen', index=False)
-            training_df.to_excel(writer, sheet_name='Datos_Training', index=False)
-
-        return output_name
-
-    except Exception as e:
-        return f"Error: {str(e)}"
+        # Listar las categorías que tienen una alta similitud con la frase
+        categorias_relevantes = []
+        for categoria, frases_grupo in categorias.items():
+            # Obtener la media de los embeddings del grupo
+            grupo_embeddings = modelo.encode(frases_grupo)
+            centro_grupo = np.mean(grupo_embeddings, axis=0)
+            
+            # Calcular la similitud entre la frase y el centro del grupo
+            similitud = cosine_similarity(frase_embedding, [centro_grupo])[0][0]
+            
+            # Si la similitud supera el umbral, asignamos la categoría
+            if similitud > umbral_similitud:
+                categorias_relevantes.append(categoria)
 
-# Interfaz Gradio
+        # Si no hay categorías relevantes, asignamos "Sin grupo"
+        if not categorias_relevantes:
+            categorias_relevantes.append("Sin grupo")
+        
+        categorias_frases.append(";".join(categorias_relevantes))
+    
+    # Crear un DataFrame para mostrar el resultado
+    resultados = pd.DataFrame({
+        'Frase': frases,
+        'Categorías': categorias_frases
+    })
+    
+    return resultados
+
+# Función para cargar y procesar el archivo Excel
+def procesar_excel(archivo):
+    df = pd.read_excel(archivo)
+    # Asumir que el archivo tiene una columna llamada "Frase"
+    frases = df['Frase'].tolist()
+    return obtener_categorias_dinamicas(frases)
+
+# Crear la interfaz de Gradio
 iface = gr.Interface(
-    fn=process_excel,
-    inputs=[
-        gr.File(label="Excel con literales de entrenamiento (B: literales, C: códigos)"),
-        gr.File(label="Excel con nuevos literales a codificar"),
-        gr.Slider(
-            minimum=0.0, 
-            maximum=1.0, 
-            value=0.7, 
-            label="Umbral de confianza (0-1)"
-        )
-    ],
-    outputs=gr.File(label="Excel con resultados"),
-    title="Codificador Automático de Literales",
-    description="Codifica automáticamente literales basándose en ejemplos previos. Los códigos múltiples deben estar separados por punto y coma (;) en la columna C."
+    fn=procesar_excel, 
+    inputs=gr.File(label="Cargar archivo Excel con frases"), 
+    outputs="dataframe"
 )
 
-if __name__ == "__main__":
-    iface.launch()
+iface.launch()