Merge branch #AIdeaText/test' into 'AIdeaText/test2'

app.py

@@ -18,7 +18,6 @@ from modules.auth.auth import authenticate_user, register_user
 from modules.admin.admin_ui import admin_page
 
 from modules.ui.ui import (
-    main,
     login_register_page, 
     login_form,
     display_morphosyntax_analysis_interface, 

modules/__init__.py

@@ -91,14 +91,17 @@ def morpho_analysis_functions():
 
 def semantic_analysis_text_functions():
     from modules.analysis_text.semantic_analysis import (
-        visualize_semantic_relations,
+        #visualize_semantic_relations,
         perform_semantic_analysis,
-        create_semantic_graph
+        create_semantic_graph,
+        visualize_concept_graph,
     )
     return {
-        'visualize_semantic_relations': visualize_semantic_relations,
+        #'visualize_semantic_relations': visualize_semantic_relations,
         'perform_semantic_analysis': perform_semantic_analysis,
-        'create_semantic_graph': create_semantic_graph
+        'create_semantic_graph': create_semantic_graph,
+        'create_concept_graph': create_concept_graph,
+        'visualize_concept_graph': visualize_concept_graph,
     }
 
 def discourse_analysis_text_functions():

modules/database/database.py

@@ -256,20 +256,26 @@ def store_semantic_result(username, text, analysis_result):
     if analysis_collection is None:
         logger.error("La conexión a MongoDB no está inicializada")
         return False
+
     try:
+        # Convertir el gráfico a imagen base64
         buf = io.BytesIO()
         analysis_result['relations_graph'].savefig(buf, format='png')
         buf.seek(0)
         img_str = base64.b64encode(buf.getvalue()).decode('utf-8')
+
+        # Convertir los conceptos clave a una lista de tuplas
+        key_concepts = [(concept, float(frequency)) for concept, frequency in analysis_result['key_concepts']]
+
         analysis_document = {
             'username': username,
             'timestamp': datetime.utcnow(),
             'text': text,
-            'entities': analysis_result['entities'],
-            'key_concepts': analysis_result['key_concepts'],
-            'network_diagram': img_str,  # Cambiado de 'relations_graph' a 'network_diagram'
+            'key_concepts': key_concepts,
+            'network_diagram': img_str,
             'analysis_type': 'semantic'
         }
+
         result = analysis_collection.insert_one(analysis_document)
         logger.info(f"Análisis semántico guardado con ID: {result.inserted_id} para el usuario: {username}")
         logger.info(f"Longitud de la imagen guardada: {len(img_str)}")
@@ -280,19 +286,19 @@ def store_semantic_result(username, text, analysis_result):
 
 ###############################################################################################################
 
-def store_discourse_analysis_result(username, text1, text2, graph1, graph2):
+def store_discourse_analysis_result(username, text1, text2, analysis_result):
     try:
         # Crear una nueva figura combinada
         fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(20, 10))
 
-        # Añadir la primera imagen con título
-        ax1.imshow(graph1.get_figure().canvas.renderer.buffer_rgba())
-        ax1.set_title("Documento Patrón: Relaciones semánticas relevantes")
+        # Añadir la primera imagen
+        ax1.imshow(analysis_result['graph1'].canvas.renderer.buffer_rgba())
+        ax1.set_title("Documento 1: Relaciones Conceptuales")
         ax1.axis('off')
 
-        # Añadir la segunda imagen con título
-        ax2.imshow(graph2.get_figure().canvas.renderer.buffer_rgba())
-        ax2.set_title("Documento Comparado con el documento patrón: Relaciones semánticas relevantes")
+        # Añadir la segunda imagen
+        ax2.imshow(analysis_result['graph2'].canvas.renderer.buffer_rgba())
+        ax2.set_title("Documento 2: Relaciones Conceptuales")
         ax2.axis('off')
 
         # Ajustar el diseño
@@ -306,8 +312,12 @@ def store_discourse_analysis_result(username, text1, text2, graph1, graph2):
 
         # Cerrar las figuras para liberar memoria
         plt.close(fig)
-        plt.close(graph1.get_figure())
-        plt.close(graph2.get_figure())
+        plt.close(analysis_result['graph1'])
+        plt.close(analysis_result['graph2'])
+
+        # Convertir los conceptos clave a listas de tuplas
+        key_concepts1 = [(concept, float(frequency)) for concept, frequency in analysis_result['table1'].values.tolist()]
+        key_concepts2 = [(concept, float(frequency)) for concept, frequency in analysis_result['table2'].values.tolist()]
 
         analysis_document = {
             'username': username,
@@ -315,11 +325,12 @@ def store_discourse_analysis_result(username, text1, text2, graph1, graph2):
             'text1': text1,
             'text2': text2,
             'combined_graph': img_str,
+            'key_concepts1': key_concepts1,
+            'key_concepts2': key_concepts2,
             'analysis_type': 'discourse'
         }
 
         result = analysis_collection.insert_one(analysis_document)
-
         logger.info(f"Análisis discursivo guardado con ID: {result.inserted_id} para el usuario: {username}")
         return True
     except Exception as e:

modules/text_analysis/discourse_analysis.py

@@ -2,53 +2,88 @@ import streamlit as st
 import spacy
 import networkx as nx
 import matplotlib.pyplot as plt
-from collections import defaultdict
-from .semantic_analysis import visualize_semantic_relations, create_semantic_graph, POS_COLORS, POS_TRANSLATIONS
+import pandas as pd
+from .semantic_analysis import (
+    create_concept_graph,
+    visualize_concept_graph,
+    identify_key_concepts,
+    POS_COLORS,
+    POS_TRANSLATIONS,
+    ENTITY_LABELS
+)
 
-##################################################################################################################
 def compare_semantic_analysis(text1, text2, nlp, lang):
     doc1 = nlp(text1)
     doc2 = nlp(text2)
