Ordinnbygging og Word2Vec med eksempel

Hva er Word Embedding?

Innbygging av ord er en ordrepresentasjonstype som lar maskinlæringsalgoritmer forstå ord med lignende betydninger. Det er en språkmodellerings- og funksjonslæringsteknikk for å kartlegge ord i vektorer av reelle tall ved hjelp av nevrale nettverk, sannsynlighetsmodeller eller dimensjonsreduksjon på ord-samforekomstmatrisen. Noen ordinnbyggingsmodeller er Word2vec (Google), GloVe (Stanford) og fastText (Facebook).

Ordinnbygging kalles også en distribuert semantisk modell, distribuert representert modell, semantisk vektorrom eller vektorrommodell. Når du leser disse navnene, kommer du over ordet semantisk, som betyr å kategorisere lignende ord sammen. For eksempel bør frukt som eple, mango og banan plasseres tett sammen, mens bøker vil plasseres langt unna disse ordene. I en bredere forstand vil ordinnbygging skape en vektor av frukt som er plassert langt unna vektorrepresentasjonen av bøker.

Hvor brukes Word Embedding?

Ordinnbygging hjelper med funksjonsgenerering, dokumentklynging, tekstklassifisering og oppgaver med naturlig språkbehandling. La oss liste opp disse bruksområdene og diskutere hver enkelt.

• Regn ut lignende ord: Ordinnbygging brukes til å foreslå lignende ord som ordet som blir utsatt for prediksjonsmodellen. I tillegg til det foreslås også ulike ord, samt de vanligste ordene.
• Lag en gruppe beslektede ord: Den brukes for semantiske grupperping, som grupperer ting med lignende egenskaper sammen og skyver ulike gjenstander langt bort.
• Funksjon for tekstklassifisering: Tekst kartlegges i vektormatriser som mates til modellen for trening så vel som prediksjon. Tekstbaserte klassifiseringsmodeller kan ikke trenes på strenger, så dette konverterer teksten til en maskinopplærbar form. De semantiske byggingsfunksjonene hjelper ytterligere med tekstbasert klassifisering.
• Dokumentgruppering: Dette er et annet program der Word Embedding og Word2vec er mye brukt.
• Naturlig språkbehandling: Det finnes mange applikasjoner der ordinnbygging er nyttig og vinner over funksjoner som f.eks.tracsjonsfaser, som ordklassetagging, sentimentanalyse og syntaktisk analyse.

Nå som du forstår hvor ordinnebygging brukes, la oss se på den mest populære modellen som brukes til å lage disse innebyggingene.

Hva er Word2vec?

Word2vec er en teknikk eller modell som produserer ordinnleggelser for bedre ordrepresentasjon. Det er en naturlig språkbehandlingsmetode som fanger opp et stort antall presise syntaktiske og semantiske ordforhold. Det er et overfladisk tolags nevralt nettverk som kan oppdage synonyme ord og foreslå tilleggsord for delvise setninger når det er trent.

Før du går videre, se forskjellen mellom et grunt og et dypt nevralt nettverk som vist i eksempeldiagrammet for Word-innebygging nedenfor:

Det grunne nevrale nettverket består av bare ett skjult lag mellom input og output, mens et dypt nevralt nettverk inneholder flere skjulte lag mellom input og output. Input er underlagt noder, mens det skjulte laget, så vel som outputlaget, inneholder nevroner.

Word2vec er et tolagsnettverk der det er en inngang, ett skjult lag og en utgang.

Word2vec ble utviklet av en gruppe forskere ledet av Tomas Mikolov ved GoogleWord2vec er bedre og mer effektiv enn den latente semantiske analysemodellen.

Hvorfor Word2vec?

Word2vec representerer ord i en vektorromrepresentasjon. Ord er representert i form av vektorer, og plasseringen gjøres på en slik måte at ord med lignende betydning vises sammen, og ulike ord er plassert langt unna. Dette kalles også en semantisk relasjon. Nevrale nettverk forstår ikke tekst; i stedet forstår de bare tall. Ordinnbygging gir en måte å konvertere tekst til en numerisk vektor.

