Tagging POS con NLTK e Chunking in NLP [ESEMPI]

Etichettatura POS

Etichettatura POS L'etichettatura grammaticale (Parts of Speech Tagging) è un processo che etichetta le parole in formato testuale in base alla loro definizione e al contesto, assegnando a ciascuna parola un token specifico (Parte del Discorso).

Impariamo con un esempio di parte del discorso di NLTK:

Input: Everything to permit us.
Output: [('Everything', NN),('to', TO), ('permit', VB), ('us', PRP)]

Fasi coinvolte nell'esempio di etichettatura POS

• Tokenizza il testo (word_tokenize)
• Applica pos_tag al passaggio precedente, ovvero nltk.pos_tag(tokenize_text)

Di seguito sono riportati alcuni esempi di tag POS NLTK:

L'elenco di tag POS NLTK sopra riportato contiene tutti i tag POS NLTK. Il tagger POS NLTK viene utilizzato per assegnare informazioni grammaticali a ciascuna parola della frase. L'installazione, l'importazione e il download di tutti i pacchetti POS NLTK sono ora completi.

Cos'è il Chunking nella PNL?

chunking In PNL (elaborazione del linguaggio naturale), il chunking è un processo che consiste nel raggruppare piccole informazioni in unità più grandi. L'uso principale del chunking è la creazione di gruppi di "sintagmi nominali". Viene utilizzato per dare struttura alla frase seguendo l'etichettatura POS (Part-of-Speaking) combinata con le espressioni regolari. Il gruppo di parole risultante è chiamato "chunk". È anche noto come parsing superficiale.

Nell'analisi sintattica superficiale, esiste al massimo un livello tra radici e foglie, mentre l'analisi sintattica profonda comprende più di un livello. L'analisi sintattica superficiale è anche chiamata analisi sintattica leggera o chunking.

Regole per il Chunking

Non ci sono regole predefinite, ma è possibile combinarle in base alle esigenze. Ad esempio, supponiamo di dover etichettare un nome, un verbo (al passato), un aggettivo e una congiunzione coordinante all'interno di una frase. È possibile utilizzare la regola seguente:

chunk:{***?}

La tabella seguente illustra il significato dei vari simboli:

Ora scriviamo il codice per comprendere meglio la regola.

from nltk import pos_tag
from nltk import RegexpParser
text ="learn php from guru99 and make study easy".split()
print("After Split:",text)
tokens_tag = pos_tag(text)
print("After Token:",tokens_tag)
patterns= """mychunk:{***?}"""
chunker = RegexpParser(patterns)
print("After Regex:",chunker)
output = chunker.parse(tokens_tag)
print("After Chunking",output)

Produzione:

After Split: ['learn', 'php', 'from', 'guru99', 'and', 'make', 'study', 'easy']
After Token: [('learn', 'JJ'), ('php', 'NN'), ('from', 'IN'), ('guru99', 'NN'), ('and', 'CC'), ('make', 'VB'), ('study', 'NN'), ('easy', 'JJ')]
After Regex: chunk.RegexpParser with 1 stages:
RegexpChunkParser with 1 rules:
       '***?'>
After Chunking (S
  (mychunk learn/JJ)
  (mychunk php/NN)
  from/IN
  (mychunk guru99/NN and/CC)
  make/VB
  (mychunk study/NN easy/JJ))

La conclusione della parte precedente del tagging del discorso Python Ad esempio, "make" è un verbo che non è incluso nella regola, quindi non viene etichettato come mychunk.

Caso d'uso del Chunking

La segmentazione (chunking) viene utilizzata per il rilevamento delle entità. Un'entità è quella parte della frase tramite la quale una macchina ottiene il valore corrispondente a una determinata intenzione.

Example:
Temperature of New York.
Here Temperature is the intention and New York is an entity.

In altre parole, il chunking viene utilizzato per selezionare sottoinsiemi di token. Segui il codice qui sotto per capire come viene utilizzato il chunking per selezionare i token. In questo esempio, vedrai un grafico che corrisponde a un blocco di un sintagma nominale.

 import nltk
text = "learn php from guru99"
tokens = nltk.word_tokenize(text)
print(tokens)
tag = nltk.pos_tag(tokens)
print(tag)
grammar = "NP: {
?*}"
cp  =nltk.RegexpParser(grammar)
result = cp.parse(tag)
print(result)
result.draw()    # It will draw the pattern graphically which can be seen in Noun Phrase chunking

Produzione:

['learn', 'php', 'from', 'guru99']  -- These are the tokens
[('learn', 'JJ'), ('php', 'NN'), ('from', 'IN'), ('guru99', 'NN')]   -- These are the pos_tag
(S (NP learn/JJ php/NN) from/IN (NP guru99/NN))        -- Noun Phrase Chunking

Sostantivo Frase Chunking Grafico

Dal grafico possiamo concludere che "learn" e "guru99" sono due token diversi ma vengono classificati come sintagmi nominali, mentre il token "from" non appartiene a un sintagma nominale. Il chunking viene utilizzato per categorizzare token diversi nello stesso chunk. Il risultato dipenderà dalla grammatica selezionata. Inoltre, in NLTK il chunking viene utilizzato per etichettare modelli ed esplorare corpus di testo.

Conteggio delle etichette POS

Ne abbiamo discusso vari pos_tag valori precedentemente. Qui studierai come contare questi tag. Il conteggio dei tag è fondamentale per la classificazione del testo e per la preparazione delle caratteristiche per le operazioni di elaborazione del linguaggio naturale. Scriveremo prima il codice funzionante e poi spiegheremo i passaggi.

from collections import Counter
import nltk
text = "Guru99 is one of the best sites to learn WEB, SAP, Ethical Hacking and much more online."
lower_case = text.lower()
tokens = nltk.word_tokenize(lower_case)
tags = nltk.pos_tag(tokens)
counts = Counter( tag for word,  tag in tags)
print(counts)

Produzione:

Counter({'NN': 5, ',': 2, 'TO': 1, 'CC': 1, 'VBZ': 1, 'NNS': 1, 'CD': 1, '.': 1, 'DT': 1, 'JJS': 1, 'JJ': 1, 'JJR': 1, 'IN': 1, 'VB': 1, 'RB': 1})

Elaborazione del codice:

1. Utilizza il pacchetto Counter del modulo collections. Counter è una sottoclasse di dizionario che memorizza gli elementi come chiavi e i relativi conteggi come valori.
2. Importa NLTK per tokenizzare il testo.
3. Scrivi il testo di cui vuoi contare il pos_tag.
4. Convertire tutte le parole in minuscolo prima della tokenizzazione.
5. Passa le parole attraverso word_tokenize e calcola il pos_tag di ogni token.
6. Il contatore quindi conta il numero totale di occorrenze di ciascun tag nel testo.

Distribuzione di frequenza

La distribuzione di frequenza si riferisce al numero di volte in cui si verifica un risultato di un esperimento. Viene utilizzata per trovare la frequenza di ogni parola presente in un documento. Utilizza il FreqDist classe definita da probabilità NLTK modulo. Il conteggio viene incrementato di uno ogni volta che si verifica un campionamento.

Per ogni parola, possiamo verificare quante volte compare in un documento. Ad esempio:

• Metodo di conteggio: freq_dist.count('and') restituisce il numero di volte in cui si è verificato 'and'. Viene chiamato metodo count.
• Metodo di frequenza: freq_dist.freq('and') restituisce la frequenza di un dato campione.

Scriveremo un piccolo programma che calcola la distribuzione di frequenza di ogni parola nel testo.

import nltk
a = "Guru99 is the site where you can find the best tutorials for Software Testing     Tutorial, SAP Course for Beginners. Java Tutorial for Beginners and much more. Please     visit the site guru99.com and much more."
words = nltk.tokenize.word_tokenize(a)
fd = nltk.FreqDist(words)
fd.plot()

Spiegazione del codice:

1. Importa il modulo NLTK.
2. Scrivi il testo di cui devi trovare la distribuzione delle parole.
3. Tokenizzare ogni parola del testo, che viene poi utilizzata come input per il modulo FreqDist di nltk.
4. Applica ciascuna parola a nltk.FreqDist sotto forma di elenco.
5. Rappresenta le parole nel grafico utilizzando la funzione plot().

NOTA: per visualizzare il grafico è necessario installare matplotlib. Questo strumento conta le occorrenze di ogni parola nel testo e aiuta nell'analisi del sentiment basata sul testo. Il termine chiave è "tokenizzazione": dopo la tokenizzazione, ogni parola viene controllata per determinare quante volte è comparsa.

Collocazioni: bigram e trigrammi

Le collocazioni sono coppie di parole che ricorrono insieme più volte in un documento. Si calcolano come rapporto tra il numero di queste coppie che compaiono insieme e il numero totale di parole del documento.

Consideriamo parole come raggi ultravioletti e raggi infrarossi. Le parole ultravioletti e raggi non vengono usate singolarmente e quindi possono essere trattate come una collocazione. Un altro esempio è la TAC, poiché non diciamo TAC e scansione separatamente. Le collocazioni possono essere classificate in due tipi:

• Bigrammi: combinazione di due parole
• Trigrammi: combinazione di tre parole

I bigrammi e i trigrammi forniscono caratteristiche più significative e utili per l'espressione delle caratteristichetracfase di zione. Sono particolarmente utili nell'analisi del sentiment basata sul testo.

Esempio di bigrammi Code:

import nltk
text = "Guru99 is a totally new kind of learning experience."
Tokens = nltk.word_tokenize(text)
output = list(nltk.bigrams(Tokens))
print(output)

Produzione:

[('Guru99', 'is'), ('is', 'totally'), ('totally', 'new'), ('new', 'kind'), ('kind', 'of'), ('of', 'learning'), ('learning', 'experience'), ('experience', '.')]

Esempio di trigrammi Code:

A volte diventa importante vedere una coppia di tre parole nella frase per l'analisi statistica e il conteggio della frequenza. Anche questo gioca un ruolo cruciale nella formazione NLP (elaborazione del linguaggio naturale) funzionalità e previsione del sentiment basata sul testo. Lo stesso codice viene eseguito per calcolare i trigrammi.

import nltk
text = "Guru99 is a totally new kind of learning experience."
Tokens = nltk.word_tokenize(text)
output = list(nltk.trigrams(Tokens))
print(output)

Produzione:

[('Guru99', 'is', 'totally'), ('is', 'totally', 'new'), ('totally', 'new', 'kind'), ('new', 'kind', 'of'), ('kind', 'of', 'learning'), ('of', 'learning', 'experience'), ('learning', 'experience', '.')]

Taggare le frasi

L'etichettatura di una frase consiste nell'aggiungere etichette come verbo o nome in base al contesto della frase. Identificare le etichette POS è complesso, quindi l'etichettatura generica manuale non è possibile, poiché alcune parole hanno significati ambigui a seconda della struttura della frase. La conversione del testo in un elenco è un passaggio importante prima dell'etichettatura, poiché ogni parola viene iterata e conteggiata per una specifica etichetta.

import nltk
text = "Hello Guru99, You have to build a very good site, and I love visiting your site."
sentence = nltk.sent_tokenize(text)
for sent in sentence:
	 print(nltk.pos_tag(nltk.word_tokenize(sent)))

Code Spiegazione:

1. Code per importare nltk (il Natural Language Toolkit, che contiene sottomoduli come la tokenizzazione delle frasi e la tokenizzazione delle parole).
2. Testo i cui tag devono essere stampati.
3. Tokenizzazione delle frasi.
4. Viene implementato un ciclo for in cui le parole vengono suddivise in token all'interno della frase e il tag di ciascuna parola viene stampato come output.

In un corpus esistono due tipi di tagger POS:

1. Etichettatore POS basato su regole: Per le parole dal significato ambiguo, si applica un approccio basato su regole e informazioni contestuali. Questo avviene analizzando il significato della parola precedente o successiva. Pertanto, le parole vengono etichettate secondo le regole grammaticali di una particolare lingua, come la maiuscola e la punteggiatura. Ad esempio, il tagger di Brill.

2. Etichettatore POS stocastico: In questo metodo si applicano approcci basati sulla frequenza o sulla probabilità. Se una parola è prevalentemente associata a una determinata etichetta nel set di addestramento, le viene assegnata la stessa etichetta nella frase di test. Tuttavia, l'etichetta di una parola dipende non solo dalla propria etichetta, ma anche dall'etichetta precedente, pertanto questo metodo non è sempre accurato.

Etichettatura POS con modello di Markov nascosto

I problemi di etichettatura possono essere modellati anche utilizzando un modello di Markov nascosto (HMM). Questo modello considera i token di input come una sequenza osservabile, mentre i tag sono considerati stati nascosti, e l'obiettivo è determinare la sequenza degli stati nascosti. Ad esempio, x = x1,x2,…,xn, dove x è una sequenza di token, mentre y = y1,y2,y3,y4…yn è la sequenza nascosta.

Come funziona il modello di Markov nascosto (HMM)?

HMM utilizza una distribuzione congiunta P(x, y), dove x è la sequenza di token di input e y è la sequenza di tag. La sequenza di tag per x sarà argmax su y1…yn di p(x1,x2,…xn,y1,y2,y3,…). Abbiamo categorizzato i tag dal testo, ma le statistiche di tali tag sono fondamentali, quindi la parte successiva consiste nel contare questi tag per l'analisi statistica.

DOMANDE FREQUENTI