-    
-    G1, pos_counts1 = create_semantic_graph(doc1, lang)
-    G2, pos_counts2 = create_semantic_graph(doc2, lang)
-    
-    # Create two separate figures with a smaller size
-    fig1, ax1 = plt.subplots(figsize=(18, 13))
-    fig2, ax2 = plt.subplots(figsize=(18, 13))
-    
-    # Draw the first graph
-    pos1 = nx.spring_layout(G1, k=0.7, iterations=50)
-    nx.draw(G1, pos1, ax=ax1, node_color=[POS_COLORS.get(G1.nodes[node]['pos'], '#CCCCCC') for node in G1.nodes()],
-            with_labels=True, node_size=4000, font_size=10, font_weight='bold',
-            arrows=True, arrowsize=20, width=2, edge_color='gray')
-    nx.draw_networkx_edge_labels(G1, pos1, edge_labels=nx.get_edge_attributes(G1, 'label'), font_size=8, ax=ax1)
-    
-    # Draw the second graph
-    pos2 = nx.spring_layout(G2, k=0.7, iterations=50)
-    nx.draw(G2, pos2, ax=ax2, node_color=[POS_COLORS.get(G2.nodes[node]['pos'], '#CCCCCC') for node in G2.nodes()],
-            with_labels=True, node_size=4000, font_size=10, font_weight='bold',
-            arrows=True, arrowsize=20, width=2, edge_color='gray')
-    nx.draw_networkx_edge_labels(G2, pos2, edge_labels=nx.get_edge_attributes(G2, 'label'), font_size=8, ax=ax2)
-    
-    ax1.set_title("Documento 1: Relaciones Semánticas Relevantes", fontsize=14, fontweight='bold')
-    ax2.set_title("Documento 2: Relaciones Semánticas Relevantes", fontsize=14, fontweight='bold')
-    
-    ax1.axis('off')
-    ax2.axis('off')
-    
-    # Add legends
-    legend_elements = [plt.Rectangle((0,0),1,1,fc=POS_COLORS.get(pos, '#CCCCCC'), edgecolor='none', 
-                       label=f"{POS_TRANSLATIONS[lang].get(pos, pos)}")
-                       for pos in ['NOUN', 'VERB']]
-    ax1.legend(handles=legend_elements, loc='upper left', bbox_to_anchor=(0, 1), fontsize=8)
-    ax2.legend(handles=legend_elements, loc='upper left', bbox_to_anchor=(0, 1), fontsize=8)
-    
-    plt.tight_layout()
-    
-    return fig1, fig2
-
-##################################################################################################################
+
+    # Identificar conceptos clave para ambos documentos
+    key_concepts1 = identify_key_concepts(doc1)
+    key_concepts2 = identify_key_concepts(doc2)
+
+    # Crear grafos de conceptos para ambos documentos
+    G1 = create_concept_graph(doc1, key_concepts1)
+    G2 = create_concept_graph(doc2, key_concepts2)
+
+    # Visualizar los grafos de conceptos
+    fig1 = visualize_concept_graph(G1, lang)
+    fig2 = visualize_concept_graph(G2, lang)
+
+    # Remover los títulos superpuestos
+    fig1.suptitle("")
+    fig2.suptitle("")
+
+    return fig1, fig2, key_concepts1, key_concepts2
+
+def create_concept_table(key_concepts):
+    df = pd.DataFrame(key_concepts, columns=['Concepto', 'Frecuencia'])
+    df['Frecuencia'] = df['Frecuencia'].round(2)
+    return df
+
 def perform_discourse_analysis(text1, text2, nlp, lang):
-    graph1, graph2 = compare_semantic_analysis(text1, text2, nlp, lang)
-    return graph1, graph2
+    graph1, graph2, key_concepts1, key_concepts2 = compare_semantic_analysis(text1, text2, nlp, lang)
+
+    # Crear tablas de conceptos clave
+    table1 = create_concept_table(key_concepts1)
+    table2 = create_concept_table(key_concepts2)
+
+    return {
+        'graph1': graph1,
+        'graph2': graph2,
+        'table1': table1,
+        'table2': table2
+    }
+
+def display_discourse_analysis_results(analysis_result, lang_code):
+    translations = {
+        'es': {
+            'doc1_title': "Documento 1: Relaciones Conceptuales",
+            'doc2_title': "Documento 2: Relaciones Conceptuales",
+            'key_concepts': "Conceptos Clave",
+        },
+        'en': {
+            'doc1_title': "Document 1: Conceptual Relations",
+            'doc2_title': "Document 2: Conceptual Relations",
+            'key_concepts': "Key Concepts",
+        },
+        'fr': {
+            'doc1_title': "Document 1 : Relations Conceptuelles",
+            'doc2_title': "Document 2 : Relations Conceptuelles",
+            'key_concepts': "Concepts Clés",
+        }
+    }
+
+    t = translations[lang_code]
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        with st.expander(t['doc1_title'], expanded=True):
+            st.pyplot(analysis_result['graph1'])
+            st.subheader(t['key_concepts'])
+            st.table(analysis_result['table1'])
+
+    with col2:
+        with st.expander(t['doc2_title'], expanded=True):
+            st.pyplot(analysis_result['graph2'])
+            st.subheader(t['key_concepts'])
+            st.table(analysis_result['table2'])

modules/text_analysis/semantic_analysis.py

@@ -3,260 +3,125 @@ import streamlit as st
 import spacy
 import networkx as nx
 import matplotlib.pyplot as plt
