Stemming en lemmatization in Python

Met andere woorden, een document lemmatiseren betekent het correct doen, omdat je daarbij een woordenschat gebruikt en een morfologische analyse van woorden uitvoert om alleen de flectie-eindes te verwijderen en de basis- of woordenboekvorm van een woord terug te geven, de “lemma”. Je kunt bijvoorbeeld verwachten dat een lemmatization-algoritme “runs”, “running” en “ran” toewijst aan de lemma “run.”  

Voordelen van lemmatization

• Nauwkeurigheid: Lemmatization kapt woorden niet simpelweg af zoals bij stemming. Analyse van woorden gebeurt op basis van de woordsoort (POS) zodat context wordt meegewogen bij het produceren van lemma’s. Bovendien levert lemmatization echte woordenboekwoorden op.

Nadelen van lemmatization 

• Tijdrovend: In vergelijking met stemming is lemmatization een langzaam en tijdrovend proces. Dit komt doordat lemmatization morfologische analyse vereist en de betekenis van woorden uit een woordenboek afleidt. 

Voorbeelden van stemming en lemmatization in Python met NLTK

Je hebt nu een overzicht van stemming en lemmatization. In deze sectie gaan we hands-on aan de slag en laten we voorbeelden van beide technieken zien met Python en een bibliotheek genaamd NLTK. 

Het Python NLTK-pakket

Natural Language Tool Kit (NLTK) is een Python-bibliotheek voor het bouwen van programma’s die natuurlijke taal kunnen verwerken. De bibliotheek kan verschillende bewerkingen uitvoeren, zoals tokenizen, stemming, classificatie, parsen, taggen, semantisch redeneren, sentimentanalyse en meer.

De nieuwste versie is NLTK 3.9.x en vereist Python 3.10 of hoger (tot en met 3.14), maar daar hoef je je geen zorgen over te maken, want het is vooraf geïnstalleerd in de DataLab-werkmap — importeer gewoon nltk en je kunt aan de slag.

Voorbeeld van stemming in Python

Een van de populairste stemmers heet de “Porter stemmer.” De Porter stemmer werd voor het eerst voorgesteld door Martin Porter in een paper uit 1980 met de titel "An algorithm for suffix stripping." De paper is uitgegroeid tot een van de meest gebruikte algoritmen voor stemming in het Engels.

Zo werkt het:

import nltk
from nltk.stem import PorterStemmer
nltk.download("punkt_tab")  # Use punkt_tab in NLTK 3.9+; punkt is deprecated
​
# 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

"""

Dit is een vrij eenvoudig voorbeeld; we verwachtten deze resultaten van onze Porter stemmer, zoals hierboven in de sectie “Stemming” vermeld. 

Laten we een lastiger voorbeeld proberen:

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
"""

Je ziet hier dat sommige uitvoerwoorden geen deel uitmaken van het Engelse woordenboek (zoals “becaus”, “people” en “programm”). Iets anders om op te merken is dat er geen rekening wordt gehouden met context. “Programmers” is bijvoorbeeld een meervoudig zelfstandig naamwoord, maar is teruggebracht tot “program”, wat een zelfstandig naamwoord of een werkwoord kan zijn — met andere woorden: de stamwoorden zijn ambigu. 

Voorbeeld van lemmatization in Python

De motivatie achter contextgevoelige lemmatizers was om de prestaties op onbekende en dubbelzinnige woorden te verbeteren. In ons lemmatization-voorbeeld gebruiken we een populaire lemmatizer genaamd WordNet lemmatizer. 

WordNet is een grote, gratis en publiek beschikbare lexicale database voor het Engels die gericht is op het vastleggen van gestructureerde semantische relaties tussen woorden.

Laten we het in actie zien:

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:
   # pos="v" tells the lemmatizer to treat words as verbs
   # Other options: "n" (noun), "a" (adjective), "r" (adverb)
   print("{0:20}{1:20}".format(word, wnl.lemmatize(word, pos="v")))

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

Ingevoerde woorden die aan onze lemmatizer worden doorgegeven, blijven ongewijzigd als ze niet in WordNet te vinden zijn. Dit betekent dat context moet worden meegegeven, wat gebeurt door de waarde voor de part-of-speech-parameter, pos, op te geven in wordnet_lemmatizer.lemmatize.

