Stemming e lematização em Python

Exemplos práticos de stemização e lematização em Python com NLTK

Agora você tem uma visão geral da lematização e da formação de tronco. Nesta seção, vamos colocar a mão na massa e demonstrar exemplos de ambas as técnicas usando Python e uma biblioteca chamada NLTK. 

Uma breve introdução ao pacote Python NLTK

O Natural Language Tool Kit (NLTK) é uma biblioteca Python usada para criar programas capazes de processar linguagem natural. A biblioteca pode executar diferentes operações, como tokenização, stemização, classificação, análise, marcação, raciocínio semântico, análise de sentimentos e muito mais.

A versão mais recente é o NLTK 3.8.1 e requer as versões 3.7, 3.8, 3.9, 3.10 ou 3.11 do Python, mas você não precisa se preocupar com isso, pois ele vem pré-instalado no DataCamp Workspace - basta importar o nltk e pronto. 

Exemplo de Stemming em Python

Um dos algoritmos de stemização mais populares é chamado de "stemizador Porter". O stemmer de Porter foi proposto pela primeira vez por Martin Porter em um artigo de 1980 intitulado "An algorithm for suffix stripping" (Um algoritmo para remoção de sufixos). O artigo se tornou um dos algoritmos mais comuns para stemização em inglês.

Vamos ver como isso funciona:

import nltk
from nltk.stem import PorterStemmer
nltk.download("punkt")
​
# Initialize Python porter stemmer
ps = PorterStemmer()
​
# Example inflections to reduce
example_words = ["program","programming","programer","programs","programmed"]
​
# Perform stemming
print("{0:20}{1:20}".format("--Word--","--Stem--"))
for word in example_words:
   print ("{0:20}{1:20}".format(word, ps.stem(word)))

"""
--Word--            --Stem--            
program             program             
programming         program             
programer           program             
programs            program             
programmed          program

"""

Este é um exemplo bastante simples; esperávamos esses resultados do nosso stemmer porter, conforme mencionado na seção "Stemming" acima. 

Vamos tentar um exemplo mais complicado:

import string
from nltk.tokenize import word_tokenize

example_sentence = "Python programmers often tend like programming in python because it's like english. We call people who program in python pythonistas."

# Remove punctuation
example_sentence_no_punct = example_sentence.translate(str.maketrans("", "", string.punctuation))

# Create tokens
word_tokens = word_tokenize(example_sentence_no_punct)

# Perform stemming
print("{0:20}{1:20}".format("--Word--","--Stem--"))
for word in word_tokens:
    print ("{0:20}{1:20}".format(word, ps.stem(word)))

"""
--Word--            --Stem--            
Python              python              
programmers         programm            
often               often               
tend                tend                
like                like                
programming         program             
in                  in                  
python              python              
because             becaus              
its                 it                  
like                like                
english             english             
We                  we                  
call                call                
people              peopl               
who                 who                 
program             program             
in                  in                  
python              python              
pythonistas         pythonista
"""

Aqui você pode ver que algumas das palavras de saída não fazem parte do dicionário de inglês (por exemplo, "becaus", "people" e "programm"). Outro aspecto a ser observado é que o contexto não é levado em consideração. Por exemplo, "programadores" é um substantivo no plural, mas foi reduzido a "programa", que pode ser um substantivo ou um verbo - em outras palavras, as palavras-raiz são ambíguas. 

Exemplo de lematização em Python

A motivação por trás dos lematizadores sensíveis ao contexto foi melhorar o desempenho em palavras não vistas e ambíguas. Em nosso exemplo de lematização, usaremos um lematizador popular chamado WordNet lemmatizer. 

O Wordnet é um banco de dados lexical grande, gratuito e disponível publicamente para o idioma inglês, com o objetivo de estabelecer relações semânticas estruturadas entre as palavras.

Vamos ver em ação:

from nltk.stem import WordNetLemmatizer
nltk.download("wordnet")
nltk.download("omw-1.4")
​
# Initialize wordnet lemmatizer
wnl = WordNetLemmatizer()
​
# Example inflections to reduce
example_words = ["program","programming","programer","programs","programmed"]
​
# Perform lemmatization
print("{0:20}{1:20}".format("--Word--","--Lemma--"))
for word in example_words:
   print ("{0:20}{1:20}".format(word, wnl.lemmatize(word, pos="v")))

"""
--Word--            --Lemma--           
program             program             
programming         program             
programer           programer           
programs            program             
programmed          program
"""   

As palavras de entrada passadas ao nosso lematizador permanecerão inalteradas se não puderem ser encontradas no WordNet. Isso significa que o contexto deve ser fornecido, o que é feito fornecendo o valor do parâmetro de parte da fala, pos, em wordnet_lemmatizer.lemmatize.

Observe que a palavra "programmer" (programador) não foi reduzida para "program" (programa) pelo nosso lematizador: isso se deve ao fato de termos dito ao nosso lematizador para usar apenas verbos com haste. 