-from collections import Counter
-from collections import defaultdict
+from collections import Counter, defaultdict
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
 
 # Define colors for grammatical categories
 POS_COLORS = {
-    'ADJ': '#FFA07A',    # Light Salmon
-    'ADP': '#98FB98',    # Pale Green
-    'ADV': '#87CEFA',    # Light Sky Blue
-    'AUX': '#DDA0DD',    # Plum
-    'CCONJ': '#F0E68C',  # Khaki
-    'DET': '#FFB6C1',    # Light Pink
-    'INTJ': '#FF6347',   # Tomato
-    'NOUN': '#90EE90',   # Light Green
-    'NUM': '#FAFAD2',    # Light Goldenrod Yellow
-    'PART': '#D3D3D3',   # Light Gray
-    'PRON': '#FFA500',   # Orange
-    'PROPN': '#20B2AA',  # Light Sea Green
-    'SCONJ': '#DEB887',  # Burlywood
-    'SYM': '#7B68EE',    # Medium Slate Blue
-    'VERB': '#FF69B4',   # Hot Pink
-    'X': '#A9A9A9',      # Dark Gray
+    'ADJ': '#FFA07A', 'ADP': '#98FB98', 'ADV': '#87CEFA', 'AUX': '#DDA0DD',
+    'CCONJ': '#F0E68C', 'DET': '#FFB6C1', 'INTJ': '#FF6347', 'NOUN': '#90EE90',
+    'NUM': '#FAFAD2', 'PART': '#D3D3D3', 'PRON': '#FFA500', 'PROPN': '#20B2AA',
+    'SCONJ': '#DEB887', 'SYM': '#7B68EE', 'VERB': '#FF69B4', 'X': '#A9A9A9',
 }
 
 POS_TRANSLATIONS = {
     'es': {
-        'ADJ': 'Adjetivo',
-        'ADP': 'Preposición',
-        'ADV': 'Adverbio',
-        'AUX': 'Auxiliar',
-        'CCONJ': 'Conjunción Coordinante',
-        'DET': 'Determinante',
-        'INTJ': 'Interjección',
-        'NOUN': 'Sustantivo',
-        'NUM': 'Número',
-        'PART': 'Partícula',
-        'PRON': 'Pronombre',
-        'PROPN': 'Nombre Propio',
-        'SCONJ': 'Conjunción Subordinante',
-        'SYM': 'Símbolo',
-        'VERB': 'Verbo',
-        'X': 'Otro',
+        'ADJ': 'Adjetivo', 'ADP': 'Preposición', 'ADV': 'Adverbio', 'AUX': 'Auxiliar',
+        'CCONJ': 'Conjunción Coordinante', 'DET': 'Determinante', 'INTJ': 'Interjección',
+        'NOUN': 'Sustantivo', 'NUM': 'Número', 'PART': 'Partícula', 'PRON': 'Pronombre',
+        'PROPN': 'Nombre Propio', 'SCONJ': 'Conjunción Subordinante', 'SYM': 'Símbolo',
+        'VERB': 'Verbo', 'X': 'Otro',
     },
     'en': {
-        'ADJ': 'Adjective',
-        'ADP': 'Preposition',
-        'ADV': 'Adverb',
-        'AUX': 'Auxiliary',
-        'CCONJ': 'Coordinating Conjunction',
-        'DET': 'Determiner',
-        'INTJ': 'Interjection',
-        'NOUN': 'Noun',
-        'NUM': 'Number',
-        'PART': 'Particle',
-        'PRON': 'Pronoun',
-        'PROPN': 'Proper Noun',
-        'SCONJ': 'Subordinating Conjunction',
-        'SYM': 'Symbol',
-        'VERB': 'Verb',
-        'X': 'Other',
+        'ADJ': 'Adjective', 'ADP': 'Preposition', 'ADV': 'Adverb', 'AUX': 'Auxiliary',
+        'CCONJ': 'Coordinating Conjunction', 'DET': 'Determiner', 'INTJ': 'Interjection',
+        'NOUN': 'Noun', 'NUM': 'Number', 'PART': 'Particle', 'PRON': 'Pronoun',
+        'PROPN': 'Proper Noun', 'SCONJ': 'Subordinating Conjunction', 'SYM': 'Symbol',
+        'VERB': 'Verb', 'X': 'Other',
     },
     'fr': {
-        'ADJ': 'Adjectif',
-        'ADP': 'Préposition',
-        'ADV': 'Adverbe',
-        'AUX': 'Auxiliaire',
-        'CCONJ': 'Conjonction de Coordination',
-        'DET': 'Déterminant',
-        'INTJ': 'Interjection',
-        'NOUN': 'Nom',
-        'NUM': 'Nombre',
-        'PART': 'Particule',
-        'PRON': 'Pronom',
-        'PROPN': 'Nom Propre',
-        'SCONJ': 'Conjonction de Subordination',
-        'SYM': 'Symbole',
-        'VERB': 'Verbe',
-        'X': 'Autre',
+        'ADJ': 'Adjectif', 'ADP': 'Préposition', 'ADV': 'Adverbe', 'AUX': 'Auxiliaire',
+        'CCONJ': 'Conjonction de Coordination', 'DET': 'Déterminant', 'INTJ': 'Interjection',
+        'NOUN': 'Nom', 'NUM': 'Nombre', 'PART': 'Particule', 'PRON': 'Pronom',
+        'PROPN': 'Nom Propre', 'SCONJ': 'Conjonction de Subordination', 'SYM': 'Symbole',
+        'VERB': 'Verbe', 'X': 'Autre',
     }
 }
-########################################################################################################################################
 
-# Definimos las etiquetas y colores para cada idioma
 ENTITY_LABELS = {
     'es': {
         "Personas": "lightblue",
-        "Conceptos": "lightgreen",
         "Lugares": "lightcoral",
-        "Fechas": "lightyellow"
+        "Inventos": "lightgreen",
+        "Fechas": "lightyellow",
+        "Conceptos": "lightpink"
     },
     'en': {
         "People": "lightblue",
-        "Concepts": "lightgreen",
         "Places": "lightcoral",
-        "Dates": "lightyellow"
+        "Inventions": "lightgreen",
+        "Dates": "lightyellow",
+        "Concepts": "lightpink"
     },
     'fr': {
         "Personnes": "lightblue",
-        "Concepts": "lightgreen",
         "Lieux": "lightcoral",
-        "Dates": "lightyellow"
+        "Inventions": "lightgreen",
+        "Dates": "lightyellow",
+        "Concepts": "lightpink"
     }
 }
 
-#########################################################################################################
-def count_pos(doc):
-    return Counter(token.pos_ for token in doc if token.pos_ != 'PUNCT')
+def identify_key_concepts(doc, top_n=10):
+    # Identificar sustantivos, verbos y adjetivos más frecuentes
+    word_freq = Counter([token.lemma_.lower() for token in doc if token.pos_ in ['NOUN', 'VERB', 'ADJ'] and not token.is_stop])
+    return word_freq.most_common(top_n)
 