Merk op dat het woord “programmer” niet is teruggebracht tot “program” door onze lemmatizer: dit komt omdat we onze lemmatizer hebben verteld alleen werkwoorden te verwerken. 

Laten we onze lemmatizer iets ingewikkelders geven om te zien hoe die het doet…

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 
"""

Alle woorden die door het lemmatization-algoritme worden teruggegeven, staan in het Engelse woordenboek — op “pythonistas” na, wat meer een informele term is voor Python-programmeurs. 

Stemming vs. lemmatization

Je hebt gezien hoe je beide technieken implementeert, maar hoe verhouden ze zich? 

Stemming en lemmatization zijn beide tekstverwerkingstechnieken die tot doel hebben geflecteerde woorden terug te brengen tot een gemeenschappelijke stam. Ondanks de overlap in het overkoepelende doel, zijn de twee technieken niet hetzelfde. 

De belangrijkste verschillen tussen stemming en lemmatization liggen in de manier waarop elke techniek het doel bereikt om geflecteerde woorden te reduceren tot een gemeenschappelijke stam. 

Stemmers proberen de gemeenschappelijke stammen van verschillende flecties te vinden door het einde of begin van het woord af te kappen. Het afkappen is gebaseerd op een lijst met veelvoorkomende voor- en achtervoegsels die typisch in geflecteerde woorden voorkomen. Deze ongedifferentieerde manier van afkappen kan soms tot betekenisvolle stammen leiden, maar soms ook niet. 

Lemmatization probeert daarentegen gemeenschappelijke stammen te vinden uit geflecteerde woorden door een morfologische analyse uit te voeren. Om flecties nauwkeurig te reduceren, is een gedetailleerd woordenboek nodig zodat het algoritme kan opzoeken hoe een geflecteerd woord aan zijn lemma is gekoppeld.

De grove, heuristische aanpak van stemmers betekent doorgaans dat ze snel en efficiënt zijn, maar niet altijd nauwkeurig. Lemmatization levert daarentegen snelheid en efficiëntie in voor nauwkeurigheid, en resulteert zo in betekenisvolle stammen. 

Een stemmer kan bijvoorbeeld “saw” reduceren tot “s.” Een lemmatizer zal op basis van de context waarin het wordt gebruikt nagaan of “saw” een zelfstandig naamwoord is (de handzaag) of een werkwoord (de verleden tijd van “to see”) voordat een lemma wordt teruggegeven — als het een zelfstandig naamwoord is, geeft hij “saw” terug, en als het een werkwoord is, “see.”

Deze punten zijn nu waarschijnlijk duidelijk, dus hier is de hamvraag — “moet ik stemming of lemmatization gebruiken voor tekstpreprocessing?” 

Zoals met de meeste softwarezaken: het hangt ervan af. 

Hecht je waarde aan snelheid en efficiëntie? Kies dan stemming. 

Is context belangrijk voor je toepassing? Als je “ja” zegt, gebruik dan lemmatization. 

Welke techniek je gebruikt, hangt volledig af van de toepassing waar je aan werkt en je projectdoelen. Je wilt misschien met beide technieken experimenten uitvoeren en de resultaten vergelijken om te zien welke aanpak het best aansluit bij je doelen. 

Iets waar we in deze tutorial niet diep op zijn ingegaan, is hoe lemmatizers worden gemaakt; dat komt doordat er verschillende bibliotheken zijn (zoals SpaCy, NLTK, enz.) die met diverse talen werken. Als je echter je eigen lemmatizer zou moeten bouwen voor een niet-ondersteunde taal (bijv. Akan), heb je grondige kennis en begrip van de doeltaal nodig. Stemmers zijn in zulke scenario’s veel eenvoudiger te bouwen.

Conclusie

Samengevat: stemming en lemmatization zijn technieken voor tekstverwerking in NLP. Ze hebben beide als doel flecties terug te brengen tot gemeenschappelijke stamwoorden, maar hanteren daarbij elk een andere aanpak. 

Lemmatization is veel nauwkeuriger dan stemming. Het levert altijd echte woordenboekwoorden op en houdt rekening met context. Voor de meeste moderne NLP-pijplijnen heeft lemmatization de voorkeur wanneer nauwkeurigheid belangrijk is. Werk je echter op grote schaal of bouw je snel een prototype, dan kan stemming goed genoeg en aanzienlijk sneller zijn.