Stemming en lemmatisering in Python NLTK met voorbeelden

Wat houdt stemming en lemmatisering in? Python NLTK?

Stemming en lemmatisering in Python NLTK zijn tekstnormalisatietechnieken voor Natural Language Processing. Deze technieken worden veel gebruikt voor tekstpreprocessing. Het verschil tussen stemming en lemmatisering is dat stemming sneller is omdat het woorden knipt zonder de context te kennen, terwijl lemmatisering langzamer is omdat het de context van woorden kent vóór de verwerking.

Wat is stammen?

stammend is een methode voor het normaliseren van woorden in Natural Language Processing. Het is een techniek waarbij een reeks woorden in een zin wordt omgezet in een reeks om de zoekactie te verkorten. Bij deze methode worden de woorden met dezelfde betekenis, maar met enkele variaties afhankelijk van de context of zin, genormaliseerd.

In een ander woord is er één grondwoord, maar er zijn veel variaties op dezelfde woorden. Het grondwoord is bijvoorbeeld 'eten' en de variaties ervan zijn 'eet, eet, gegeten en zo'. Op dezelfde manier, met de hulp van Stemming in Python, kunnen we het grondwoord van elke variatie vinden.

Bij voorbeeld

He was riding.	
He was taking the ride.

In de twee bovenstaande zinnen is de betekenis hetzelfde, dat wil zeggen: rijactiviteit in het verleden. Een mens kan gemakkelijk begrijpen dat beide betekenissen hetzelfde zijn. Maar voor machines zijn beide zinnen verschillend. Het werd dus moeilijk om het in dezelfde gegevensrij om te zetten. Als we niet dezelfde dataset leveren, kan de machine niet voorspellen. Het is dus noodzakelijk om de betekenis van elk woord te differentiëren om de dataset voor te bereiden op machinaal leren. En hier wordt stam gebruikt om hetzelfde type gegevens te categoriseren door het stamwoord te achterhalen.

Laten we dit implementeren met a Python program.NLTK heeft een algoritme met de naam "PorterStemmer". Dit algoritme accepteert de lijst met tokenized woorden en zet deze in het hoofdwoord.

Programma voor het begrijpen van Stemming

from nltk.stem import PorterStemmer
e_words= ["wait", "waiting", "waited", "waits"]
ps =PorterStemmer()
for w in e_words:
    rootWord=ps.stem(w)
    print(rootWord)

uitgang:

wait	
wait	
wait	
wait

Code Verklaring:

Er is een stammodule in NLTk die wordt geïmporteerd. Als u de volledige module importeert, wordt het programma zwaar omdat het duizenden regels codes bevat. Dus van de hele stammodule hebben we alleen ‘PorterStemmer’ geïmporteerd.
We hebben een dummylijst met variatiegegevens van hetzelfde woord opgesteld.
Er wordt een object gemaakt dat behoort tot de klasse nltk.stem.porter.PorterStemmer.

Verder hebben we het één voor één aan PorterStemmer doorgegeven met behulp van de “for” -lus. Ten slotte kregen we het uitgangswoord van elk woord dat in de lijst wordt genoemd.

Uit de bovenstaande uitleg kan ook worden geconcludeerd dat stammen wordt beschouwd als een belangrijke voorverwerkingsstap omdat het redundantie in de gegevens en variaties in hetzelfde woord verwijdert. Als gevolg hiervan worden gegevens gefilterd, wat zal helpen bij een betere machinetraining.

Nu geven we een volledige zin door en controleren we het gedrag ervan als uitvoer.

Programma:

from nltk.stem import PorterStemmer
from nltk.tokenize import sent_tokenize, word_tokenize
sentence="Hello Guru99, You have to build a very good site and I love visiting your site."
words = word_tokenize(sentence)
ps = PorterStemmer()
for w in words:
	rootWord=ps.stem(w)
	print(rootWord)

Output:

hello	
guru99	
,	
you	
have	
build	
a	
veri	
good	
site	
and	
I	
love	
visit	
your	
site

Code Verklaring:

Pakket PorterStemer wordt geïmporteerd uit modulestam
Pakketten voor tokenisatie van zowel zinnen als woorden worden geïmporteerd
Er wordt een zin geschreven die in de volgende stap moet worden getokeniseerd.
In deze stap wordt woordtokenisatie als gevolg van lemmatisering geïmplementeerd.
Hier wordt een object voor PorterStemmer gemaakt.
Er wordt een lus uitgevoerd en elk woord wordt afgeleid met behulp van het object dat is gemaakt in coderegel 5

Conclusie:

Stemming is een module voor gegevensvoorverwerking. De Engelse taal kent vele varianten van één enkel woord. Deze variaties zorgen voor onduidelijkheid in de training en voorspelling van machine learning. Om een succesvol model te creëren, is het essentieel om dergelijke woorden te filteren en met behulp van stemming naar hetzelfde type geordende gegevens te converteren. Dit is ook een belangrijke techniek om rijgegevens uit een reeks zinnen te halen en overtollige gegevens te verwijderen, ook wel normalisatie genoemd.

Wat is lemmatisering?