Word2vec rekonstruerer den språklige konteksten til ord. Før vi går videre, la oss forstå hva språklig kontekst er. I et generelt scenario, når vi snakker eller skriver for å kommunisere, prøver andre å finne ut hva setningen handler om. For eksempel: «Hva er temperaturen i India?» Her er konteksten at brukeren ønsker å vite «temperaturen i India». Kort sagt, hovedmålet med en setning er kontekst. Ordene eller setningene som omgir muntlig eller skriftlig språk bidrar til å bestemme betydningen av konteksten. Word2vec lærer vektorrepresentasjonen av ord gjennom disse kontekstene.

Hva gjør Word2vec?

Før Word-innbygging

Det er viktig å vite hvilken tilnærming som ble brukt før ordinnbygging og hva dens ulemper er, og deretter skal vi se hvordan disse ulempene overvinnes ved ordinnbygging ved hjelp av Word2vec-tilnærmingen. Til slutt skal vi gå videre til hvordan Word2vec fungerer, fordi det er viktig å forstå hvordan det fungerer.

Tilnærming for latent semantisk analyse

Dette er tilnærmingen som ble brukt før ordinnbygging. Den brukte konseptet med en ordpose, der ord er representert i form av kodede vektorer. Det er en sparsom vektorrepresentasjon der dimensjonen er lik størrelsen på vokabularet. Hvis ordet forekommer i ordboken, telles det; ellers telles det ikke. For å forstå mer, se programmet nedenfor.

Word2vec eksempel

from sklearn.feature_extraction.text import CountVectorizer

vectorizer = CountVectorizer()
data_corpus = ["guru99 is the best site for online tutorials. I love to visit guru99."]
vocabulary = vectorizer.fit(data_corpus)
X = vectorizer.transform(data_corpus)

print(X.toarray())
print(vectorizer.get_feature_names_out())

Utgang:

[[1 2 1 1 1 1 1 1 1 1]]
[u'best', u'guru99', u'is', u'love', u'online', u'sitefor', u'the', u'to', u'tutorials', u'visit']

Code Forklaring

1. CountVectorizer er modulen som brukes til å lagre vokabularet basert på tilpasning av ordene i det. Dette importeres fra sklearn.
2. Lag objektet ved å bruke klassen CountVectorizer.
3. Skriv dataene i listen som skal tilpasses i CountVectorizer.
4. Data passer inn i objektet som er opprettet fra klassen CountVectorizer.
5. Bruk en ordsekkmetode for å telle ord i dataene ved hjelp av vokabularet. Hvis et ord eller token ikke er tilgjengelig i vokabularet, settes en slik indeksposisjon til null.
6. Variabelen i linje 5, som er x, konverteres til en matrise (en metode tilgjengelig for x). Dette gir antallet av hvert token i setningen eller listen som er oppgitt i linje 3.
7. Dette viser funksjonene som er en del av vokabularet når det tilpasses ved hjelp av dataene i linje 4.

I den latente semantiske tilnærmingen representerer raden unike ord, mens kolonnen representerer antall ganger ordet forekommer i dokumentet. Det er en representasjon av ord i form av en dokumentmatrise. Termfrekvens-invers dokumentfrekvens (TF-IDF) brukes til å telle frekvensen av ord i dokumentet, som er frekvensen av termen i dokumentet delt på frekvensen av termen i hele korpuset.

Mangel på Bag of Words-metoden

• Den ignorerer rekkefølgen på ordene; for eksempel, dette er dårlig = dårlig er dette.
• Den ignorerer ordenes kontekst. Anta at vi skriver setningen «Han elsket bøker. Utdanning finnes best i bøker». Det ville opprette to vektorer: én for «Han elsket bøker» og en annen for «Utdanning finnes best i bøker». Den ville behandle begge som ortogonale, noe som gjør dem uavhengige, men i virkeligheten er de relatert til hverandre.

