Extracción de palabras clave | Extracción de palabras clave en Python

Este post fue difundido como parte del Blogatón de ciencia de datos.

Introducción

Los datos no estructurados contienen una gran cantidad de información. Es como la energía cuando se aprovecha, creará un alto valor para sus partes interesadas. Varias compañías ya están trabajando mucho en este ámbito. No hay duda de que los datos no estructurados son ruidosos y se debe realizar un trabajo significativo para limpiarlos, analizarlos y hacerlos significativos para su uso. Este post habla sobre un área que ayuda a analizar grandes cantidades de datos al resumir el contenido e identificar temas de interés: Extracción de palabras clave

Descripción general de la extracción de palabras clave

Es una técnica de análisis de texto. Podemos obtener importantes conocimientos sobre el tema en un corto período de tiempo. Ayuda a concisar el texto y obtener palabras clave relevantes. Ahorra el tiempo de revisar todo el documento. Los casos de uso de ejemplo son hallar temas de interés en un post de noticias e identificar los problemas en función de las opiniones de los clientes, etc. Una de las técnicas utilizadas para la extracción de palabras clave es TF-IDF (frecuencia de término – frecuencia de documento inverso)

TF – Descripción general de las FDI

Frecuencia de término – Con qué frecuencia aparece una definición en un texto. Se mide como el número de veces que aparece una definición t en el texto / Número total de palabras en el documento

Frecuencia de documento inversa – Qué relevancia dispone de una palabra en un documento. Se mide como log (número total de oraciones / Número de oraciones con término t)

TF-IDF – La relevancia de las palabras se mide por esta puntuación. Se mide como TF * IDF

Usaremos el mismo concepto e intentaremos codificarlo línea por línea usando Python. Tomaremos un conjunto más pequeño de documentos de texto y realizaremos todos los pasos anteriores. Aunque ya existen en el mercado conceptos más avanzados para la extracción de palabras clave, este post tiene como objetivo comprender el concepto básico detrás de la identificación de la relevancia de las palabras. ¡Comencemos!

Implementación

1. Importar paquetes

Necesitamos tokenizar para crear tokens de palabras, itemgetter para ordenar el diccionario y matemáticas para realizar la operación log base e

from nltk import tokenize
from operator import itemgetter
import math

2. Declarar variables

Declararemos una variable de cadena. Será un marcador de posición para el documento de texto de muestra.

doc="I am a graduate. I want to learn Python. I like learning Python. Python is easy. Python is interesting. Learning increases thinking. Everyone should invest time in learning"

3. Quite las palabras vacías

Las palabras vacías son las palabras que aparecen a menudo y que pueden no tener relevancia para nuestro análisis. Podemos borrar el uso de la biblioteca nltk

import nltk
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize 
stop_words = set(stopwords.words('english'))

4. Encuentra el total de palabras en el documento.

Esto será necesario al calcular la frecuencia de término

total_words = doc.split()
total_word_length = len(total_words)
print(total_word_length)

5. Calcula el número total de oraciones

Esto será necesario al calcular la frecuencia inversa del documento.

total_sentences = tokenize.sent_tokenize(doc)
total_sent_len = len(total_sentences)
print(total_sent_len)

6. Calcula TF para cada palabra

Comenzaremos calculando el recuento de palabras para cada palabra sin parar y en conclusión dividiremos cada elemento por el resultado del paso 4

tf_score = {}
for each_word in total_words:
    each_word = each_word.replace('.','')
    if each_word not in stop_words:
        if each_word in tf_score:
            tf_score[each_word] += 1
        else:
            tf_score[each_word] = 1

# Dividing by total_word_length for each dictionary element
tf_score.update((x, y/int(total_word_length)) for x, y in tf_score.items())
print(tf_score)

7. Función para chequear si la palabra está presente en una lista de frases.

Este método será necesario al calcular la IDF.

def check_sent(word, sentences): 
    final = [all([w in x for w in word]) for x in sentences] 
    sent_len = [sentences[i] for i in range(0, len(final)) if final[i]]
    return int(len(sent_len))

8. Calcule el IDF para cada palabra.

Usaremos la función en el paso 7 para iterar la palabra sin parar y almacenar el resultado para la frecuencia inversa del documento.

idf_score = {}
for each_word in total_words:
    each_word = each_word.replace('.','')
    if each_word not in stop_words:
        if each_word in idf_score:
            idf_score[each_word] = check_sent(each_word, total_sentences)
        else:
            idf_score[each_word] = 1

# Performing a log and divide
idf_score.update((x, math.log(int(total_sent_len)/y)) for x, y in idf_score.items())

print(idf_score)

9. Calcular TF * IDF

Dado que la clave de ambos diccionarios es la misma, podemos iterar un diccionario para obtener las claves y multiplicar los valores de ambos

tf_idf_score = {key: tf_score[key] * idf_score.get(key, 0) for key in tf_score.keys()}
print(tf_idf_score)

10. Cree una función para obtener N palabras importantes en el documento

def get_top_n(dict_elem, n):
    result = dict(sorted(dict_elem.items(), key = itemgetter(1), reverse = True)[:n]) 
    return result

11. Obtenga las 5 palabras más importantes

print(get_top_n(tf_idf_score, 5))

Conclusión

Entonces, ¡esta es una de las formas en que puede construir su propio extractor de palabras clave en Python! Los pasos anteriores se pueden resumir de una manera simple como Documento -> Borrar palabras vacías -> Buscar frecuencia de término (TF) -> Buscar frecuencia de documento inverso (IDF) -> Buscar TF * IDF -> Obtener las N mejores palabras clave. Comparta sus pensamientos si este post fue interesante o lo ayudó de alguna manera. Siempre abierto a mejoras y sugerencias. Puedes hallar el código en GitHub

Relacionado