-#####################################################################################################################
-
-def create_semantic_graph(doc, lang):
-    G = nx.Graph()
-    word_freq = defaultdict(int)
-    lemma_to_word = {}
-    lemma_to_pos = {}
-
-    # Count frequencies of lemmas and map lemmas to their most common word form and POS
-    for token in doc:
-        if token.pos_ in ['NOUN', 'VERB']:
-            lemma = token.lemma_.lower()
-            word_freq[lemma] += 1
-            if lemma not in lemma_to_word or token.text.lower() == lemma:
-                lemma_to_word[lemma] = token.text
-            lemma_to_pos[lemma] = token.pos_
-
-    # Get top 20 most frequent lemmas
-    top_lemmas = [lemma for lemma, _ in sorted(word_freq.items(), key=lambda x: x[1], reverse=True)[:20]]
-
-    # Add nodes
-    for lemma in top_lemmas:
-        word = lemma_to_word[lemma]
-        G.add_node(word, pos=lemma_to_pos[lemma])
-
-    # Add edges
-    for token in doc:
-        if token.lemma_.lower() in top_lemmas:
-            if token.head.lemma_.lower() in top_lemmas:
-                source = lemma_to_word[token.lemma_.lower()]
-                target = lemma_to_word[token.head.lemma_.lower()]
-                if source != target:  # Avoid self-loops
-                    G.add_edge(source, target, label=token.dep_)
-
-    return G, word_freq
-
-############################################################################################################################################
-
-def visualize_semantic_relations(doc, lang):
+def create_concept_graph(doc, key_concepts):
     G = nx.Graph()
-    word_freq = defaultdict(int)
-    lemma_to_word = {}
-    lemma_to_pos = {}
-
-    # Count frequencies of lemmas and map lemmas to their most common word form and POS
-    for token in doc:
-        if token.pos_ in ['NOUN', 'VERB']:
-            lemma = token.lemma_.lower()
-            word_freq[lemma] += 1
-            if lemma not in lemma_to_word or token.text.lower() == lemma:
-                lemma_to_word[lemma] = token.text
-            lemma_to_pos[lemma] = token.pos_
-
-    # Get top 20 most frequent lemmas
-    top_lemmas = [lemma for lemma, _ in sorted(word_freq.items(), key=lambda x: x[1], reverse=True)[:20]]
-
-    # Add nodes
-    for lemma in top_lemmas:
-        word = lemma_to_word[lemma]
-        G.add_node(word, pos=lemma_to_pos[lemma])
-
-    # Add edges
-    for token in doc:
-        if token.lemma_.lower() in top_lemmas:
-            if token.head.lemma_.lower() in top_lemmas:
-                source = lemma_to_word[token.lemma_.lower()]
-                target = lemma_to_word[token.head.lemma_.lower()]
-                if source != target:  # Avoid self-loops
-                    G.add_edge(source, target, label=token.dep_)
-
-    fig, ax = plt.subplots(figsize=(36, 27))
-    pos = nx.spring_layout(G, k=0.7, iterations=50)
-
-    node_colors = [POS_COLORS.get(G.nodes[node]['pos'], '#CCCCCC') for node in G.nodes()]
-
-    nx.draw(G, pos, node_color=node_colors, with_labels=True, 
-            node_size=10000, 
-            font_size=16, 
-            font_weight='bold', 
-            arrows=True, 
-            arrowsize=30, 
-            width=3, 
-            edge_color='gray',
-            ax=ax)
-
-    edge_labels = nx.get_edge_attributes(G, 'label')
-    nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=14, ax=ax)
+    
+    # Añadir nodos
+    for concept, freq in key_concepts:
+        G.add_node(concept, weight=freq)
+    
+    # Añadir aristas basadas en la co-ocurrencia en oraciones
+    for sent in doc.sents:
+        sent_concepts = [token.lemma_.lower() for token in sent if token.lemma_.lower() in dict(key_concepts)]
+        for i, concept1 in enumerate(sent_concepts):
+            for concept2 in sent_concepts[i+1:]:
+                if G.has_edge(concept1, concept2):
+                    G[concept1][concept2]['weight'] += 1
+                else:
+                    G.add_edge(concept1, concept2, weight=1)
+    
+    return G
 
+def visualize_concept_graph(G, lang):
+    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 Semánticas Relevantes",
-        'en': "Relevant Semantic Relations",
-        'fr': "Relations Sémantiques Pertinentes"
+        'es': "Relaciones entre Conceptos Clave",
+        'en': "Key Concept Relations",
+        'fr': "Relations entre Concepts Clés"
     }
-    ax.set_title(title[lang], fontsize=24, fontweight='bold')
+    ax.set_title(title[lang], fontsize=16)
     ax.axis('off')
-
-    legend_elements = [plt.Rectangle((0,0),1,1,fc=POS_COLORS.get(pos, '#CCCCCC'), edgecolor='none', 
-                       label=f"{POS_TRANSLATIONS[lang].get(pos, pos)}")
-                       for pos in ['NOUN', 'VERB']]
-    ax.legend(handles=legend_elements, loc='center left', bbox_to_anchor=(1, 0.5), fontsize=16)
-
-    return fig
-
-############################################################################################################################################
-def identify_and_contextualize_entities(doc, lang):
-    entities = []
-    for ent in doc.ents:
-        # Obtener el contexto (3 palabras antes y después de la entidad)
-        start = max(0, ent.start - 3)
-        end = min(len(doc), ent.end + 3)
-        context = doc[start:end].text
-        
-        entities.append({
-            'text': ent.text,
-            'label': ent.label_,
-            'start': ent.start,
-            'end': ent.end,
-            'context': context
-        })
     