For å overvinne disse begrensningene ble ordinnebygging utviklet, og Word2vec er én tilnærming som brukes for å implementere det.

Hvordan fungerer Word2vec?

Word2vec lærer et ord ved å forutsi konteksten i det omkringliggende ordet. La oss for eksempel ta ordet «Han elsker Fotball."

Vi ønsker å beregne Word2vec for ordet: elsker.

Anta:

loves = Vin. P(Vout / Vin) is calculated
where,
Vin is the input word.
P is the probability of likelihood.
Vout is the output word.

Ordet elsker beveger seg over hvert ord i korpuset. Syntaktiske så vel som semantiske forhold mellom ord er kodet. Dette hjelper med å finne lignende og analoge ord.

Alle tilfeldige trekk ved ordet elsker beregnes. Disse funksjonene endres eller oppdateres i forhold til naboord eller kontekstord ved hjelp av en Ryggformering metoden.

En annen måte å lære på er at hvis konteksten til to ord er like, eller to ord har lignende trekk, så er slike ord beslektet.

Word2vec Architecture

Det er to arkitekturer som brukes av Word2vec:

1. Kontinuerlig pose med ord (CBOW)
2. Skip-gram

Før vi går videre, la oss diskutere hvorfor disse arkitekturene eller modellene er viktige fra et ordrepresentasjonsperspektiv. Læring av ordrepresentasjon er i hovedsak uovervåket, men mål/etiketter er nødvendige for å trene modellen. Skip-gram og CBOW konverterer den uovervåkede representasjonen til en overvåket form for modelltrening.

I CBOW blir det gjeldende ordet forutsagt ved å bruke vinduet til omkringliggende kontekstvinduer. For eksempel, hvis w_i-1, W_i-2, W_{jeg + 1}, W_{jeg + 2} gis ord eller kontekst, vil denne modellen gi w_i.

Skip-Gram utfører det motsatte av CBOW, som innebærer at den forutsier den gitte sekvensen eller konteksten fra ordet. Du kan reversere eksemplet for å forstå det. Hvis w_i er gitt, vil dette forutsi konteksten, eller w_i-1, W_i-2, W_{jeg + 1}, W_{jeg + 2}.

Word2vec gir et alternativ for å velge mellom CBOW (Continuous Bag of Words) og skip-gram. Slike parametere gis under treningen av modellen. Man kan ha muligheten til å bruke negativ sampling eller et hierarkisk softmax-lag.

Kontinuerlig pose med ord

La oss tegne et enkelt Word2vec-eksempeldiagram for å forstå den kontinuerlige «pose-of-words»-arkitekturen.

La oss regne ut ligningene matematisk. Anta at V er vokabularstørrelsen og N er størrelsen på det skjulte laget. Inndata er definert som { x_i-1, x_i-2, x_{jeg + 1}, x_{jeg + 2} }. Vi får vektmatrisen ved å multiplisere V * N. En annen matrise fås ved å multiplisere inngangsvektoren med vektmatrisen. Dette kan også forstås av følgende ligning.

h = xi^tW

hvor xi^t og W er henholdsvis inngangsvektoren og vektmatrisen.

For å beregne samsvaret mellom kontekst og det neste ordet, se ligningen nedenfor.

u = predikert representasjon * h

hvor predikert representasjon er hentet fra modellen i ligningen ovenfor.

Skip-Gram-modell

Skip-Gram-metoden brukes til å forutsi en setning gitt et inndataord. For å forstå det bedre, la oss tegne diagrammet som er vist i Word2vec-eksemplet nedenfor.

Man kan behandle det som det motsatte av modellen med kontinuerlig ordpose, hvor inputen er ordet og modellen gir konteksten eller sekvensen. Vi kan også konkludere med at målet mates til inputen, og utdatalaget replikeres flere ganger for å få plass til det valgte antallet kontekstord. Feilvektoren fra alle utdatalagene summeres for å justere vekter via en tilbakepropageringsmetode.

