POS-tagging med NLTK og Chunking i NLP [EKSEMPLER]

POS-tagging

POS-tagging (Orddelmerking) er en prosess for å merke opp ord i tekstformat for en bestemt del av en tale basert på definisjon og kontekst. Den er ansvarlig for å lese tekst på et språk og tilordne et spesifikt token (orddeler) til hvert ord. Det kalles også grammatisk merking.

La oss lære med et eksempel på en NLTK-ordklasse:

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

Trinn involvert i POS-taggingseksemplet

• Tokenize tekst (word_tokenize)
• Bruk pos_tag i trinnet ovenfor, det vil si nltk.pos_tag(tokenize_text)

Eksempler på NLTK POS-tagger er listet opp nedenfor:

NLTK POS-taglisten ovenfor inneholder alle NLTK POS-taggene. NLTK POS-taggeren brukes til å tilordne grammatisk informasjon til hvert ord i setningen. Installasjon, import og nedlasting av alle pakkene med POS NLTK er nå fullført.

Hva er Chunking i NLP?

chunking I NLP er Chunking en prosess for å ta små biter av informasjon og gruppere dem i store enheter. Den primære bruken av Chunking er å lage grupper av «substantivfraser». Det brukes til å legge til struktur i setningen ved å følge POS-tagging kombinert med regulære uttrykk. Den resulterende gruppen av ord kalles «chunks». Det kalles også shallow parsing.

Ved grunn parsing er det maksimalt ett nivå mellom røtter og blader, mens dyp parsing omfatter mer enn ett nivå. Grunn parsing kalles også lett parsing eller chunking.

Regler for Chunking

Det finnes ingen forhåndsdefinerte regler, men du kan kombinere dem etter behov og krav. La oss for eksempel si at du må merke substantiv, verb (preteritum), adjektiv og konjunksjon fra setningen. Du kan bruke regelen nedenfor:

chunk:{***?}

Tabellen nedenfor viser hva de ulike symbolene betyr:

La oss nå skrive koden for å forstå regelen bedre.

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)

Utgang:

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

Konklusjonen fra ovennevnte Part of Speech-tagging Python Eksempel er at «make» er et verb som ikke er inkludert i regelen, så det er ikke merket som mychunk.

Bruk Case of Chunking

Chunking brukes til enhetsdeteksjon. En enhet er den delen av setningen der en maskin henter verdien for en hvilken som helst intensjon.

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

Med andre ord brukes chunking til å velge delsett av tokens. Følg koden nedenfor for å forstå hvordan chunking brukes til å velge tokens. I dette eksemplet vil du se en graf som tilsvarer en del av en substantivfrase.

 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

Utgang:

['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

Substantiv frase chunking Graph

Fra grafen kan vi konkludere med at «learn» og «guru99» er to forskjellige tokens, men de er kategorisert som en substantivfrase, mens tokenet «from» ikke tilhører en substantivfrase. Chunking brukes til å kategorisere forskjellige tokens i samme chunk. Resultatet vil avhenge av grammatikken som er valgt. Videre brukes Chunking i NLTK til å merke mønstre og utforske tekstkorpusa.

Telle POS-brikker

Vi har diskutert ulike post_tag verdier tidligere. Her skal du studere hvordan du teller disse taggene. Å telle tagger er avgjørende for tekstklassifisering og for å forberede funksjoner for naturlige språkoperasjoner. Vi skriver først arbeidskoden og forklarer deretter trinnene.

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)

Utgang:

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

Utarbeidelse av koden:

1. Bruk Counter-pakken fra samlingsmodulen. Counter er en underklasse i ordboken som lagrer elementer som nøkler og antallene deres som verdier.
2. Importer nltk for å tokenisere teksten.
3. Skriv teksten hvis post_tag du vil telle.
4. Gjør alle ord om til små bokstaver før tokenisering.
5. Send ordene gjennom word_tokenize og beregn pos_taggen til hver token.
6. Counter teller deretter den totale forekomsten av hver tag i teksten.

Frekvensdistribusjon

Frekvensfordeling refererer til antall ganger et utfall av et eksperiment forekommer. Den brukes til å finne frekvensen av hvert ord som forekommer i et dokument. Den bruker Frekvensavdeling klasse definert av nltk.sannsynlighet modulen. Antallet økes med én hver gang en prøve forekommer.

For et hvilket som helst ord kan vi sjekke hvor mange ganger det forekommer i et dokument. For eksempel:

• Tellemetode: freq_dist.count('og') returnerer antall ganger 'og' har forekommet. Dette kalles count-metoden.
• Frekvensmetode: freq_dist.freq('og') returnerer frekvensen til en gitt prøve.

