Extração de palavras-chave | Extração de palavras-chave em Python

Esta postagem foi lançada como parte do Data Science Blogathon.

Introdução

Dados não estruturados contêm uma grande quantidade de informações. É como energia quando aproveitada, criará alto valor para seus stakeholders. Várias empresas já estão a fazer muito trabalho nesta área. Não há dúvida de que dados não estruturados são ruidosos e um trabalho significativo precisa ser feito para limpá-los., analisá-los e torná-los significativos para uso. Este post fala sobre uma área que ajuda a analisar grandes quantidades de dados resumindo conteúdos e identificando tópicos de interesse.: Extração de palavras-chave

Visão geral da extração de palavras-chave

É uma técnica de análise de texto. Podemos obter insights importantes sobre o assunto em um curto período de tempo. Ajuda a concisar o texto e obter palavras-chave relevantes. Economize tempo revisando todo o documento. Exemplos de casos de uso são encontrar tópicos de interesse em uma postagem de notícias e identificar problemas com base no feedback do cliente, etc. Uma das técnicas usadas para extração de palavras-chave é o TF-IDF (frequência do termo – frequência de documentos reversos)

TF – Visão geral do IDF

Frequência do termo – Com que frequência uma definição aparece em um texto. É medido como o número de vezes que uma definição t aparece no texto / Número total de palavras no documento

Reverter a frequência do documento – Quão relevante é uma palavra em um documento. Se mide como log (número total de frases / Número de frases com termo t)

TF-IDF – A relevância das palavras é medida por este escore. Medido como TF * IDF

Usaremos o mesmo conceito e tentaremos codificar linha por linha usando Python. Pegaremos um conjunto menor de documentos de texto e executaremos todas as etapas acima. Embora já existam conceitos mais avançados para extração de palavras-chave no mercado, Este post tem como objetivo entender o conceito básico por trás da identificação da relevância das palavras. Vamos começar!

Implementação

1. Pacotes de importação

Precisamos tokenizar para criar tokens de palavras, itemgetter para classificar o dicionário e matemática para executar a operação de registro base e

from nltk import tokenize
from operator import itemgetter
import math

2. Declarar variáveis

Vamos declarar uma variável de string. este será um espaço reservado para o documento de texto amostral.

doc="Eu sou um graduado. Eu quero aprender Python. Eu gosto de aprender Python. Python é fácil. Python é interessante. Aprender aumenta o pensamento. Todos devem investir tempo no aprendizado"

3. Remova palavras vazias

Palavras vazias são as palavras que aparecem com frequência e podem não ter relevância para nossa análise.. Podemos excluir o uso da biblioteca nltk

import nltk
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize 
stop_words = set(stopwords.words('inglês'))

4. Encontre o número total de palavras no documento.

Isso será necessário ao calcular a frequência de termo

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

5. Calcule o número total de sentenças

isso será necessário ao calcular a frequência reversa do documento.

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

6. Calcular TF para cada palavra

Começaremos calculando a contagem de palavras para cada palavra sem parar e em conclusão dividiremos cada elemento pelo resultado da etapa 4

tf_score = {}
para each_word em total_words:
    each_word = each_word.replace('.','')
    se não each_word em stop_words:
        se each_word em tf_score:
            tf_score[each_word] += 1
        outro:
            tf_score[each_word] = 1

# Dividing by total_word_length for each dictionary element
tf_score.update((x, e/int(total_word_length)) para x, e em tf_score.itens())
imprimir(tf_score)

7. Função para verificar se a palavra está presente em uma lista de frases.

Este método será necessário no cálculo do IDF.

def check_sent(palavra, frases): 
    fim = [tudo([w em x para w em palavra]) para x em frases] 
    sent_len = [frases[eu] para eu no alcance(0, len(final)) se final[eu]]
    int retorno(len(sent_len))

8. Calcule o IDF para cada palavra.

Vamos usar a função na etapa 7 para iterar a palavra sem parar e armazenar o resultado para a frequência reversa do documento.

idf_score = {}
para each_word em total_words:
    each_word = each_word.replace('.','')
    se não each_word em stop_words:
        se each_word em idf_score:
            idf_score[each_word] check_sent(each_word, total_sentences)
        outro:
            idf_score[each_word] = 1

# Performing a log and divide
idf_score.update((x, math.log(int(total_sent_len)/e)) para x, e em idf_score.itens())

imprimir(idf_score)

9. Calcular TF * IDF

Uma vez que a chave de ambos os dicionários é a mesma, podemos iterar um dicionário para obter as chaves e multiplicar os valores de ambos

tf_idf_score = {chave: tf_score[chave] * idf_score.get(chave, 0) para chave em tf_score.keys()}
imprimir(tf_idf_score)

10. criar uma função para obter n palavras importantes no documento

def get_top_n(dict_elem, n):
    resultado = dict(classificado(dict_elem.itens(), chave = itemgetter(1), reverso = Verdadeiro)[:n]) 
    resultado de retorno

11. Pegue o 5 palavras mais importantes

imprimir(get_top_n(tf_idf_score, 5))

conclusão

Então, esta é uma das maneiras que você pode construir seu próprio extrator de palavras-chave em 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. Por favor, compartilhe seus pensamentos se este post foi interessante ou ajudou você de alguma forma. Sempre aberto a melhorias e sugestões. Você pode encontrar o código em GitHub

Relacionado