-    # Identificar conceptos clave (usando sustantivos y verbos más frecuentes)
-    word_freq = Counter([token.lemma_.lower() for token in doc if token.pos_ in ['NOUN', 'VERB'] and not token.is_stop])
-    key_concepts = word_freq.most_common(10)  # Top 10 conceptos clave
-    
-    return entities, key_concepts
-
+    plt.tight_layout()
+    return fig
 
-############################################################################################################################################
 def perform_semantic_analysis(text, nlp, lang):
     doc = nlp(text)
-
-    # Identificar entidades y conceptos clave
-    entities, key_concepts = identify_and_contextualize_entities(doc, lang)
-
-    # Visualizar relaciones semánticas
-    relations_graph = visualize_semantic_relations(doc, lang)
     
-    # Imprimir entidades para depuración
-    print(f"Entidades encontradas ({lang}):")
-    for ent in doc.ents:
-        print(f"{ent.text} - {ent.label_}")
+    # Identificar conceptos clave
+    key_concepts = identify_key_concepts(doc)
+    
+    # Crear y visualizar grafo de conceptos
+    concept_graph = create_concept_graph(doc, key_concepts)
+    relations_graph = visualize_concept_graph(concept_graph, lang)
     
-    relations_graph = visualize_semantic_relations(doc, lang)
     return {
-        'entities': entities,
         'key_concepts': key_concepts,
         'relations_graph': relations_graph
     }
 
-__all__ = ['visualize_semantic_relations', 'create_semantic_graph', 'POS_COLORS', 'POS_TRANSLATIONS', 'identify_and_contextualize_entities']    
+__all__ = ['perform_semantic_analysis', 'ENTITY_LABELS', 'POS_TRANSLATIONS']

modules/text_analysis/semantic_analysis_v0.py

