Stamning och lemmatisering in Python NLTK med exempel

Vad är stam och lemmatisering i Python NLTK?

Stamning och lemmatisering in Python NLTK är textnormaliseringstekniker för naturlig språkbehandling. Dessa tekniker används ofta för textförbehandling. Skillnaden mellan stemming och lemmatisering är att stemming är snabbare eftersom det skär ord utan att känna till sammanhanget, medan lemmatisering är långsammare eftersom det känner till ords sammanhang innan bearbetning.

Vad är Stemming?

stemming är en metod för normalisering av ord i Naturlig språkbehandling. Det är en teknik där en uppsättning ord i en mening omvandlas till en sekvens för att förkorta dess uppslag. I denna metod normaliseras orden som har samma betydelse men har vissa variationer beroende på sammanhanget eller meningen.

Med ett annat ord finns det ett grundord, men det finns många varianter av samma ord. Till exempel är grundordet "äta" och dess varianter är "äter, äter, äter och så". På samma sätt med hjälp av Stemming in Python, kan vi hitta grundordet för alla varianter.

Till exempel

He was riding.	
He was taking the ride.

I ovanstående två meningar är innebörden densamma, dvs. ridaktivitet i det förflutna. En människa kan lätt förstå att båda betydelserna är desamma. Men för maskiner är båda meningarna olika. Därför blev det svårt att konvertera den till samma datarad. Om vi ​​inte tillhandahåller samma datauppsättning, misslyckas maskinen med att förutsäga. Så det är nödvändigt att skilja innebörden av varje ord för att förbereda datasetet för maskininlärning. Och här används stemming för att kategorisera samma typ av data genom att få dess rotord.

Låt oss implementera detta med en Python program.NLTK har en algoritm som heter "PorterStemmer". Denna algoritm accepterar listan med tokeniserade ord och stammar in det i rotord.

Program för att förstå 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)

Produktion:

wait	
wait	
wait	
wait 

Code Förklaring:

• Det finns en stammodul i NLTk som importeras. Om du importerar hela modulen blir programmet tungt eftersom det innehåller tusentals rader med koder. Så från hela stammodulen importerade vi bara "PorterStemmer."
• Vi förberedde en dummylista med variationsdata för samma ord.
• Ett objekt skapas som tillhör klassen nltk.stem.porter.PorterStemmer.

• Vidare skickade vi den till PorterStemmer en efter en med hjälp av "for" loop. Slutligen fick vi utmatningsrotord för varje ord som nämns i listan.

Från ovanstående förklaring kan man också dra slutsatsen att stemming anses vara ett viktigt förbearbetningssteg eftersom det tog bort redundans i data och variationer i samma ord. Som ett resultat filtreras data vilket kommer att hjälpa till med bättre maskinträning.

Nu skickar vi en hel mening och kontrollerar dess beteende som en utgång.

Program:

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)

Produktion:

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

Code Förklaring:

• Paketet PorterStemer importeras från modulstam
• Paket för tokenisering av mening såväl som ord importeras
• En mening skrivs som ska tokeniseras i nästa steg.
• Ordtokenisering som härrör lemmatisering implementeras i detta steg.
• Ett objekt för PorterStemmer skapas här.
• Slinga körs och stemming av varje ord görs med hjälp av objektet som skapats i kodrad 5

Slutsats:

Stemming är en dataförbearbetningsmodul. Det engelska språket har många varianter av ett enda ord. Dessa variationer skapar otydlighet i maskininlärningsträning och förutsägelse. För att skapa en framgångsrik modell är det viktigt att filtrera sådana ord och konvertera till samma typ av sekvenserad data med hjälp av stemming. Detta är också en viktig teknik för att få raddata från en uppsättning mening och ta bort redundanta data, även känd som normalisering.

Vad är lemmatisering?

lemmatisering i NLTK är den algoritmiska processen att hitta ett ords lemma beroende på dess betydelse och sammanhang. Lemmatisering syftar vanligtvis på den morfologiska analysen av ord, som syftar till att ta bort böjningsändelser. Det hjälper till att returnera bas- eller ordboksformen för ett ord som kallas lemma.

NLTK Lemmatiseringsmetoden är baserad på WorldNets inbyggda morph-funktion. Textförbearbetning inkluderar både härdning och lemmatisering. Många tycker att de två termerna är förvirrande. Vissa behandlar dessa som samma, men det finns en skillnad mellan härdning och lemmatisering. Lematisering föredras framför den förra på grund av nedanstående anledning.

Varför är Lemmatisering bättre än Stemming?

Stamalgoritm fungerar genom att klippa suffixet från ordet. I en vidare mening skär antingen början eller slutet av ordet.

Tvärtom är lemmatisering en mer kraftfull operation, och den tar hänsyn till morfologisk analys av orden. Det returnerar lemma som är basformen för alla dess böjningsformer. Fördjupade språkkunskaper krävs för att skapa ordböcker och leta efter ordets rätta form. Stemming är en allmän operation medan lemmatisering är en intelligent operation där rätt form kommer att ses i ordboken. Därför hjälper lemmatisering till att bilda bättre maskininlärning funktioner.

Code att skilja mellan lemmatisering och stemming

stemming Code:

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

Produktion::

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

lemmatisering Code:

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

Produktion:

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

Diskussion om output

Om du ser stammande för studier och studier, är produktionen densamma (studi) men NLTK lemmatizer ger olika lemma för både tokenstudier för studier och studier för att studera. Så när vi behöver göra funktionsuppsättningar för att träna maskin skulle det vara bra om lemmatisering föredras.

Använd Case of Lemmatizer

Lemmatizer minimerar tvetydighet i texten. Exempelord som cykel eller cyklar konverteras till basord cykel. I grund och botten kommer det att konvertera alla ord som har samma betydelse men olika representation till sin basform. Det minskar ordtätheten i den givna texten och hjälper till att förbereda de korrekta funktionerna för träningsmaskinen. Renare data, desto mer intelligent och exakt blir din maskininlärningsmodell. NLTK Lemmatizer sparar också minne och beräkningskostnader.

Realtidsexempel som visar användningen av Wordnet Lemmatization och POS-taggning 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 Förklaring

• Först importeras corpus reader wordnet.
• WordNetLemmatizer importeras från wordnet.
• Word tokenize såväl som delar av taltaggen importeras från nltk.
• Standardordbok importeras från samlingar.
• Dictionary skapas där post_tag (första bokstaven) är nyckelvärdena vars värden är mappade med värdet från wordnet dictionary. Vi har tagit den enda första bokstaven då vi kommer att använda den senare i slingan.
• Texten är skriven och symboliserad.
• Objekt lemma_function skapas som kommer att användas inuti slingan.
• Loopen körs och lemmatize tar två argument, ett är en token och det andra är en map.ping av pos_tag med wordnet-värde.

Produktion:

guru99 => guru99				
is => be				
totally => totally				
new => new				
kind => kind				
of => of				
learning => learn				
experience => experience				
. => .				 

Python Lematisering har ett nära samband med wordnet ordbok, så det är viktigt att studera detta ämne, så vi håller detta som nästa ämne.