Vamos passar nosso lematizador por algo mais complicado para ver como ele se sai...

example_sentence = "Python programmers often tend like programming in python because it's like english. We call people who program in python pythonistas."
​
# Remove punctuation
example_sentence_no_punct = example_sentence.translate(str.maketrans("", "", string.punctuation))
​
word_tokens = word_tokenize(example_sentence_no_punct)
​
# Perform lemmatization
print("{0:20}{1:20}".format("--Word--","--Lemma--"))
for word in word_tokens:
   print ("{0:20}{1:20}".format(word, wnl.lemmatize(word, pos="v")))
"""
--Word--            --Lemma--           
Python              Python              
programmers         programmers         
often               often               
tend                tend                
like                like                
programming         program             
in                  in                  
python              python              
because             because             
its                 its                 
like                like                
english             english             
We                  We                  
call                call                
people              people              
who                 who                 
program             program             
in                  in                  
python              python              
pythonistas         pythonistas 
"""

Todas as palavras retornadas pelo algoritmo de lematização estão no dicionário de inglês - menos "pythonistas", que é mais um termo informal usado para se referir a programadores de python. 

Stemming vs Lemmatization

Você já viu como implementar as duas técnicas, mas como elas se comparam? 

Stemming e lematização são técnicas de processamento de texto que visam reduzir palavras flexionadas a uma raiz básica comum. Apesar da correlação no objetivo geral, as duas técnicas não são as mesmas. 

As principais diferenças entre stemização e lematização estão na forma como cada técnica chega ao objetivo de reduzir as palavras flexionadas a uma raiz básica comum. 

Os algoritmos de stemização tentam encontrar as raízes da base comum de várias flexões cortando as terminações ou inícios da palavra. O chop se baseia em uma lista de prefixos e sufixos comuns que normalmente podem ser encontrados em palavras flexionadas. Esse ato de natureza não discriminatória de cortar palavras pode ocasionalmente levar à descoberta de hastes de palavras significativas, mas outras vezes não. 

Por outro lado, os algoritmos de lematização tentam encontrar raízes de base comuns em palavras flexionadas por meio de uma análise morfológica. Para reduzir as flexões com precisão, é necessário manter um dicionário detalhado para que o algoritmo possa pesquisar e vincular uma palavra flexionada ao seu lema.

"Os dois também podem diferir no fato de que a stemização comumente colapsa palavras derivadas relacionadas, enquanto a lematização comumente colapsa apenas as diferentes formas flexionais de um lema."

- Fonte: PNL de Stanford, livro de RI.

A abordagem heurística bruta adotada pelos algoritmos de stemização geralmente significa que eles são rápidos e eficientes, mas nem sempre precisos. Por outro lado, os algoritmos de lematização sacrificam a velocidade e a eficiência em prol da precisão, resultando, assim, em raízes de base significativas. 

Por exemplo, um algoritmo de stemming pode reduzir "saw" para "s". Um algoritmo de lematização considerará se "saw" é um substantivo (a ferramenta manual para cortar) ou um verbo (ver) com base no contexto em que é usado antes de decidir retornar um lema - se for um substantivo, ele retornará "saw" e, se for um verbo, retornará "see".

Esses pontos já devem estar bem claros para você, então aqui vai a pergunta de um milhão de dólares: "Devo usar stemming ou lematização para o pré-processamento de texto?" 

Como a maioria das coisas relacionadas a software, isso depende. 

Você se preocupa com velocidade e eficiência? Se for o caso, escolha stemming. 

O contexto é importante para seu aplicativo? Se você respondeu "sim", use a lematização. 

A técnica a ser usada depende totalmente do aplicativo em que você está trabalhando e dos seus objetivos para o projeto. Talvez você queira fazer experimentos com as duas técnicas e comparar os resultados para ver qual abordagem produziu os resultados mais alinhados com as metas do seu projeto. 

Algo que não abordamos muito neste tutorial é como os algoritmos de lematização são criados; isso ocorre porque há várias bibliotecas (como SpaCy, NLTK etc.) compatíveis com diferentes idiomas. No entanto, se você tivesse que criar seu próprio lematizador para um idioma não disponível (ou seja, Akan), precisaria de um bom conhecimento e compreensão do idioma de destino para criar um lematizador. Os algoritmos de stemização são muito mais fáceis de criar para esses cenários.

Encerramento

Em resumo, stemming e lematização são técnicas usadas para processamento de texto em NLP. Ambos têm o objetivo de reduzir as flexões a palavras-raiz de base comum, mas cada um adota uma abordagem diferente ao fazer isso. A abordagem de stemming é muito mais rápida do que a lematização, mas é mais rudimentar e, ocasionalmente, pode levar a raízes de base comum sem significado. Como alternativa, a lematização é muito mais precisa do que a stemização em termos de encontrar palavras significativas no dicionário e leva em consideração o contexto.