Filtrado y Visualización de Frecuencias de Palabras con NLTK y NumPy

Clase 9 de 24 • Curso de Fundamentos de Procesamiento de Lenguaje Natural con Python y NLTK

Resumen

¿Cómo abordar las distribuciones de frecuencia en un corpus de texto?

Las distribuciones de frecuencia de palabras nos permiten entender qué términos son más frecuentes dentro de un texto, pero es necesario filtrar estas distribuciones para identificar palabras verdaderamente relevantes. Al analizar un documento o corpus de datos, como libros, tweets, o cualquier otro tipo de colección textual, es vital separar las palabras con contenido semántico importante de aquellas que simplemente sirven como conectores.

¿Qué hicimos en nuestra clase anterior?

Anteriormente, utilizamos la librería nltk y su método FreqDist para calcular la distribución de frecuencia de palabras en el libro "Moby Dick". Sin embargo, las palabras más frecuentes no siempre son las más relevantes desde un punto de vista semántico o gramatical.

Usamos FreqDist para identificar las palabras más comunes en un texto.
Observamos que muchas de estas palabras no aportan información valiosa sobre el contenido del texto.

¿Cómo filtrar las palabras más relevantes?

Para obtener palabras que realmente nos aporten información, creamos un filtro basado en la longitud de las palabras. Este proceso nos permitió eliminar elementos no semánticos, como signos de puntuación y palabras de uso muy común que no agregan relevancia.

long_words = [palabra for palabra in text1 if len(palabra) > 5]

¿Cómo creamos un nuevo vocabulario filtrado y su distribución?

Después de filtrar las palabras, generamos un nuevo vocabulario con las palabras relevantes ordenadas alfabéticamente:

vocabulario_filtrado = sorted(set(long_words))

Luego, construimos una nueva distribución de frecuencias para este vocabulario reducido:

palabras_interesantes = [(palabra, f_dist[palabra]) for palabra in vocabulario_filtrado if f_dist[palabra] > 10]

¿Cómo transformamos datos a objetos NumPy?

La transformación de datos a un formato NumPy nos permite operar con los datos de manera más eficiente, especialmente cuando se trata de ordenar listas con grandes volúmenes de datos:

import numpy as np

d_types = [('word', 'U50'), ('frequency', 'int')]
palabras_interesantes = np.array(palabras_interesantes, dtype=d_types)
palabras_interesantes = np.sort(palabras_interesantes, order='frequency')

¿Cómo visualizar las distribuciones ordenadas con Matplotlib?

Finalmente, podemos visualizar esta nueva distribución utilizando Matplotlib, una herramienta poderosa para gráficos:

import matplotlib.pyplot as plt

plt.figure(figsize=(10, 5))
plt.plot(range(len(palabras_interesantes)), [item[1] for item in palabras_interesantes])
plt.xticks(rotation='vertical')
plt.grid(True)
plt.show()

Este análisis no solo es aplicable a libros sino también puede ser extendido a análisis de redes sociales, investigación de mercado, y cualquier tipo de investigación lingüística, ya que las palabras más frecuentes rara vez cuentan toda la historia. Estas técnicas te permiten profundizar más y sacar el máximo provecho de tus datos textuales. ¡Sigue explorando y perfeccionando estas herramientas para extraer insights valiosos!

Tatiana Novoa

student•

Para lo de quitar las palabras que no generan valor yo suelo usar librerías que contienen listas de stopwords, dado que siento que haciéndolo por la longitud de la palabra igual podríamos estar perdiendo datos útiles

from nltk.corpus import stopwords

Francisco Camacho

teacher•

asi es, en eso tienes toda la razón, un paso fundamental es remover stopwords.

Sergio Argel

student•

Gracias por el dato. Hay una palabra que extraño y que dice mucho (frecuencia 906) es 'whale' que por su longitud no entra en el filtro realizado, de hecho es la palabra 'más interesante' en este texto.

Carlos Chavez

student•

Excelente profesor.El poder de lo sencillo es propio de verdaderos conocedores.Muy bien estructurado el curso.Esta ventana de tecnología es asombrosa y completamente descrestante. El conocimiento se vuelve infinito y es una fantasía ver lo que ha sido capaz de desarrollar el hombre

Francisco Camacho

