Derivazione e lemmatizzazione in Python NLTK con esempi

In cosa consistono la derivazione e la lemmatizzazione Python NLTK?

Derivazione e lemmatizzazione in Python NLTK sono tecniche di normalizzazione del testo per l'elaborazione del linguaggio naturale. Queste tecniche sono ampiamente utilizzate per la pre-elaborazione del testo. La differenza tra stemming e lemmatizzazione è che lo stemming è più veloce in quanto taglia le parole senza conoscerne il contesto, mentre la lemmatizzazione è più lenta in quanto conosce il contesto delle parole prima dell'elaborazione.

Cos'è lo Stemming?

Stemming è un metodo di normalizzazione delle parole in Elaborazione del linguaggio naturale. È una tecnica in cui un insieme di parole in una frase viene convertito in una sequenza per abbreviarne la ricerca. In questo metodo si normalizzano le parole che hanno lo stesso significato ma che presentano alcune variazioni a seconda del contesto o della frase.

In un'altra parola, esiste una parola radice, ma esistono molte varianti delle stesse parole. Ad esempio, la radice della parola è “mangia” e le sue varianti sono “mangia, mangia, mangiato e così”. Allo stesso modo, con l'aiuto di Stemming in Python, possiamo trovare la radice di qualsiasi variazione.

Per esempio

He was riding.	
He was taking the ride.

Nelle due frasi precedenti il significato è lo stesso, cioè attività equestre nel passato. Un essere umano può facilmente capire che entrambi i significati sono gli stessi. Ma per le macchine le due frasi sono diverse. Pertanto è diventato difficile convertirlo nella stessa riga di dati. Nel caso in cui non forniamo lo stesso set di dati, la macchina non riesce a prevedere. Quindi è necessario differenziare il significato di ogni parola per preparare il set di dati per l’apprendimento automatico. E qui la radice viene utilizzata per classificare lo stesso tipo di dati ottenendo la sua parola radice.

Implementiamolo con a Python program.NLTK ha un algoritmo denominato "PorterStemmer". Questo algoritmo accetta l'elenco di parole tokenizzate e lo deriva nella parola radice.

Programma per comprendere lo 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)

Uscita:

wait	
wait	
wait	
wait

Spiegazione del codice:

C'è un modulo stem in NLTk che viene importato. Se importi il modulo completo, il programma diventa pesante poiché contiene migliaia di righe di codice. Quindi, dall’intero modulo stem, abbiamo importato solo “PorterStemmer”.
Abbiamo preparato un elenco fittizio di dati di variazione della stessa parola.
Viene creato un oggetto che appartiene alla classe nltk.stem.porter.PorterStemmer.

Inoltre, li abbiamo passati a PorterStemmer uno per uno utilizzando il ciclo "for". Alla fine, abbiamo ottenuto la parola radice di output di ogni parola menzionata nell'elenco.

Dalla spiegazione di cui sopra, si può anche concludere che lo stemming è considerato un importante passo di preelaborazione perché rimuove la ridondanza nei dati e le variazioni nella stessa parola. Di conseguenza, i dati vengono filtrati e ciò aiuterà a migliorare l'addestramento della macchina.

Ora passiamo una frase completa e controlliamo il suo comportamento come output.

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)

Produzione:

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

Spiegazione del codice:

Il pacchetto PorterStemer viene importato dal modulo stem
Vengono importati pacchetti per la tokenizzazione di frasi e parole
Viene scritta una frase che verrà tokenizzata nel passaggio successivo.
In questo passaggio viene implementata la tokenizzazione delle parole che deriva dalla lemmatizzazione.
Qui viene creato un oggetto per PorterStemmer.
Viene eseguito il loop e la radice di ogni parola viene eseguita utilizzando l'oggetto creato nella riga di codice 5

Conclusione:

Stemming è un modulo di preelaborazione dei dati. La lingua inglese ha molte varianti di una singola parola. Queste variazioni creano ambiguità nell'addestramento e nella previsione del machine learning. Per creare un modello di successo, è fondamentale filtrare tali parole e convertirle nello stesso tipo di dati in sequenza utilizzando la radice. Inoltre, questa è una tecnica importante per ottenere dati di riga da un insieme di frasi e la rimozione di dati ridondanti, nota anche come normalizzazione.

Cos'è la lemmatizzazione?

lemmatizzazione in NLTK è il processo algoritmico per trovare il lemma di una parola a seconda del suo significato e contesto. La lemmatizzazione di solito si riferisce all'analisi morfologica delle parole, che mira a rimuovere le desinenze flessive. Aiuta a restituire la forma base o dizionario di una parola conosciuta come lemma.

Il metodo di lemmatizzazione NLTK si basa sulla funzione morph incorporata di WorldNet. La preelaborazione del testo include sia la radice che la lemmatizzazione. Molte persone trovano confusi i due termini. Alcuni li trattano allo stesso modo, ma c'è una differenza tra stemming e lemmatizzazione. La lemmatizzazione è preferita alla prima per il motivo seguente.

Perché la lemmatizzazione è meglio dello stemming?

L'algoritmo di stemming funziona tagliando il suffisso dalla parola. In un senso più ampio taglia l'inizio o la fine della parola.

La lemmatizzazione, invece, è un'operazione più potente, e prende in considerazione l'analisi morfologica delle parole. Restituisce il lemma che è la forma base di tutte le sue forme flessive. È necessaria una conoscenza linguistica approfondita per creare dizionari e cercare la forma corretta della parola. La derivazione è un'operazione generale mentre la lemmatizzazione è un'operazione intelligente in cui la forma corretta verrà cercata nel dizionario. Quindi, la lemmatizzazione aiuta a formarsi meglio machine learning caratteristiche.

Codice per distinguere tra lemmatizzazione e stemming

Codice derivativo:

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

Produzione::

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

Codice di lemmatizzazione:

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

Produzione:

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

Discussione sull'output

Se cerchi la radice per studi e studio, l'output è lo stesso (studi) ma il lemmatizzatore NLTK fornisce lemma diverso per entrambi i token studio per studi e studio per studio. Pertanto, quando dobbiamo creare un set di funzionalità per addestrare la macchina, sarebbe fantastico se si preferisse la lemmatizzazione.

Caso d'uso di Lemmatizzatore

Lemmatizer riduce al minimo l'ambiguità del testo. Parole di esempio come bicicletta o biciclette vengono convertite nella parola base bicicletta. Fondamentalmente, convertirà tutte le parole con lo stesso significato ma diversa rappresentazione nella loro forma base. Riduce la densità delle parole nel testo dato e aiuta a preparare le caratteristiche precise per la macchina da allenamento. Più puliti saranno i dati, più intelligente e accurato sarà il tuo modello di machine learning. NLTK Lemmatizer consentirà inoltre di risparmiare memoria e costi computazionali.

Esempio in tempo reale che mostra l'uso della lemmatizzazione di Wordnet e del POS Tagging 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)

Spiegazione del codice

Innanzitutto viene importato il lettore di corpus wordnet.
WordNetLemmatizer è importato da Wordnet.
La tokenizzazione delle parole e le parti dei tag vocali vengono importate da nltk.
Il dizionario predefinito viene importato dalle raccolte.
Il dizionario viene creato dove pos_tag (prima lettera) sono i valori chiave i cui valori sono mappati con il valore del dizionario wordnet. Abbiamo preso solo la prima lettera perché la useremo più avanti nel ciclo.
Il testo viene scritto ed è tokenizzato.
Viene creato l'oggetto lemma_function che verrà utilizzato all'interno del loop.
Viene eseguito il loop e lemmatize prenderà due argomenti, uno è token e l'altro è una mappatura di pos_tag con valore wordnet.