Vi skal skrive et lite program som beregner frekvensfordelingen til hvert ord i teksten.

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

Forklaring av kode:

1. Importer nltk-modulen.
2. Skriv teksten hvis ordfordeling du trenger å finne.
3. Tokeniser hvert ord i teksten, som tjener som input til FreqDist-modulen til nltk.
4. Bruk hvert ord til nltk.FreqDist i form av en liste.
5. Plott ordene i grafen ved hjelp av plot().

MERK: matplotlib må være installert for å se grafen. Den teller forekomsten av hvert ord i teksten og hjelper til med tekstbasert sentimentanalyse. Nøkkelbegrepet er «tokenize»: etter tokenisering kontrolleres hvert ord for å bestemme hvor mange ganger det forekom.

Kollokasjoner: Bigrams og Trigrams

Kollokasjoner er ordpar som forekommer sammen mange ganger i et dokument. Det beregnes ut fra forholdet mellom antallet av disse parene som forekommer sammen og det totale ordantallet i dokumentet.

Tenk på ord som ultrafiolette stråler og infrarøde stråler. Ordene ultrafiolett og stråler brukes ikke individuelt og kan derfor behandles som en samlokalisering. Et annet eksempel er CT-skanning, siden vi ikke sier CT og skanning separat. Samlokalisering kan kategoriseres i to typer:

• Bigrams: kombinasjon av to ord
• Trigrammer: kombinasjon av tre ord

Bigrammer og trigrammer gir mer meningsfulle og nyttige funksjoner for funksjonen f.eks.tracsjonsfasen. Disse er spesielt nyttige i tekstbasert sentimentanalyse.

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

Utgang:

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

Eksempel på trigrammer Code:

Noen ganger blir det viktig å se et par på tre ord i setningen for statistisk analyse og frekvenstelling. Dette spiller igjen en avgjørende rolle i formingen NLP (naturlig språkbehandling) samt tekstbasert sentimentprediksjon. Den samme koden kjøres for å beregne trigrammene.

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

Utgang:

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

Merking av setninger

Å merke en setning refererer til å legge til etiketter som verb eller substantiv basert på setningens kontekst. Det er komplisert å identifisere POS-tagger, så generisk tagging er ikke mulig manuelt, ettersom noen ord har tvetydige betydninger avhengig av setningsstrukturen. Å konvertere tekst til en liste er et viktig trinn før tagging, ettersom hvert ord løkkes og telles for en bestemt tagg.

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 Forklaring:

1. Code å importere nltk (den naturlige Language Toolkit, som inneholder undermoduler som setningstokenisering og ordtokenisering).
2. Tekst hvis tagger skal skrives ut.
3. Setningstokenisering.
4. En for-løkke implementeres der ord tokeniseres fra setningen og taggen til hvert ord skrives ut som utdata.

I et korpus finnes det to typer POS-taggere:

1. Regelbasert POS-tagger: For ord med tvetydig betydning brukes en regelbasert tilnærming basert på kontekstuell informasjon. Dette gjøres ved å analysere betydningen av det foregående eller påfølgende ordet. Derfor merkes ord med de grammatiske reglene i et bestemt språk, som store bokstaver og tegnsetting. For eksempel Brills tagger.

2. Stokastisk POS-tagger: Tilnærminger som frekvens eller sannsynlighet brukes under denne metoden. Hvis et ord stort sett er merket med en bestemt tagg i treningssettet, får det den taggen i testsetningen. Ordtaggen avhenger ikke bare av sin egen tagg, men også av den forrige taggen, så denne metoden er ikke alltid nøyaktig.

POS-merking med skjult Markov-modell

Taggingproblemer kan også modelleres ved hjelp av en skjult Markov-modell (HMM). Den behandler input-tokens som en observerbar sekvens, mens tagger anses som skjulte tilstander, og målet er å bestemme den skjulte tilstandssekvensen. For eksempel, x = x1,x2,…,xn, hvor x er en sekvens av tokens, mens y = y1,y2,y3,y4…yn er den skjulte sekvensen.

Hvordan fungerer Hidden Markov Model (HMM)?

HMM bruker en fellesfordeling P(x, y), hvor x er input-tokensekvensen og y er tag-sekvensen. Tag-sekvensen for x vil være argmax over y1…yn av p(x1,x2,…xn,y1,y2,y3,…). Vi har kategorisert tagger fra teksten, men statistikk for slike tagger er viktig, så neste del er å telle disse taggene for statistisk studie.

Spørsmål og svar