Update modules/text_analysis/semantic_analysis.py

modules/text_analysis/semantic_analysis.py

@@ -220,70 +220,132 @@ def fig_to_html(fig):
 
 def identify_key_concepts(doc, min_freq=2, min_length=3):
     """
-    Identifica conceptos clave en el texto, excluyendo stopwords
-    y aplicando criterios de frecuencia y longitud.
+    Identifica conceptos clave en el texto.
+    Args:
+        doc: Documento procesado por spaCy
+        min_freq: Frecuencia mínima para considerar un concepto
+        min_length: Longitud mínima de palabra para considerar
+    Returns:
+        list: Lista de tuplas (concepto, frecuencia)
     """
-    stopwords = get_stopwords(doc.lang_)
-    word_freq = Counter()
-    
-    for token in doc:
-        if (token.text.lower() not in stopwords and  # No es stopword
-            token.is_alpha and                       # Es alfabético
-            len(token.text) >= min_length and        # Longitud mínima
-            not token.is_punct and                   # No es puntuación
-            not token.like_num):                     # No es número
-            
-            # Usar el lema en lugar del token para unificar variantes
-            word_freq[token.lemma_] += 1
-    
-    # Filtrar por frecuencia mínima y ordenar por frecuencia
-    key_concepts = [(word, freq) for word, freq in word_freq.items() 
+    try:
+        # Obtener stopwords para el idioma
+        stopwords = get_stopwords(doc.lang_)
+        
+        # Contar frecuencias de palabras
+        word_freq = Counter()
+        
+        for token in doc:
+            if (token.lemma_.lower() not in stopwords and
+                len(token.lemma_) >= min_length and
+                token.is_alpha and
+                not token.is_punct and
+                not token.like_num):
+                
+                word_freq[token.lemma_.lower()] += 1
+        
+        # Filtrar por frecuencia mínima
+        concepts = [(word, freq) for word, freq in word_freq.items() 
                    if freq >= min_freq]
-    key_concepts.sort(key=lambda x: x[1], reverse=True)
-    
-    return key_concepts[:10]  # Retornar los 10 conceptos más frecuentes
+        
+        # Ordenar por frecuencia
+        concepts.sort(key=lambda x: x[1], reverse=True)
+        
+        return concepts[:10]  # Retornar los 10 conceptos más frecuentes
+        
+    except Exception as e:
+        logger.error(f"Error en identify_key_concepts: {str(e)}")
+        return []  # Retornar lista vacía en caso de error
 
 
 def create_concept_graph(doc, key_concepts):
     """
     Crea un grafo de relaciones entre conceptos.
+    Args:
+        doc: Documento procesado por spaCy
+        key_concepts: Lista de tuplas (concepto, frecuencia)
+    Returns:
+        nx.Graph: Grafo de conceptos
     """
-    G = nx.Graph()
-    concept_words = {concept[0] for concept in key_concepts}
-    
-    for sent in doc.sents:
-        sentence_concepts = []
-        for token in sent:
-            if token.lemma_ in concept_words:
-                sentence_concepts.append(token.lemma_)
+    try:
+        G = nx.Graph()
         
-        # Crear conexiones entre conceptos en la misma oración
-        for i, concept1 in enumerate(sentence_concepts):
-            for concept2 in sentence_concepts[i+1:]:
-                if G.has_edge(concept1, concept2):
-                    G[concept1][concept2]['weight'] += 1
-                else:
-                    G.add_edge(concept1, concept2, weight=1)
-    
-    return G
+        # Crear un conjunto de conceptos clave para búsqueda rápida
+        concept_words = {concept[0].lower() for concept in key_concepts}
+        
+        # Añadir nodos al grafo
+        for concept, freq in key_concepts:
+            G.add_node(concept.lower(), weight=freq)
+        
+        # Analizar cada oración
+        for sent in doc.sents:
+            # Obtener conceptos en la oración actual
+            current_concepts = []
+            for token in sent:
+                if token.lemma_.lower() in concept_words:
+                    current_concepts.append(token.lemma_.lower())
+            
+            # Crear conexiones entre conceptos en la misma oración
+            for i, concept1 in enumerate(current_concepts):
+                for concept2 in current_concepts[i+1:]:
+                    if concept1 != concept2:
+                        # Si ya existe la arista, incrementar el peso
+                        if G.has_edge(concept1, concept2):
+                            G[concept1][concept2]['weight'] += 1
+                        # Si no existe, crear nueva arista con peso 1
+                        else:
+                            G.add_edge(concept1, concept2, weight=1)
+        
+        return G
+        
+    except Exception as e:
+        logger.error(f"Error en create_concept_graph: {str(e)}")
+        # Retornar un grafo vacío en caso de error
+        return nx.Graph()
 
 def visualize_concept_graph(G, lang_code):
-    fig, ax = plt.subplots(figsize=(12, 8))
-    pos = nx.spring_layout(G, k=0.5, iterations=50)
-    node_sizes = [G.nodes[node]['weight'] * 100 for node in G.nodes()]
-    nx.draw_networkx_nodes(G, pos, node_size=node_sizes, node_color='lightblue', alpha=0.8, ax=ax)
-    nx.draw_networkx_labels(G, pos, font_size=10, font_weight="bold", ax=ax)
-    edge_weights = [G[u][v]['weight'] for u, v in G.edges()]
-    nx.draw_networkx_edges(G, pos, width=edge_weights, alpha=0.5, ax=ax)
-    title = {
-        'es': "Relaciones entre Conceptos Clave",
-        'en': "Key Concept Relations",
-        'fr': "Relations entre Concepts Clés"
-    }
-    ax.set_title(title[lang_code], fontsize=16)
-    ax.axis('off')
-    plt.tight_layout()
-    return fig
+    """
+    Visualiza el grafo de conceptos.
+    Args:
+        G: Grafo de networkx
+        lang_code: Código del idioma
+    Returns:
+        matplotlib.figure.Figure: Figura con el grafo visualizado
+    """
+    try:
+        plt.figure(figsize=(12, 8))
+        
+        # Calcular el layout del grafo
+        pos = nx.spring_layout(G)
+        
+        # Obtener pesos de nodos y aristas
+        node_weights = [G.nodes[node].get('weight', 1) * 500 for node in G.nodes()]
+        edge_weights = [G[u][v].get('weight', 1) for u, v in G.edges()]
+        
+        # Dibujar el grafo
+        nx.draw_networkx_nodes(G, pos, 
+                             node_size=node_weights,
+                             node_color='lightblue',
+                             alpha=0.6)
+        
+        nx.draw_networkx_edges(G, pos,
+                             width=edge_weights,
+                             alpha=0.5,
+                             edge_color='gray')
+        
+        nx.draw_networkx_labels(G, pos,
+                              font_size=10,
+                              font_weight='bold')
+        
+        plt.title("Red de conceptos relacionados")
+        plt.axis('off')
+        
+        return plt.gcf()
+        
+    except Exception as e:
+        logger.error(f"Error en visualize_concept_graph: {str(e)}")
+        # Retornar una figura vacía en caso de error
+        return plt.figure()
 
 def create_entity_graph(entities):
     G = nx.Graph()