Detección de la coherencia en textos utilizando Python y la librería NLTK

La coherencia en los textos es fundamental para su comprensión por parte del lector. Cuando un texto no tiene coherencia, resulta difícil entenderlo y se pierde el mensaje que se intenta transmitir. En este tutorial, aprenderemos a utilizar Python y la librería NLTK para detectar la coherencia en textos.

Instalación de NLTK

Antes de comenzar, debemos asegurarnos de tener instalada la librería NLTK. Si aún no la tiene instalada, podemos hacerlo mediante pip, el gestor de paquetes de Python.


   pip install nltk

Carga de Texto

Primero, debemos cargar el texto que deseamos analizar. Este texto puede ser un archivo en formato .txt o una cadena de texto.


   import nltk
   from nltk.tokenize import word_tokenize
   nltk.download('punkt')

   # Carga del texto desde un archivo
   with open('texto.txt', 'r') as f:
      texto = f.read()

   # Carga del texto desde una cadena de caracteres
   texto = "Este es un ejemplo de texto para analizar la coherencia."

Tokenización de Palabras

Para poder analizar la coherencia en el texto, debemos separar las palabras en el mismo. Esto lo logramos mediante la tokenización.


   # Tokenización de palabras
   palabras = word_tokenize(texto)

Eliminación de Stopwords

Las stopwords son palabras que no aportan significado al texto, y por lo tanto, no son tomadas en cuenta en el análisis de coherencia. Podemos eliminarlas mediante la librería NLTK.


   nltk.download('stopwords')
   from nltk.corpus import stopwords

   # Eliminación de stopwords
   palabras_sin_stopwords = [palabra for palabra in palabras if palabra.casefold() not in stopwords.words('spanish')]

Análisis de Coherencia

Para analizar la coherencia en el texto, utilizaremos el algoritmo de Latent Semantic Analysis (LSA) de la librería NLTK. Este algoritmo busca la relación semántica entre las palabras en el texto.


   from nltk.corpus import brown
   from nltk.corpus import stopwords
   from nltk.cluster.util import cosine_distance
   import numpy as np

   sentences = nltk.sent_tokenize(texto)

   def sentence_similarity(sent1, sent2, stopwords=None):
       if stopwords is None:
           stopwords = []
 
       sent1 = [w.lower() for w in sent1]
       sent2 = [w.lower() for w in sent2]
 
       all_words = list(set(sent1 + sent2))
 
       vector1 = [0] * len(all_words)
       vector2 = [0] * len(all_words)
 
       for w in sent1:
           if w in stopwords:
               continue
           vector1[all_words.index(w)] += 1
 
       for w in sent2:
           if w in stopwords:
               continue
           vector2[all_words.index(w)] += 1
 
       return 1 - cosine_distance(vector1, vector2)

   def build_similarity_matrix(sentences, stopwords=None):
       # Create an empty similarity matrix
       similarity_matrix = np.zeros((len(sentences), len(sentences)))
 
       for idx1 in range(len(sentences)):
           for idx2 in range(len(sentences)):
               if idx1 == idx2:
                   continue 
               similarity_matrix[idx1][idx2] = sentence_similarity(sentences[idx1], sentences[idx2], stopwords)
 
       return similarity_matrix

   def generate_summary(text, top_n=5):
       nltk.download("punkt")
       nltk.download("stopwords")
       stop_words = stopwords.words('spanish')
       summarize_text = []

       # Step 1 - Read text anc split it
       sentences = nltk.sent_tokenize(text)

       # Step 2 - Generate Similary Martix across sentences
       sentence_similarity_martix = build_similarity_matrix(sentences, stop_words)

       # Step 3 - Rank sentences in similarity martix
       sentence_similarity_graph = nx.from_numpy_array(sentence_similarity_martix)
       scores = nx.pagerank(sentence_similarity_graph)

       # Step 4 - Sort the rank and pick top sentences
       ranked_sentence = sorted(((scores[i],s) for i,s in enumerate(sentences)), reverse=True)    
       for i in range(top_n):
         summarize_text.append("".join(ranked_sentence[i][1]))

       # Step 5 - Offcourse, output the summarize text
       return summarize_text

    # Generación de resumen
    resumen = generate_summary(texto, 3)

En este tutorial aprendimos a utilizar Python y la librería NLTK para detectar la coherencia en textos mediante el algoritmo LSA. Esto nos permite mejorar la comprensión y calidad de los textos que escribimos o leemos. ¡Esperamos que este tutorial haya sido de ayuda!