Hvilken modell å velge?

CBOW er flere ganger raskere enn skip-gram og gir en bedre frekvens for hyppige ord, mens skip-gram trenger en liten mengde treningsdata og representerer selv sjeldne ord eller uttrykk. Tabellen nedenfor sammenligner begge arkitekturene med et raskt blikk.

Forholdet mellom Word2vec og NLTK

NLTK er det naturlige Language Toolkit. Det brukes til forbehandling av tekst. Man kan utføre forskjellige operasjoner som ordklassetagging, lemmatisering, stemming, fjerning av stoppord og fjerning av sjeldne eller minst brukte ord. Det hjelper med å rense teksten samt forberede funksjoner fra de effektive ordene. På den annen side brukes Word2vec til semantisk (nært beslektede elementer sammen) og syntaktisk (sekvens) matching. Ved å bruke Word2vec kan man finne lignende ord, ulike ord, dimensjonal reduksjon og mye annet. En annen viktig funksjon i Word2vec er å konvertere den høyere dimensjonale representasjonen av tekst til lavere dimensjonale vektorer.

Hvor skal jeg bruke NLTK og Word2vec?

Hvis man må utføre noen generelle oppgaver som nevnt ovenfor, som tokenisering, POS-tagging og parsing, må man bruke NLTK, mens man må bruke Word2vec for å forutsi ord i henhold til kontekst, emnemodellering eller dokumentlikhet.

Relasjon mellom NLTK og Word2vec ved hjelp av kode

NLTK og Word2vec kan brukes sammen for å finne lignende ordrepresentasjoner eller syntaktisk matching. NLTK-verktøysettet kan brukes til å laste inn mange pakker som følger med NLTK, og en modell kan opprettes ved hjelp av Word2vec. Den kan deretter testes på sanntidsord. La oss se kombinasjonen av begge i følgende kode. Før du går videre med prosessen, ta en titt på korpusa som NLTK tilbyr. Du kan laste den ned ved hjelp av kommandoen:

nltk(nltk.download('all'))

Se skjermbildet for koden.

import nltk
import gensim
from nltk.corpus import abc

model = gensim.models.Word2Vec(abc.sents())
X = list(model.wv.vocab)
data = model.most_similar('science')
print(data)

Utgang:

[('law', 0.9415997266769409), ('practice', 0.9276568293571472), ('discussion', 0.9259148836135864), ('agriculture', 0.9257254004478455), ('media', 0.9232194423675537), ('policy', 0.922248125076294), ('general', 0.9166069030761719), ('undertaking', 0.916458249092102), ('tight', 0.9129181504249573), ('board', 0.9107444286346436)]

Forklaring til Code

1. Nltk-biblioteket importeres, hvorfra du kan laste ned abc-korpuset som vi skal bruke i neste trinn.
2. Gensim er importert. Hvis Gensim Word2vec ikke er installert, installer det ved å bruke kommandoen «pip3 install gensim». Se skjermbildet nedenfor.

3. Importer abc-korpuset, som er lastet ned ved hjelp av nltk.download('abc').
4. Send filene til Word2vec-modellen, som importeres ved hjelp av Gensim, som setninger.
5. Vokabularet lagres i form av en variabel.
6. Modellen testes på eksempelordet vitenskap, ettersom disse filene er relatert til vitenskap.
7. Her forutsies det lignende ordet «vitenskap» av modellen.

Aktivatorer og Word2Vec

Aktiveringsfunksjonen til et nevron definerer utgangen fra det gitt et sett med input. Den er biologisk inspirert av aktivitet i hjernen vår, der forskjellige nevroner aktiveres ved hjelp av forskjellige stimuli. La oss forstå aktiveringsfunksjonen gjennom følgende diagram.

Her er x1, x2, … x4 nodene i det nevrale nettverket.

w1, w2, w3 er vektene til nodene.

Summen (Σ) av alle vekter og nodeverdier fungerer som aktiveringsfunksjon.