@@ -0,0 +1,264 @@
+#semantic_analysis.py
+import streamlit as st
+import spacy
+import networkx as nx
+import matplotlib.pyplot as plt
+from collections import Counter
+from collections import defaultdict
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+
+# Define colors for grammatical categories
+POS_COLORS = {
+    'ADJ': '#FFA07A',    # Light Salmon
+    'ADP': '#98FB98',    # Pale Green
+    'ADV': '#87CEFA',    # Light Sky Blue
+    'AUX': '#DDA0DD',    # Plum
+    'CCONJ': '#F0E68C',  # Khaki
+    'DET': '#FFB6C1',    # Light Pink
+    'INTJ': '#FF6347',   # Tomato
+    'NOUN': '#90EE90',   # Light Green
+    'NUM': '#FAFAD2',    # Light Goldenrod Yellow
+    'PART': '#D3D3D3',   # Light Gray
+    'PRON': '#FFA500',   # Orange
+    'PROPN': '#20B2AA',  # Light Sea Green
+    'SCONJ': '#DEB887',  # Burlywood
+    'SYM': '#7B68EE',    # Medium Slate Blue
+    'VERB': '#FF69B4',   # Hot Pink
+    'X': '#A9A9A9',      # Dark Gray
+}
+
+POS_TRANSLATIONS = {
+    'es': {
+        'ADJ': 'Adjetivo',
+        'ADP': 'Preposición',
+        'ADV': 'Adverbio',
+        'AUX': 'Auxiliar',
+        'CCONJ': 'Conjunción Coordinante',
+        'DET': 'Determinante',
+        'INTJ': 'Interjección',
+        'NOUN': 'Sustantivo',
+        'NUM': 'Número',
+        'PART': 'Partícula',
+        'PRON': 'Pronombre',
+        'PROPN': 'Nombre Propio',
+        'SCONJ': 'Conjunción Subordinante',
+        'SYM': 'Símbolo',
+        'VERB': 'Verbo',
+        'X': 'Otro',
+    },
+    'en': {
+        'ADJ': 'Adjective',
+        'ADP': 'Preposition',
+        'ADV': 'Adverb',
+        'AUX': 'Auxiliary',
+        'CCONJ': 'Coordinating Conjunction',
+        'DET': 'Determiner',
+        'INTJ': 'Interjection',
+        'NOUN': 'Noun',
+        'NUM': 'Number',
+        'PART': 'Particle',
+        'PRON': 'Pronoun',
+        'PROPN': 'Proper Noun',
+        'SCONJ': 'Subordinating Conjunction',
+        'SYM': 'Symbol',
+        'VERB': 'Verb',
+        'X': 'Other',
+    },
+    'fr': {
+        'ADJ': 'Adjectif',
+        'ADP': 'Préposition',
+        'ADV': 'Adverbe',
+        'AUX': 'Auxiliaire',
+        'CCONJ': 'Conjonction de Coordination',
+        'DET': 'Déterminant',
+        'INTJ': 'Interjection',
+        'NOUN': 'Nom',
+        'NUM': 'Nombre',
+        'PART': 'Particule',
+        'PRON': 'Pronom',
+        'PROPN': 'Nom Propre',
+        'SCONJ': 'Conjonction de Subordination',
+        'SYM': 'Symbole',
+        'VERB': 'Verbe',
+        'X': 'Autre',
+    }
+}
+########################################################################################################################################
+
+# Definimos las etiquetas y colores para cada idioma
+ENTITY_LABELS = {
+    'es': {
+        "Personas": "lightblue",
+        "Conceptos": "lightgreen",
+        "Lugares": "lightcoral",
+        "Fechas": "lightyellow"
+    },
+    'en': {
+        "People": "lightblue",
+        "Concepts": "lightgreen",
+        "Places": "lightcoral",
+        "Dates": "lightyellow"
+    },
+    'fr': {
+        "Personnes": "lightblue",
+        "Concepts": "lightgreen",
+        "Lieux": "lightcoral",
+        "Dates": "lightyellow"
+    }
+}
+
+#########################################################################################################
+def count_pos(doc):
+    return Counter(token.pos_ for token in doc if token.pos_ != 'PUNCT')
+
+#####################################################################################################################
+
+def create_semantic_graph(doc, lang):
+    G = nx.Graph()
+    word_freq = defaultdict(int)
+    lemma_to_word = {}
+    lemma_to_pos = {}
+
+    # Count frequencies of lemmas and map lemmas to their most common word form and POS
+    for token in doc:
+        if token.pos_ in ['NOUN', 'VERB']:
+            lemma = token.lemma_.lower()
+            word_freq[lemma] += 1
+            if lemma not in lemma_to_word or token.text.lower() == lemma:
+                lemma_to_word[lemma] = token.text
+            lemma_to_pos[lemma] = token.pos_
+
+    # Get top 20 most frequent lemmas
+    top_lemmas = [lemma for lemma, _ in sorted(word_freq.items(), key=lambda x: x[1], reverse=True)[:20]]
+
+    # Add nodes
+    for lemma in top_lemmas:
+        word = lemma_to_word[lemma]
+        G.add_node(word, pos=lemma_to_pos[lemma])
+
+    # Add edges
+    for token in doc:
+        if token.lemma_.lower() in top_lemmas:
+            if token.head.lemma_.lower() in top_lemmas:
+                source = lemma_to_word[token.lemma_.lower()]
+                target = lemma_to_word[token.head.lemma_.lower()]
+                if source != target:  # Avoid self-loops
+                    G.add_edge(source, target, label=token.dep_)
+
+    return G, word_freq
+
+############################################################################################################################################
+
+def visualize_semantic_relations(doc, lang):
+    G = nx.Graph()
+    word_freq = defaultdict(int)
+    lemma_to_word = {}
+    lemma_to_pos = {}
+
+    # Count frequencies of lemmas and map lemmas to their most common word form and POS
+    for token in doc:
+        if token.pos_ in ['NOUN', 'VERB']:
+            lemma = token.lemma_.lower()
+            word_freq[lemma] += 1
+            if lemma not in lemma_to_word or token.text.lower() == lemma:
+                lemma_to_word[lemma] = token.text
+            lemma_to_pos[lemma] = token.pos_
+
+    # Get top 20 most frequent lemmas
+    top_lemmas = [lemma for lemma, _ in sorted(word_freq.items(), key=lambda x: x[1], reverse=True)[:20]]
+
+    # Add nodes
+    for lemma in top_lemmas:
+        word = lemma_to_word[lemma]
+        G.add_node(word, pos=lemma_to_pos[lemma])
+
+    # Add edges
+    for token in doc:
+        if token.lemma_.lower() in top_lemmas:
+            if token.head.lemma_.lower() in top_lemmas:
+                source = lemma_to_word[token.lemma_.lower()]
+                target = lemma_to_word[token.head.lemma_.lower()]
+                if source != target:  # Avoid self-loops
+                    G.add_edge(source, target, label=token.dep_)
+
+    fig, ax = plt.subplots(figsize=(36, 27))
+    pos = nx.spring_layout(G, k=0.7, iterations=50)
+
+    node_colors = [POS_COLORS.get(G.nodes[node]['pos'], '#CCCCCC') for node in G.nodes()]
+
+    nx.draw(G, pos, node_color=node_colors, with_labels=True, 
+            node_size=10000, 
+            font_size=16, 
+            font_weight='bold', 
+            arrows=True, 
+            arrowsize=30, 
+            width=3, 
+            edge_color='gray',
+            ax=ax)
+
+    edge_labels = nx.get_edge_attributes(G, 'label')
+    nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=14, ax=ax)
+
+    title = {
+        'es': "Relaciones Semánticas Relevantes",
+        'en': "Relevant Semantic Relations",
+        'fr': "Relations Sémantiques Pertinentes"
+    }
+    ax.set_title(title[lang], fontsize=24, fontweight='bold')
+    ax.axis('off')
+
+    legend_elements = [plt.Rectangle((0,0),1,1,fc=POS_COLORS.get(pos, '#CCCCCC'), edgecolor='none', 
+                       label=f"{POS_TRANSLATIONS[lang].get(pos, pos)}")
+                       for pos in ['NOUN', 'VERB']]
+    ax.legend(handles=legend_elements, loc='center left', bbox_to_anchor=(1, 0.5), fontsize=16)
+
+    return fig
+
+############################################################################################################################################
+def identify_and_contextualize_entities(doc, lang):
+    entities = []
+    for ent in doc.ents:
+        # Obtener el contexto (3 palabras antes y después de la entidad)
+        start = max(0, ent.start - 3)
+        end = min(len(doc), ent.end + 3)
+        context = doc[start:end].text
+        
+        entities.append({
+            'text': ent.text,
+            'label': ent.label_,
+            'start': ent.start,
+            'end': ent.end,
+            'context': context
+        })
+    
+    # Identificar conceptos clave (usando sustantivos y verbos más frecuentes)
+    word_freq = Counter([token.lemma_.lower() for token in doc if token.pos_ in ['NOUN', 'VERB'] and not token.is_stop])
+    key_concepts = word_freq.most_common(10)  # Top 10 conceptos clave
+    
+    return entities, key_concepts
+
+
+############################################################################################################################################
+def perform_semantic_analysis(text, nlp, lang):
+    doc = nlp(text)
+
+    # Identificar entidades y conceptos clave
+    entities, key_concepts = identify_and_contextualize_entities(doc, lang)
+
+    # Visualizar relaciones semánticas
+    relations_graph = visualize_semantic_relations(doc, lang)
+    
+    # Imprimir entidades para depuración
+    print(f"Entidades encontradas ({lang}):")
+    for ent in doc.ents:
+        print(f"{ent.text} - {ent.label_}")
+    
+    relations_graph = visualize_semantic_relations(doc, lang)
+    return {
+        'entities': entities,
+        'key_concepts': key_concepts,
+        'relations_graph': relations_graph
+    }
+
+__all__ = ['visualize_semantic_relations', 'create_semantic_graph', 'POS_COLORS', 'POS_TRANSLATIONS', 'identify_and_contextualize_entities']    

modules/text_analysis/semantic_analysis_v00.py

