Update modules/text_analysis/semantic_analysis.py

modules/text_analysis/semantic_analysis.py

@@ -183,25 +183,48 @@ def perform_semantic_analysis(text, nlp, lang_code):
 
 def identify_key_concepts(doc, stopwords, min_freq=2, min_length=3):
     """
-    Identifica conceptos clave en el texto.
+    Identifica conceptos clave en el texto, excluyendo entidades nombradas.
+    Args:
+        doc: Documento procesado por spaCy
+        stopwords: Lista de stopwords
+        min_freq: Frecuencia mínima para considerar un concepto
+        min_length: Longitud mínima del concepto
+    Returns:
+        List[Tuple[str, int]]: Lista de tuplas (concepto, frecuencia)
     """
     try:
         word_freq = Counter()
         
+        # Crear conjunto de tokens que son parte de entidades
+        entity_tokens = set()
+        for ent in doc.ents:
+            entity_tokens.update(token.i for token in ent)
+        
+        # Procesar tokens
         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):
+            # Verificar si el token no es parte de una entidad nombrada
+            if (token.i not in entity_tokens and  # No es parte de una entidad
+                token.lemma_.lower() not in stopwords and  # No es stopword
+                len(token.lemma_) >= min_length and  # Longitud mínima
+                token.is_alpha and  # Es alfabético
+                not token.is_punct and  # No es puntuación
+                not token.like_num and  # No es número
+                not token.is_space and  # No es espacio
+                not token.is_stop and  # No es stopword de spaCy
+                not token.pos_ == 'PROPN' and  # No es nombre propio
+                not token.pos_ == 'SYM' and  # No es símbolo
+                not token.pos_ == 'NUM' and  # No es número
+                not token.pos_ == 'X'):  # No es otro
                 
+                # Convertir a minúsculas y añadir al contador
                 word_freq[token.lemma_.lower()] += 1
         
+        # Filtrar conceptos por frecuencia mínima y ordenar por frecuencia
         concepts = [(word, freq) for word, freq in word_freq.items() 
                    if freq >= min_freq]
         concepts.sort(key=lambda x: x[1], reverse=True)
         
-        logger.info(f"Identified {len(concepts)} key concepts")
+        logger.info(f"Identified {len(concepts)} key concepts after excluding entities")
         return concepts[:10]
         
     except Exception as e:
@@ -209,9 +232,10 @@ def identify_key_concepts(doc, stopwords, min_freq=2, min_length=3):
         return []
 
 ########################################################################
+
 def create_concept_graph(doc, key_concepts):
     """
-    Crea un grafo de relaciones entre conceptos.
+    Crea un grafo de relaciones entre conceptos, ignorando entidades.
     Args:
         doc: Documento procesado por spaCy
         key_concepts: Lista de tuplas (concepto, frecuencia)
@@ -224,26 +248,30 @@ def create_concept_graph(doc, key_concepts):
         # Crear un conjunto de conceptos clave para búsqueda rápida
         concept_words = {concept[0].lower() for concept in key_concepts}
         
+        # Crear conjunto de tokens que son parte de entidades
+        entity_tokens = set()
+        for ent in doc.ents:
+            entity_tokens.update(token.i for token in ent)
+        
         # 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
+            # Obtener conceptos en la oración actual, excluyendo entidades
             current_concepts = []
             for token in sent:
-                if token.lemma_.lower() in concept_words:
+                if (token.i not in entity_tokens and 
+                    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)
         
@@ -251,7 +279,6 @@ def create_concept_graph(doc, key_concepts):
         
     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()
 
 ###############################################################################