Hvorfor aktiveringsfunksjon?

Hvis ingen aktiveringsfunksjon brukes, vil utgangen være lineær, men funksjonaliteten til en lineær funksjon er begrenset. For å oppnå kompleks funksjonalitet som objektdeteksjon, bildeklassifisering, osv.ping tekst ved hjelp av stemme, og mange andre ikke-lineære utganger, er det behov for en aktiveringsfunksjon.

Hvordan aktiveringslaget beregnes i ordet innebygging (Word2vec)

Softmax-laget (normalisert eksponensiell funksjon) er utdata-lagsfunksjonen som aktiverer eller utløser hver node. En annen tilnærming som brukes er hierarkisk softmax, hvor kompleksiteten beregnes ved O(log₂V), mens i softmax er den O(V), hvor V er vokabularstørrelsen. Forskjellen mellom disse er reduksjonen av kompleksiteten i det hierarkiske softmax-laget. For å forstå funksjonaliteten, se på eksemplet på Word-innebygging nedenfor:

Anta at vi ønsker å beregne sannsynligheten for å observere ordet elsker gitt en viss kontekst. Flyten fra roten til bladnoden vil først bevege seg til node 2 og deretter til node 5. Så hvis vi har en vokabularstørrelse på 8, er det bare behov for tre beregninger. Dette tillater dekomponering av beregningen av sannsynligheten for ett ord (elsker).

Hvilke andre alternativer er tilgjengelige enn Hierarchical Softmax?

Generelt sett er de tilgjengelige innebyggingsalternativene Differensiert Softmax, CNN-Softmax, viktighetssampling, adaptiv viktighetssampling, støykontrastiv estimering, negativ sampling, selvnormalisering og sjelden normalisering.

Når det gjelder Word2vec, har vi negativ sampling tilgjengelig.

Negativ sampling er en måte å sample treningsdata på. Det ligner litt på stokastisk gradientnedstigning, men med noen forskjeller. Negativ sampling ser bare etter negative treningseksempler. Den er basert på støykontrastsiv estimering og sampler tilfeldig ord som ikke er i konteksten. Det er en rask treningsmetode og velger konteksten tilfeldig. Hvis det forutsagte ordet vises i den tilfeldig valgte konteksten, er begge vektorene nær hverandre.

Hvilken konklusjon kan man trekke?

Aktivatorer aktiverer nevronene akkurat som nevronene våre aktiveres av eksterne stimuli. Softmax-laget er en av output-lagets funksjoner som aktiverer nevronene ved innebygging av ord. I Word2vec har vi alternativer som hierarkisk softmax og negativ sampling. Ved hjelp av aktivatorer kan man konvertere en lineær funksjon til en ikke-lineær funksjon, og en kompleks maskinlæringsalgoritme kan implementeres ved hjelp av slike funksjoner.

Hva er Gensim?

Gensim er en åpen kildekode-emnemodellering og verktøysett for behandling av naturlig språk som er implementert i Python og Cython. Gensim-verktøysettet lar brukere importere Word2vec for emnemodellering for å oppdage skjult struktur i teksten. Gensim tilbyr ikke bare en implementering av Word2vec, men også Doc2vec og FastText.

Denne delen fokuserer på Word2vec, så vi holder oss til det nåværende emnet.

Hvordan implementere Word2vec ved hjelp av Gensim

Frem til nå har vi diskutert hva Word2vec er, de ulike arkitekturene, hvorfor det er et skifte fra en ordpose til Word2vec, forholdet mellom Word2vec og NLTK med livekode, og aktiveringsfunksjoner.

Nedenfor finner du en trinnvis metode for å implementere Word2vec ved hjelp av Gensim:

Trinn 1) Datainnsamling

Det første trinnet for å implementere enhver maskinlæringsmodell eller implementering av naturlig språkbehandling er datainnsamling.

Vennligst observer dataene for å bygge en intelligent chatbot som vist i Gensim Word2vec-eksemplet nedenfor.