@@ -0,0 +1,153 @@
+#semantic_analysis.py
+import streamlit as st
+import spacy
+import networkx as nx
+import matplotlib.pyplot as plt
+from collections import Counter, defaultdict
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+
+# Define colors for grammatical categories
+POS_COLORS = {
+    'ADJ': '#FFA07A', 'ADP': '#98FB98', 'ADV': '#87CEFA', 'AUX': '#DDA0DD',
+    'CCONJ': '#F0E68C', 'DET': '#FFB6C1', 'INTJ': '#FF6347', 'NOUN': '#90EE90',
+    'NUM': '#FAFAD2', 'PART': '#D3D3D3', 'PRON': '#FFA500', 'PROPN': '#20B2AA',
+    'SCONJ': '#DEB887', 'SYM': '#7B68EE', 'VERB': '#FF69B4', 'X': '#A9A9A9',
+}
+
+POS_TRANSLATIONS = {
+    'es': {
+        'ADJ': 'Adjetivo', 'ADP': 'Preposición', 'ADV': 'Adverbio', 'AUX': 'Auxiliar',
+        'CCONJ': 'Conjunción Coordinante', 'DET': 'Determinante', 'INTJ': 'Interjección',
+        'NOUN': 'Sustantivo', 'NUM': 'Número', 'PART': 'Partícula', 'PRON': 'Pronombre',
+        'PROPN': 'Nombre Propio', 'SCONJ': 'Conjunción Subordinante', 'SYM': 'Símbolo',
+        'VERB': 'Verbo', 'X': 'Otro',
+    },
+    'en': {
+        'ADJ': 'Adjective', 'ADP': 'Preposition', 'ADV': 'Adverb', 'AUX': 'Auxiliary',
+        'CCONJ': 'Coordinating Conjunction', 'DET': 'Determiner', 'INTJ': 'Interjection',
+        'NOUN': 'Noun', 'NUM': 'Number', 'PART': 'Particle', 'PRON': 'Pronoun',
+        'PROPN': 'Proper Noun', 'SCONJ': 'Subordinating Conjunction', 'SYM': 'Symbol',
+        'VERB': 'Verb', 'X': 'Other',
+    },
+    'fr': {
+        'ADJ': 'Adjectif', 'ADP': 'Préposition', 'ADV': 'Adverbe', 'AUX': 'Auxiliaire',
+        'CCONJ': 'Conjonction de Coordination', 'DET': 'Déterminant', 'INTJ': 'Interjection',
+        'NOUN': 'Nom', 'NUM': 'Nombre', 'PART': 'Particule', 'PRON': 'Pronom',
+        'PROPN': 'Nom Propre', 'SCONJ': 'Conjonction de Subordination', 'SYM': 'Symbole',
+        'VERB': 'Verbe', 'X': 'Autre',
+    }
+}
+
+ENTITY_LABELS = {
+    'es': {
+        "Personas": "lightblue",
+        "Lugares": "lightcoral",
+        "Inventos": "lightgreen",
+        "Fechas": "lightyellow",
+        "Conceptos": "lightpink"
+    },
+    'en': {
+        "People": "lightblue",
+        "Places": "lightcoral",
+        "Inventions": "lightgreen",
+        "Dates": "lightyellow",
+        "Concepts": "lightpink"
+    },
+    'fr': {
+        "Personnes": "lightblue",
+        "Lieux": "lightcoral",
+        "Inventions": "lightgreen",
+        "Dates": "lightyellow",
+        "Concepts": "lightpink"
+    }
+}
+
+def identify_and_contextualize_entities(doc, lang):
+    entities = []
+    for ent in doc.ents:
+        # Obtener el contexto (3 palabras antes y después de la entidad)
+        start = max(0, ent.start - 3)
+        end = min(len(doc), ent.end + 3)
+        context = doc[start:end].text
+        
+        # Mapear las etiquetas de spaCy a nuestras categorías
+        if ent.label_ in ['PERSON', 'ORG']:
+            category = "Personas" if lang == 'es' else "People" if lang == 'en' else "Personnes"
+        elif ent.label_ in ['LOC', 'GPE']:
+            category = "Lugares" if lang == 'es' else "Places" if lang == 'en' else "Lieux"
+        elif ent.label_ in ['PRODUCT']:
+            category = "Inventos" if lang == 'es' else "Inventions" if lang == 'en' else "Inventions"
+        elif ent.label_ in ['DATE', 'TIME']:
+            category = "Fechas" if lang == 'es' else "Dates" if lang == 'en' else "Dates"
+        else:
+            category = "Conceptos" if lang == 'es' else "Concepts" if lang == 'en' else "Concepts"
+        
+        entities.append({
+            'text': ent.text,
+            'label': category,
+            'start': ent.start,
+            'end': ent.end,
+            'context': context
+        })
+    
+    # Identificar conceptos clave (usando sustantivos y verbos más frecuentes)
+    word_freq = Counter([token.lemma_.lower() for token in doc if token.pos_ in ['NOUN', 'VERB'] and not token.is_stop])
+    key_concepts = word_freq.most_common(10)  # Top 10 conceptos clave
+    
+    return entities, key_concepts
+
+def create_concept_graph(text, concepts):
+    vectorizer = TfidfVectorizer()
+    tfidf_matrix = vectorizer.fit_transform([text])
+    concept_vectors = vectorizer.transform(concepts)
+    similarity_matrix = cosine_similarity(concept_vectors, concept_vectors)
+
+    G = nx.Graph()
+    for i, concept in enumerate(concepts):
+        G.add_node(concept)
+        for j in range(i+1, len(concepts)):
+            if similarity_matrix[i][j] > 0.1:
+                G.add_edge(concept, concepts[j], weight=similarity_matrix[i][j])
+
+    return G
+
+def visualize_concept_graph(G, lang):
+    fig, ax = plt.subplots(figsize=(12, 8))
+    pos = nx.spring_layout(G)
+    
+    nx.draw_networkx_nodes(G, pos, node_size=3000, node_color='lightblue', ax=ax)
+    nx.draw_networkx_labels(G, pos, font_size=10, font_weight="bold", ax=ax)
+    nx.draw_networkx_edges(G, pos, width=1, ax=ax)
+    
+    edge_labels = nx.get_edge_attributes(G, 'weight')
+    nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=8, ax=ax)
+
+    title = {
+        'es': "Relaciones Conceptuales",
+        'en': "Conceptual Relations",
+        'fr': "Relations Conceptuelles"
+    }
+    ax.set_title(title[lang], fontsize=16)
+    ax.axis('off')
+
+    return fig
+
+def perform_semantic_analysis(text, nlp, lang):
+    doc = nlp(text)
+
+    # Identificar entidades y conceptos clave
+    entities, key_concepts = identify_and_contextualize_entities(doc, lang)
+
+    # Crear y visualizar grafo de conceptos
+    concepts = [concept for concept, _ in key_concepts]
+    concept_graph = create_concept_graph(text, concepts)
+    relations_graph = visualize_concept_graph(concept_graph, lang)
+    
+    return {
+        'entities': entities,
+        'key_concepts': key_concepts,
+        'relations_graph': relations_graph
+    }
+
+__all__ = ['perform_semantic_analysis', 'ENTITY_LABELS', 'POS_TRANSLATIONS']