teacher•

así es Carlos, es maravilloso, y por eso es que nunca deja de ser interesante seguir aprendiendo cosas nuevas, ya verás como en los próximos cursos se vienen cosas mas avanzadas y sorprendentes

Johan Emanuel Palacios Rivera

student•

Opino lo mismo muy buen curso

Ronald Espinoza

student•

Grafica lo mismo.

top_words = 20
palabras_interesantes = np.sort(palabras_interesantes, order = 'frecuency')[-top_words:]
x = palabras_interesantes['word']
y = palabras_interesantes['frecuency']
plt.figure(figsize=(10,5))
plt.plot(x,y)
plt.xticks(x,rotation='vertical')
plt.grid(True)
plt.show()```

Geovany Uribe Aguirre

student•

¿Para qué usamos?: top_words = 20 x = np.arange(len(palabras_interesantes[-top_words:])) En vez de: top_words = 20 x = np.arange(top_words)

Alberto Perdomo

student•

Como lo yo veo no hay ninguna diferencia, seguro es el estilo del profesor. Cada quien tiene el propio

Francisco Camacho

teacher•

haha, asi es , fue solo estilo, ambas maneras funcionan y la tuya es mas elegante, yo lo voy escribiendo asi porque pense de manera diferente, antes de hacer el np.arange (estaba mirando el contenido preciso de palabras_interesantes[-top_words:]

Alan Vazquez

student•

import nltk

nltk.download('book')
nltk.download('stopwords')

from nltk.corpus import stopwords
from nltk.book import *

stop_words = stopwords.words('english')

from collections import Counter

import matplotlib.pyplot as plt
import numpy as np
import re

%matplotlib inline

def fdist(corpus):
    pattern = r'\w+(?:-\w+)*'
    search = re.compile(pattern)

    lower = [word.lower() for word in corpus]
    counts = Counter(lower)

    for word, count in counts.items():
        if not search.search(word):
            continue

        if word not in stop_words:
            yield word, count

dtypes = [('word', 'U15'), ('frequency', int)]
words = np.array( list(fdist(text1)), dtype=dtypes )
words = np.sort(words, order='frequency')[::-1]

n_words = 21
x, y = zip(*words[:n_words])

plt.figure(figsize=(12,5))

plt.plot(x, y)
plt.xticks(x, rotation=60)

plt.show()

Carlos Alberto Roque Torrealba

student•

No se si mas adelante en el curso lo realiza, pero pienso que una de las primeras cosas que se deberia realizar es colocar todas las palabras en mayúsculas o minúsculas

César Pérez

student•

He creado lo que considero un mejor filtro, en lugar de usar solo la longitud de las palabras para descartarlas, he utilizado una lista de stopwords

interesting_words = [(w,fdist[w]) for w in set(text1) if re.search(r'[\w]+',w) and w not in stopwords.words('english') and fdist[w]>10 and len(w)>1]

jimmy ibañez

student•

En el NLP podemos convertir cadenas de texto a tokens pero solo con eso traeremos también información que nada aporta al modelo, para ello debemos filtrar todos los caracteres especiales y palabras que no aporten.

Tamaño de cadena

Uno de los métodos para filtrado es por la cantidad de caracteres que posee

long_words  = [palabra for palabra in text1 if len(palabra)>5]
vocabulario_filtrado = sorted(set(long_words))
vocabulario_filtrado[:10]

Frecuencia

También la frecuencia es un valor a tener en cuenta

Podemos ahora construir una lista de tuplas, basados en los conteos ya pre-calculados de la funcion FreqDist, asi:

fdist_filtrado = [('account',2), ('additional',32), ('advancing',5)...]

Luego podemos conveertir el objeto creado a formato de np.array de Numpypara podeer haceer un sort por palabras mas frecuentes.

fdist_filtrado = np.array(fdist_filtrado, *arg)

np.sort(fdist_filtado, *arg)=[('account',2), ('additional',32), ('advancing',5)..]
```
palabras_interesantes = [(palabra, fdist[palabra])  for palabra in set(text1) if len(palabra)>5 and fdist[palabra]>10]
dtypes= [('word', 'S10'), ('frequency', int)]