[{"tag": "welcome",
"patterns": ["Hi", "How are you", "Is any one to talk?", "Hello", "hi are you available"],
"responses": ["Hello, thanks for contacting us", "Good to see you here", "Hi there, how may I assist you?"]
        },
{"tag": "goodbye",
"patterns": ["Bye", "See you later", "Goodbye", "I will come back soon"],
"responses": ["See you later, thanks for visiting", "have a great day ahead", "Wish you Come back again soon."]
        },
{"tag": "thankful",
"patterns": ["Thanks for helping me", "Thank your guidance", "That's helpful and kind from you"],
"responses": ["Happy to help!", "Any time!", "My pleasure", "It is my duty to help you"]
        },
        {"tag": "hoursopening",
"patterns": ["What hours are you open?", "Tell your opening time?", "When are you open?", "Just your timing please"],
"responses": ["We're open every day 8am-7pm", "Our office hours are 8am-7pm every day", "We open office at 8 am and close at 7 pm"]
        },
{"tag": "payments",
"patterns": ["Can I pay using credit card?", "Can I pay using Mastercard?", "Can I pay using cash only?"],
"responses": ["We accept VISA, Mastercard and credit card", "We accept credit card, debit cards and cash. Please don't worry"]
        }
   ]

Her er hva vi forstår ut fra dataene:

• Disse dataene inneholder tre ting: tagg, mønster og responser. Taggen er intensjonen (hva som er diskusjonsemnet).
• Dataene er i JSON-format.
• Et mønster er et spørsmål brukere stiller boten.
• Svar er svarene som chatboten vil gi på det tilsvarende spørsmålet/mønsteret.

Trinn 2) Dataforbehandling

Det er svært viktig å behandle rådataene. Hvis rensede data mates til maskinen, vil modellen reagere mer nøyaktig og lære dataene mer effektivt.

Dette trinnet innebærer å fjerne stoppord, stemming, unødvendige ord osv. Før du går videre, er det viktig å laste inn data og konvertere dem til en dataramme. Se koden nedenfor for dette.

import json
json_file = 'intents.json'
with open('intents.json', 'r') as f:
    data = json.load(f)

Forklaring til Code:

1. Siden dataene er i JSON-format, importeres json.
2. Filen lagres i variabelen.
3. Filen åpnes og lastes inn i datavariabelen.

Nå er dataene importert, og det er på tide å konvertere dataene til en dataramme. Se koden nedenfor for neste trinn.

import pandas as pd
df = pd.DataFrame(data)
df['patterns'] = df['patterns'].apply(', '.join)

Forklaring til Code:

1. Data konverteres til en dataramme ved hjelp av pandaer, som ble importert ovenfor.

2. Den konverterer listen i kolonnemønstrene til en streng.

from nltk.corpus import stopwords
from textblob import Word
stop = stopwords.words('english')
df['patterns'] = df['patterns'].apply(lambda x: ' '.join(x.lower() for x in x.split()))
df['patterns'] = df['patterns'].apply(lambda x: ' '.join(x for x in x.split() if x not in string.punctuation))
df['patterns'] = df['patterns'].str.replace('[^\w\s]', '')
df['patterns'] = df['patterns'].apply(lambda x: ' '.join(x for x in x.split() if not x.isdigit()))
df['patterns'] = df['patterns'].apply(lambda x: ' '.join(x for x in x.split() if x not in stop))
df['patterns'] = df['patterns'].apply(lambda x: " ".join([Word(word).lemmatize() for word in x.split()]))

Code Forklaring:

1. Engelske stoppord importeres ved hjelp av stoppordmodulen fra nltk-verktøysettet.

2. Alle ordene i teksten konverteres til små bokstaver ved hjelp av en for-betingelse og en lambda-funksjon. Lambda funksjon er en anonym funksjon.

3. Alle tekstradene i datarammen kontrolleres for tegnsetting, og disse filtreres.

