Derivazione e lemmatizzazione in Python NLTK con esempi

In cosa consistono la derivazione e la lemmatizzazione Python NLTK?

Derivazione e lemmatizzazione in Python Le tecniche NLTK (Natural Language Threat) sono tecniche di normalizzazione del testo per l'elaborazione del linguaggio naturale. Queste tecniche sono ampiamente utilizzate per la preelaborazione del testo. La differenza tra stemming e lemmatizzazione sta nel fatto che lo stemming è più veloce perché tronca le parole senza conoscerne il contesto, mentre la lemmatizzazione è più lenta perché 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 abbreviare la ricerca. In questo metodo, le parole che hanno lo stesso significato ma alcune variazioni a seconda del contesto o della frase vengono normalizzate. In altre parole, c'è una parola radice, ma ci sono molte varianti della stessa parola. Ad esempio, la parola radice è "mangiare" e le sue varianti sono "mangia, mangiare, mangiato e così via". Allo stesso modo, con l'aiuto dello Stemming in Python, possiamo trovare la radice di qualsiasi variante.

Per esempio:

He was riding.
He was taking the ride.

Nelle due frasi precedenti, il significato è lo stesso, ovvero un'attività di equitazione svolta in passato. Un essere umano può facilmente comprendere che entrambi i significati sono identici. Per le macchine, invece, le due frasi sono diverse. Pertanto, risulta difficile convertirle nella stessa riga di dati. Se non forniamo lo stesso set di dati, la macchina non riesce a fare previsioni. È quindi necessario differenziare il significato di ogni parola per preparare il set di dati per l'apprendimento automatico. In questo caso, si utilizza lo stemming per categorizzare lo stesso tipo di dati estraendone la radice.

Implementiamolo con un Python programma. NLTK ha un algoritmo chiamato PorterStemmerQuesto algoritmo accetta un elenco di parole tokenizzate e le scompone nelle parole 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)

Produzione:

wait
wait
wait
wait

Code Spiegazione:

• In NLTK è presente un modulo stem che viene importato. Se si importa l'intero modulo, il programma diventa pesante poiché contiene migliaia di righe di codice. Pertanto, dell'intero modulo stem, abbiamo importato solo "PorterStemmer".
• Abbiamo preparato un elenco fittizio di dati di variazione della stessa parola.
• Viene creato un oggetto appartenente alla classe nltk.stem.porter.PorterStemmer.
• Abbiamo passato gli elementi a PorterStemmer uno per uno utilizzando un ciclo "for". Infine, abbiamo ottenuto la radice di ciascuna parola presente nell'elenco.

Come accennato in precedenza, lo stemming è un passaggio di pre-elaborazione importante perché rimuove la ridondanza e le variazioni all'interno della stessa parola. Di conseguenza, i dati vengono filtrati, il che contribuisce a un migliore addestramento del sistema di apprendimento automatico. Ora passiamo una frase completa e ne verifichiamo l'output.

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

Code Spiegazione:

• Il pacchetto PorterStemmer 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.
• Qui viene creato un oggetto per PorterStemmer.
• Viene eseguito un ciclo e la riduzione all'ortografia di ciascuna parola viene effettuata utilizzando l'oggetto creato nella riga di codice 5.

In breve, lo stemming è un modulo di preelaborazione dei dati. La lingua inglese presenta molte varianti di una singola parola, il che crea ambiguità nell'addestramento e nella previsione dei modelli di apprendimento automatico. Per costruire un modello efficace, è fondamentale filtrare tali parole e raggrupparle in dati sequenziali utilizzando lo stemming. Questo processo è anche noto come normalizzazione.

Cos'è la lemmatizzazione?

lemmatizzazione In NLTK, la lemmatizzazione è il processo algoritmico di individuazione del lemma di una parola in base al suo significato e contesto. La lemmatizzazione si riferisce generalmente all'analisi morfologica delle parole, che mira a rimuovere le desinenze flessionali. Aiuta a restituire la forma base o lessicale di una parola, nota come lemma. Il metodo di lemmatizzazione di NLTK si basa sulla funzione morph integrata di WordNet. La preelaborazione del testo include sia lo stemming che la lemmatizzazione. Molti trovano i due termini confusi. Alcuni li considerano sinonimi, ma esiste una differenza tra stemming e lemmatizzazione. La lemmatizzazione è preferibile al primo per il motivo seguente.

Perché la lemmatizzazione è meglio dello stemming?

L'algoritmo di stemming funziona tagliando il suffisso dalla parola. In senso più ampio, taglia l'inizio o la fine della parola. Al contrario, la lemmatizzazione è 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 flessionali. Per creare dizionari e cercare la forma corretta della parola è necessaria una conoscenza linguistica approfondita. Lo stemming è un'operazione generale, mentre la lemmatizzazione è un'operazione intelligente in cui la forma corretta viene cercata nel dizionario. Pertanto, la lemmatizzazione aiuta a formare parole migliori. machine learning caratteristiche.

Code per distinguere tra lemmatizzazione e 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)))

Produzione:

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

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

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 si considera lo stemming per "studies" e "studying", l'output è lo stesso (studi), ma il lemmatizzatore NLTK fornisce un lemma diverso per entrambi i token: "study" per "studies" e "studying" per "studying". Pertanto, quando dobbiamo creare un set di caratteristiche per addestrare un algoritmo di machine learning, sarebbe preferibile utilizzare la lemmatizzazione.

Caso d'uso di Lemmatizzatore

Il lemmatizzatore riduce al minimo l'ambiguità del testo. Parole come bicicletta o biciclette vengono convertite nella parola base bicicletta. Converte tutte le parole con lo stesso significato ma rappresentazione diversa nella loro forma base, riducendo la densità delle parole e aiutandoping Prepara caratteristiche accurate per l'addestramento di un modello di machine learning. Più i dati sono puliti, più accurato sarà il modello. NLTK Lemmatizer consente inoltre di risparmiare memoria e risorse computazionali.

Esempio in tempo reale che mostra l'utilizzo della lemmatizzazione 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)

Produzione:

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

Code Spiegazione:

• Il lettore di corpus wordnet viene importato, e WordNetLemmatizer viene importato da wordnet.
• La tokenizzazione delle parole e l'etichettatura delle parti del discorso vengono importate da nltk, mentre il dizionario predefinito proviene da collections.
• Viene creato un dizionario in cui la prima lettera di pos_tag è la chiave, mappata al valore del dizionario wordnet.
• Il testo viene scritto e tokenizzato, e viene creato l'oggetto lemma_function da utilizzare all'interno del ciclo.
• Il ciclo viene eseguito e la funzione lemmatize accetta due argomenti: il token e una mappa.ping di pos_tag con il valore wordnet.

Python La lemmatizzazione ha una stretta relazione con la Dizionario WordNet, quindi è essenziale studiare questo argomento in seguito.

DOMANDE FREQUENTI