modules/ui/ui.py

@@ -58,14 +58,16 @@ from ..text_analysis.morpho_analysis import (
 
 ######################################################
 from ..text_analysis.semantic_analysis import (
-    visualize_semantic_relations,
-    perform_semantic_analysis
+    #visualize_semantic_relations,
+    perform_semantic_analysis, 
+    create_concept_graph, 
+    visualize_concept_graph
 )
 
 ######################################################
 from ..text_analysis.discourse_analysis import (
-    compare_semantic_analysis,
-    perform_discourse_analysis
+    perform_discourse_analysis, 
+    display_discourse_analysis_results
 )
 
 ######################################################
@@ -763,7 +765,7 @@ def display_semantic_analysis_interface(nlp_models, lang_code):
             'text_input_placeholder': "El objetivo de esta aplicación es que mejore sus habilidades de redacción...",
             'file_uploader': "O cargue un archivo de texto",
             'analyze_button': "Analizar texto",
-            'semantic_relations': "Relaciones Semánticas Relevantes",
+            'conceptual_relations': "Relaciones Conceptuales",
             'identified_entities': "Entidades Identificadas",
             'key_concepts': "Conceptos Clave",
             'success_message': "Análisis semántico guardado correctamente.",
@@ -776,7 +778,7 @@ def display_semantic_analysis_interface(nlp_models, lang_code):
             'text_input_placeholder': "The goal of this application is to improve your writing skills...",
             'file_uploader': "Or upload a text file",
             'analyze_button': "Analyze text",
-            'semantic_relations': "Relevant Semantic Relations",
+            'conceptual_relations': "Conceptual Relations",
             'identified_entities': "Identified Entities",
             'key_concepts': "Key Concepts",
             'success_message': "Semantic analysis saved successfully.",
@@ -789,7 +791,7 @@ def display_semantic_analysis_interface(nlp_models, lang_code):
             'text_input_placeholder': "L'objectif de cette application est d'améliorer vos compétences en rédaction...",
             'file_uploader': "Ou téléchargez un fichier texte",
             'analyze_button': "Analyser le texte",
-            'semantic_relations': "Relations Sémantiques Pertinentes",
+            'conceptual_relations': "Relations Conceptuelles",
             'identified_entities': "Entités Identifiées",
             'key_concepts': "Concepts Clés",
             'success_message': "Analyse sémantique enregistrée avec succès.",
@@ -824,18 +826,11 @@ def display_semantic_analysis_interface(nlp_models, lang_code):
 
             # Mostrar conceptos clave
             with st.expander(t['key_concepts'], expanded=True):
-                key_concepts_text = " ".join([f"[[{concept}]]" for concept, _ in analysis_result['key_concepts']])
-                st.markdown(key_concepts_text)
-
-            # Mostrar entidades identificadas
-            with st.expander(t['identified_entities'], expanded=True):
-                entities_text = ""
-                for entity in analysis_result['entities']:
-                    entities_text += f"[[{entity['text']} ({entity['label']}) - Contexto: {entity['context']}]] "
-                st.markdown(entities_text)
-
-            # Mostrar el gráfico de relaciones semánticas
-            with st.expander(t['semantic_relations'], expanded=True):
+                concept_text = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in analysis_result['key_concepts']])
+                st.write(concept_text)
+
+            # Mostrar el gráfico de relaciones conceptuales
+            with st.expander(t['conceptual_relations'], expanded=True):
                 st.pyplot(analysis_result['relations_graph'])
 
             # Guardar el resultado del análisis
@@ -845,7 +840,6 @@ def display_semantic_analysis_interface(nlp_models, lang_code):
                 st.error(t['error_message'])
         else:
             st.warning(t['warning_message'])
-
 ##################################################################################################
 def display_discourse_analysis_interface(nlp_models, lang_code):
     translations = {
@@ -898,19 +892,13 @@ def display_discourse_analysis_interface(nlp_models, lang_code):
             text_content2 = uploaded_file2.getvalue().decode('utf-8')
 
             # Realizar el análisis
-            graph1, graph2 = perform_discourse_analysis(text_content1, text_content2, nlp_models[lang_code], lang_code)
+            analysis_result = perform_discourse_analysis(text_content1, text_content2, nlp_models[lang_code], lang_code)
 
-            # Mostrar los gráficos de comparación
-            st.subheader(t['comparison'])
-            col1, col2 = st.columns(2)
-            with col1:
-                st.pyplot(graph1)
-            with col2:
-                st.pyplot(graph2)
+            # Mostrar los resultados del análisis
+            display_discourse_analysis_results(analysis_result, lang_code)
 
             # Guardar el resultado del análisis
-            #if store_discourse_analysis_result(st.session_state.username, text_content1 + "\n\n" + text_content2, graph1, graph2):
-            if store_discourse_analysis_result(st.session_state.username, text_content1, text_content2, graph1, graph2):    
+            if store_discourse_analysis_result(st.session_state.username, text_content1, text_content2, analysis_result):
                 st.success(t['success_message'])
             else:
                 st.error(t['error_message'])