4. Tegn som tall eller punktum fjernes ved hjelp av et regulært uttrykk.

5. Digits fjernes fra teksten.

6. Stoppord fjernes på dette stadiet.

7. Ord filtreres nå, og forskjellige former av det samme ordet fjernes ved hjelp av lemmatisering. Med dette er vi ferdige med dataforbehandlingen.

Utgang:

, patterns, responses, tag
0,hi one talk hello hi available,"['Hello, thanks for contacting us', 'Good to see you here', ' Hi there, how may I assist you?']",welcome
1,bye see later goodbye come back soon,"['See you later, thanks for visiting', 'have a great day ahead', 'Wish you Come back again soon.']",goodbye
2,thanks helping thank guidance thats helpful kind,"['Happy to help!', 'Any time!', 'My pleasure', 'It is my duty to help you']",thankful
3,hour open tell opening time open timing please,"[""We're open every day 8am-7pm"", 'Our office hours are 8am-7pm every day', 'We open office at 8 am and close at 7 pm']",hoursopening
4,pay using credit card pay using mastercard pay using cash,"['We accept VISA, Mastercard and credit card', 'We accept credit card, debit cards and cash. Please dont worry']",payments

Trinn 3) Bygging av nevrale nettverk ved hjelp av Word2vec

Nå er det på tide å bygge en modell ved hjelp av Gensim Word2vec-modulen. Vi må importere Word2vec fra Gensim. La oss gjøre dette, og så skal vi bygge den, og i den siste fasen skal vi sjekke modellen på sanntidsdata.

from gensim.models import Word2Vec

Nå kan vi bygge modellen med Word2Vec. Se neste kodelinje for å lære hvordan du oppretter modellen med Word2Vec. Tekst gis til modellen i form av en liste, så vi konverterer teksten fra datarammen til en liste ved hjelp av koden nedenfor.

Bigger_list = []
for i in df['patterns']:
     li = list(i.split(""))
     Bigger_list.append(li)
Model = Word2Vec(Bigger_list, min_count=1, size=300, workers=4)

Forklaring til Code:

1. Opprettet bigger_list der den indre listen legges til. Dette er formatet som mates til modellen Word2Vec.

2. En løkke implementeres, og hver oppføring i mønsterkolonnen i datarammen itereres.

3. Hvert element i kolonnemønstrene deles og lagres i den indre listen li.

4. Den indre listen legges til den ytre listen.

5. Denne listen er gitt til Word2Vec-modellen. La oss forstå noen av parameterne som er gitt her.

Min_antall: Den ignorerer alle ordene med en total frekvens som er lavere enn dette.

Størrelse: Den forteller dimensjonaliteten til ordet vektorer.

arbeidere: Dette er trådene for å trene modellen.

Det finnes også andre alternativer, og noen viktige av disse er forklart nedenfor.

Vindu: Maksimal avstand mellom gjeldende og predikerte ord i en setning.

Sg: Det er en treningsalgoritme: 1 for skip-gram og 0 for en kontinuerlig pose med ord. Vi har diskutert disse i detalj ovenfor.

Hs: Hvis dette er 1, bruker vi hierarkisk softmax for trening, og hvis 0, brukes negativ sampling.

Alpha: Innledende læringsrate.

La oss vise den endelige koden nedenfor:

# list of libraries used by the code
import string
from gensim.models import Word2Vec
import logging
from nltk.corpus import stopwords
from textblob import Word
import json
import pandas as pd
# data in json format
json_file = 'intents.json'
with open('intents.json', 'r') as f:
    data = json.load(f)
# displaying the list of stopwords
stop = stopwords.words('english')
# dataframe
df = pd.DataFrame(data)