palabras_interesantes=  np.array(palabras_interesantes, dtype= dtypes)
```
Esto le dara un orden según la frecuencia
```
palabras_interesantes = np.sort(palabras_interesantes, order= 'frequency')
palabras_interesantes
```

Graficar palabras mas interesantes

top_words=20
x= np.arange(len(palabras_interesantes[-top_words:]))
y = [freq[1] for freq in palabras_interesantes[-top_words:]]

plt.figure(figsize=(10,5))
plt.plot(x,y)
plt.xticks(x,[str(freq[0]) for freq  in palabras_interesantes[-top_words:]], rotation = 'vertical')
plt.grid(True)
plt.show()

Joel Eduardo Gaspar

student•

Utilicé el método del profe y además stopwords ya que con solo stopwords me dejaba los puntos y corchetes, etc

from nltk.corpus import stopwords
stop_words = set(stopwords.words('english'))
long_words = [palabra for palabra in text1 if not palabra in stop_words]
long_words = [palabra for palabra in text1 if len(palabra) > 2]
long_words[:20]
['Moby',
 'Dick',
 'Herman',
 'Melville',
 '1851',
 'ETYMOLOGY',
 'Supplied',
 'Late',
 'Consumptive',
 'Usher',
 'Grammar',
 'School',
 'The',
 'pale',
 'Usher',
 'threadbare',
 'coat',
 'heart',
 'body',
 'and']

Joel Eduardo Gaspar

student•

Me di cuenta que esto me seguía trayendo otras combinaciones de caracteres como '--', '!--' y cosas por el estilo, así que hice esta otra implementación:

long_words = [palabra for palabra in text1 
                if not palabra in stop_words 
                and palabra in str(re.search('[a-zA-Z]{2,}', palabra))]

Así solo traigo letras compuestas de caracteres del alfabeto, si quisiera traer también números sólo sería añadir 0-9 a a regex

Joel Eduardo Gaspar

student•

interesting_words = [(palabra, fdist[palabra]) for palabra in set(text1) 
                     if not palabra in stop_words 
                     and palabra in str(re.search('[a-zA-Z]{2,}', palabra)) 
                     and fdist[palabra] > 10]

Edwin Cubillos

student•

import nltk nltk.download(‘stopwords’)

stop_words = set(stopwords.words(‘spanish’))

filtered_sentence = [w for w in text if not w.lower() in stop_words]

Camilo Andrés Patiño Restrepo

student•

¿Existe alguna librería o función que contenga todas las preposiciones en cada idioma o por lo menos en español e inglés?

Marianela Arcila Sanchez

student•

no se si todas pero puedes filtrarlas por medio de las stop words de nltk

from nltk.corpus import stopwords
stop_words =stopwords.words("spanish")
stop_words

Hugo Fernandez Quiroz

student•

Pueden quitar las palabras que no generan valor usando la libreria stopwords

from nltk.corpus import stopwords
stops = set(stopwords.words('english'))
print(stops)

Henry Mendiburu Díaz

student•

Para obtener strings en formato unicode y no en bytes ('b'....)

dtypes = [('word', 'U10'), ('frequency', int)]

Luis Suárez

student•

Hay un pequeño detalle a contemplar. Si contamos solo con las palabras mayores a 5 caracteres en español por ejemplo dejamos palabras afuera como amor, malo, feo, lindo. Es entendíble que es un ejercicio pero en este caso hay que tener en cuenta que las palabras_++ no se debe filtrar de esa manera++_

Saludos

Marcelo Sánchez

student•

Cuando ponemos una cantidad de 200 palabras, se observa la preferencia del autor a utilizar ciertas palabras.

Enrique Ortuno

student•

Esta es una forma alternativa y yo considero mas legible

top_words = 20
# x seran las palabras e y = seran la cantidad de veces que aparecen
# x, y tienen que ser arrays para poder ser graficados
# con np.arrange(len... estamos crando un array de las longitudes de las palabras
# palabras_interesantes[-top_words:]['word']
# Esto creara un arreglo de numeros enteros de 0..top_words (top_words elementos)
x = np.arange(len(palabras_interesantes[-top_words:]))
# Esto me devuelve las frecuencias para cada x
y = palabras_interesantes[-top_words:]['frequency']

# Dimensionar la imagen
plt.figure(figsize=(10, 5))
plt.xticks (x, palabras_interesantes[-top_words:]['word'], rotation='vertical')
# Renderizar los valores
plt.plot (x,y)
# Colocar un grid de background
plt.grid(True)
# Finalmentem, mostrar el grafico
plt.show()

Gabriel Obregón

student•

🧠Distribuciones de Frecuencia en un Corpus de Texto

🔍 1. Qué son las distribuciones de frecuencia

📘 Definición: Muestran cuántas veces aparece cada palabra dentro de un texto o conjunto de textos (corpus).

🎯 Propósito: Detectar los términos más representativos del contenido.

⚠️ Atención: Las palabras más frecuentes no siempre son las más importantes —muchas son conectores o artículos (como “el”, “y”, “de”).

💡 Clave: Filtrar las palabras ayuda a centrarse en las que aportan significado real.

🧩 2. Lo que hicimos en clase

🧠 Herramienta: nltk ⚙️ Método: FreqDist

🔸 Pasos realizados:

Analizamos Moby Dick para obtener la frecuencia de palabras.
Notamos que muchas palabras comunes no eran relevantes. Decidimos crear un filtro para mejorar el análisis.

🧾 Ejemplo de código:

from nltk import FreqDist

f_dist = FreqDist(text1)

✂️ 3. Filtrar palabras relevantes

🧰 Estrategia: Eliminar palabras cortas, signos o conectores. Nos quedamos solo con las que tienen más de 5 caracteres.

🧾 Ejemplo:

long_words = [palabra for palabra in text1 if len(palabra) > 5]

✅ Resultado: Una lista de palabras más largas y significativas.

📚 4. Crear un vocabulario filtrado

🔹 Paso 1: Ordenar las palabras alfabéticamente

vocabulario_filtrado = sorted(set(long_words))

🔹 Paso 2: Calcular su frecuencia (solo si aparecen más de 10 veces)

palabras_interesantes = [(palabra, f_dist[palabra])

for palabra in vocabulario_filtrado

if f_dist[palabra] > 10]

📈 Resultado: Una lista ordenada con palabras relevantes y su frecuencia.

⚙️ 5. Optimizar con NumPy

🧮 Por qué usarlo: NumPy permite ordenar y procesar datos masivos de manera rápida y eficiente.

🧾 Implementación:

import numpy as np

d_types = [('word', 'U50'), ('frequency', 'int')]

palabras_interesantes = np.array(palabras_interesantes, dtype=d_types)

palabras_interesantes = np.sort(palabras_interesantes, order='frequency')

🚀 Ventaja: Obtienes un conjunto de datos ordenado y listo para análisis o visualización.

📊 6. Visualizar los resultados con Matplotlib

🎨 Objetivo: Representar gráficamente la frecuencia de las palabras.

🧾 Código:

import matplotlib.pyplot as plt

plt.figure(figsize=(10, 5))

plt.plot(range(len(palabras_interesantes)), [item[1] for item in palabras_interesantes])

plt.xticks(rotation='vertical')

plt.grid(True)

plt.show()

📉 Qué muestra: La distribución de las palabras más frecuentes después del filtrado.

Juan Pablo Rodriguez Pedraos

student•

Para la última parte en que grafican, creo que se simplifica, y es más optimo usar directamente las columnas que provee numpy como x y y, así no hace falta iterar en arreglos ni tampoco sobreescribir las etiquetas en x.

top_words = 20
palabras_top = palabras_ordenadas[-top_words:]
x = palabras_top['word']
y = palabras_top['frequency']

plt.figure(figsize=(10,5))
plt.plot(x, y)
plt.xticks(rotation="vertical")
plt.tick_params(labelsize = 'xx-large')
plt.grid(True)
plt.show()

Carlos Arteaga

student•

en mi caso el codigo que me sirvio fue este dtype = [('palabra', 'U10'), ('frecuencia', int)]palabras_interesantes_array = (np.array(palabras_interesantes, dtype=dtype))palabras_interesantes_array

Jhon Freddy Tavera Blandon

student•

El refinamiento del texto es un proceso clave en NLP que incluye limpieza, normalización, tokenización y la eliminación de stopwords. Tras esto, la visualización mediante gráficos de frecuencia, nubes de palabras y análisis de bigramas ayuda a extraer información significativa del texto.