Lemmatisering in NLTK is het algoritmische proces van het vinden van het lemma van een woord, afhankelijk van de betekenis en context ervan. Lemmatisering verwijst meestal naar de morfologische analyse van woorden, die tot doel heeft verbuigingsuitgangen te verwijderen. Het helpt bij het teruggeven van de basis- of woordenboekvorm van een woord dat bekend staat als het lemma.

De NLTK-lemmatiseringsmethode is gebaseerd op de ingebouwde morph-functie van WorldNet. Tekstvoorbewerking omvat zowel stammen als lemmatisering. Veel mensen vinden de twee termen verwarrend. Sommigen beschouwen deze als hetzelfde, maar er is een verschil tussen stammen en lemmatisering. Lemmatisering verdient de voorkeur boven de eerste vanwege de onderstaande reden.

Waarom is lemmatisering beter dan stemming?

Het stemming-algoritme werkt door het achtervoegsel uit het woord te knippen. In bredere zin wordt het begin of het einde van het woord afgesneden.

Integendeel, Lemmatisering is een krachtigere operatie, en het houdt rekening met morfologische analyse van de woorden. Het retourneert het lemma dat de basisvorm is van al zijn inflectionele vormen. Diepgaande taalkundige kennis is vereist om woordenboeken te maken en te zoeken naar de juiste vorm van het woord. Stemming is een algemene operatie, terwijl lemmatisering een intelligente operatie is waarbij de juiste vorm in het woordenboek wordt gezocht. Lemmatisering helpt dus bij het vormen van betere machine learning kenmerken.

Code om onderscheid te maken tussen lemmatisering en stemming

Stamcode:

import nltk
from nltk.stem.porter import PorterStemmer
porter_stemmer  = PorterStemmer()
text = "studies studying cries cry"
tokenization = nltk.word_tokenize(text)
for w in tokenization:
print("Stemming for {} is {}".format(w,porter_stemmer.stem(w)))

Output::

Stemming for studies is studi
Stemming for studying is studi
Stemming for cries is cri
Stemming for cry is cri

Lemmatiseringscode:

import nltk
	from nltk.stem import 	WordNetLemmatizer
	wordnet_lemmatizer = WordNetLemmatizer()
	text = "studies studying cries cry"
	tokenization = nltk.word_tokenize(text)
	 for w in tokenization:
		print("Lemma for {} is {}".format(w, wordnet_lemmatizer.lemmatize(w)))

Output:

Lemma for studies is study
Lemma for studying is studying
Lemma for cries is cry
Lemma for cry is cry

Bespreking van de output

Als je zoekt naar studies en studeren, is de output hetzelfde (studi), maar de NLTK-lemmatizer biedt verschillende lemma's voor zowel tokens studeren voor studies als studeren voor studeren. Dus als we functies moeten instellen om machines te trainen, zou het geweldig zijn als lemmatisering de voorkeur verdient.

Gebruiksvoorbeeld van Lemmatizer

Lemmatizer minimaliseert tekstambiguïteit. Voorbeeldwoorden als fiets of fietsen worden omgezet naar het basiswoord fiets. Kortom, het converteert alle woorden met dezelfde betekenis maar met een andere weergave naar hun basisvorm. Het vermindert de woorddichtheid in de gegeven tekst en helpt bij het voorbereiden van de nauwkeurige kenmerken voor de trainingsmachine. Hoe schoner de gegevens, hoe intelligenter en nauwkeuriger uw machine learning-model zal zijn. NLTK Lemmatizer bespaart ook geheugen en rekenkosten.

Realtimevoorbeeld waarin het gebruik van Wordnet Lemmatization en POS Tagging wordt getoond in Python

from nltk.corpus import wordnet as wn
	from nltk.stem.wordnet import WordNetLemmatizer
	from nltk import word_tokenize, pos_tag
	from collections import defaultdict
	tag_map = defaultdict(lambda : wn.NOUN)
	tag_map['J'] = wn.ADJ
	tag_map['V'] = wn.VERB
	tag_map['R'] = wn.ADV

	text = "guru99 is a totally new kind of learning experience."
	tokens = word_tokenize(text)
	lemma_function = WordNetLemmatizer()
	for token, tag in pos_tag(tokens):
		lemma = lemma_function.lemmatize(token, tag_map[tag[0]])
		print(token, "=>", lemma)

Code Uitleg

Als eerste wordt de corpusreader wordnet geïmporteerd.
WordNetLemmatizer wordt geïmporteerd uit wordnet.
Zowel woord-tokenize als delen van spraak-tags worden geïmporteerd uit nltk.
Standaardwoordenboek wordt geïmporteerd uit verzamelingen.
Woordenboek wordt gemaakt waarbij pos_tag (eerste letter) de sleutelwaarden zijn waarvan de waarden worden toegewezen aan de waarde van wordnet dictionary. We hebben alleen de eerste letter genomen omdat we deze later in de lus zullen gebruiken.
Tekst is geschreven en is tokenized.
Er wordt object lemma_function gemaakt dat binnen de lus zal worden gebruikt.
De lus wordt uitgevoerd en lemmatize heeft twee argumenten: de ene is token en de andere is een mapping van pos_tag met wordnet-waarde.