df['patterns'] = df['patterns'].apply(', '.join)
# cleaning the data using the NLP approach
print(df)
df['patterns'] = df['patterns'].apply(lambda x: ' '.join(x.lower() for x in x.split()))
df['patterns'] = df['patterns'].apply(lambda x: ' '.join(x for x in x.split() if x not in string.punctuation))
df['patterns'] = df['patterns'].str.replace('[^\w\s]', '')
df['patterns'] = df['patterns'].apply(lambda x: ' '.join(x for x in x.split() if not x.isdigit()))
df['patterns'] = df['patterns'].apply(lambda x: ' '.join(x for x in x.split() if x not in stop))
df['patterns'] = df['patterns'].apply(lambda x: " ".join([Word(word).lemmatize() for word in x.split()]))
# taking the outer list
bigger_list = []
for i in df['patterns']:
    li = list(i.split(" "))
    bigger_list.append(li)
# structure of data to be taken by the model.word2vec
print("Data format for the overall list:", bigger_list)
# custom data is fed to machine for further processing
model = Word2Vec(bigger_list, min_count=1, size=300, workers=4)

Trinn 4) Modelllagring

Modellen kan lagres i form av en bin-fil og en modellfil. Bin er det binære formatet. Se linjene nedenfor for å lagre modellen.

model.save("word2vec.model")
model.save("model.bin")

Forklaring av koden ovenfor

1. Modellen lagres i form av en .model-fil.

2. Modellen lagres i form av en .bin-fil.

Vi vil bruke denne modellen til å gjøre sanntidstesting, for eksempel lignende ord, ulike ord og vanligste ord.

Trinn 5) Laster modellen og utfører sanntidstesting

Modellen lastes inn ved hjelp av koden nedenfor:

model = Word2Vec.load('model.bin')

Hvis du vil skrive ut vokabularet fra den, gjøres det ved å bruke kommandoen nedenfor:

vocab = list(model.wv.vocab)

Vennligst se resultatet:

['see', 'thank', 'back', 'thanks', 'soon', 'open', 'mastercard', 'card', 'time', 'pay', 'talk', 'cash', 'one', 'please', 'goodbye', 'thats', 'helpful', 'hour', 'credit', 'hi', 'later', 'guidance', 'opening', 'timing', 'hello', 'helping', 'bye', 'tell', 'come', 'using', 'kind', 'available']

Trinn 6) De fleste lignende ord sjekker

La oss implementere tingene praktisk:

similar_words = model.most_similar('thanks')
print(similar_words)

Vennligst se resultatet:

[('kind', 0.16104359924793243), ('using', 0.1352398842573166), ('come', 0.11500970274209976), ('later', 0.09989878535270691), ('helping', 0.04855936020612717), ('credit', 0.04659383371472359), ('pay', 0.0329081267118454), ('thank', 0.02484947443008423), ('hour', 0.0202352125197649), ('opening', 0.018177658319473267)]

Trinn 7) Samsvarer ikke med ord fra ord som er levert

dissimlar_words = model.doesnt_match('See you later, thanks for visiting'.split())
print(dissimlar_words)

Vi har levert ordene «Vi sees senere, takk for besøket»Dette skriver ut det mest ulike ordet fra disse ordene. La oss kjøre denne koden og finne resultatet.

Resultatet etter utførelse av koden ovenfor:

Thanks

Trinn 8) Finne likheten mellom to ord

Dette forteller resultatet i form av sannsynligheten for likhet mellom to ord. Se koden nedenfor for hvordan du utfører denne delen.

similarity_two_words = model.similarity('please', 'see')
print("Please provide the similarity between these two words:")
print(similarity_two_words)

Resultatet av koden ovenfor er som følger:

0.13706

Du kan finne lignende ord ved å kjøre koden nedenfor:

similar = model.similar_by_word('kind')
print(similar)

Utdata fra koden ovenfor:

[('credit', 0.11764447391033173), ('cash', 0.11440904438495636), ('one', 0.11151769757270813), ('hour', 0.0944807156920433), ('using', 0.0705675333738327), ('thats', 0.05206916481256485), ('later', 0.04502468928694725), ('bye', 0.03960943967103958), ('back', 0.03837274760007858), ('thank', 0.0380823090672493)]

Spørsmål og svar