Word Inbäddning och Word2Vec-modell med exempel

Vad är Word Inbäddning?

Inbäddning av ord är en ordrepresentationstyp som låter maskininlärningsalgoritmer förstå ord med liknande betydelser. Det är en språkmodellerings- och funktionsinlärningsteknik för att kartlägga ord till vektorer av reella tal med hjälp av neurala nätverk, probabilistiska modeller eller dimensionsreduktion på ordsamförekomstmatrisen. Vissa ordinbäddningsmodeller är Word2vec (Google), Glove (Stanford) och snabbaste (Facebook).

Ordinbäddning kallas också som distribuerad semantisk modell eller distribuerad representerad eller semantisk vektorrymd eller vektorrymdsmodell. När du läser dessa namn stöter du på ordet semantisk som betyder att kategorisera liknande ord tillsammans. Till exempel bör frukter som äpple, mango, banan placeras nära medan böcker kommer att vara långt borta från dessa ord. I en vidare mening kommer ordinbäddning att skapa vektorn av frukter som kommer att placeras långt bort från vektorrepresentation av böcker.

Var används Word Inbäddning?

Ordinbäddning hjälper till att skapa funktioner, dokumentkluster, textklassificering och bearbetning av naturliga språk. Låt oss lista dem och diskutera var och en av dessa applikationer.

• Beräkna liknande ord: Ordinbäddning används för att föreslå ord som liknar det ord som utsätts för prediktionsmodellen. Tillsammans med det föreslår det också olika ord, såväl som de vanligaste orden.
• Skapa en grupp relaterade ord: Det används för semantisk gruppering som kommer att gruppera saker med liknande egenskaper tillsammans och olika långt borta.
• Funktion för textklassificering: Text mappas till vektorer som matas till modellen för såväl träning som förutsägelse. Textbaserade klassificeringsmodeller kan inte tränas på strängen, så detta kommer att konvertera texten till maskininlärningsbar form. Ytterligare dess funktioner för att bygga semantisk hjälp i textbaserad klassificering.
• Dokumentklustring: är en annan applikation där Word Embedding Word2vec används flitigt
• Naturlig språkbehandling: Det finns många applikationer där ordinbäddning är användbart och vinner över faser för extraktion av funktioner som delar av taltaggning, sentimental analys och syntaktisk analys. Nu har vi fått lite kunskap om ordinbäddning. Lite ljus kastas också över olika modeller för att implementera ordinbäddning. Hela denna handledning för Word Inbäddning är fokuserad på en av modellerna (Word2vec).

Vad är Word2vec?

Word2vec är en teknik/modell för att producera ordinbäddning för bättre ordrepresentation. Det är en naturlig språkbehandlingsmetod som fångar ett stort antal exakta syntaktiska och semantiska ordrelationer. Det är ett grunt tvåskiktigt neuralt nätverk som kan upptäcka synonyma ord och föreslå ytterligare ord för delmeningar när det väl har tränats.

Innan du går vidare i denna Word2vec-handledning, se skillnaden mellan grunt och djupt neuralt nätverk som visas i nedanstående Word-inbäddningsexempeldiagram:

Det grunda neurala nätverket består av det enda dolda lagret mellan ingång och utdata medan djupa neurala nätverk innehåller flera dolda lager mellan input och utdata. Indata utsätts för noder medan det dolda lagret, såväl som utdatalagret, innehåller neuroner.

Word2vec är ett tvålagersnätverk där det finns ingång ett dolt lager och utgång.

Word2vec utvecklades av en grupp forskare under ledning av Tomas Mikolov på Google. Word2vec är bättre och effektivare den latenta semantiska analysmodellen.

Varför Word2vec?

Word2vec representerar ord i vektorrumsrepresentation. Ord representeras i form av vektorer och placeringen görs på ett sådant sätt att liknande betydelseord uppträder tillsammans och olika ord finns långt borta. Detta kallas också som en semantisk relation. Neurala nätverk förstår inte text istället förstår de bara siffror. Word Inbäddning ger ett sätt att konvertera text till en numerisk vektor.

Word2vec rekonstruerar ords språkliga sammanhang. Innan vi går vidare låt oss förstå, vad är språklig kontext? I ett allmänt livsscenario när vi pratar eller skriver för att kommunicera, försöker andra människor ta reda på vad som är meningen med meningen. Till exempel, "Vad är temperaturen i Indien", här är sammanhanget att användaren vill veta "temperaturen i Indien", vilket är sammanhang. Kort sagt, huvudsyftet med en mening är sammanhang. Ord eller mening som omger talat eller skrivet språk (avslöjande) hjälper till att bestämma innebörden av sammanhang. Word2vec lär sig vektorrepresentation av ord genom sammanhangen.

Vad gör Word2vec?

Innan Word inbäddning

Det är viktigt att veta vilket tillvägagångssätt som används innan ordinbäddning och vilka är dess nackdelar och sedan kommer vi att gå till ämnet om hur nackdelar övervinns genom Word-inbäddning med Word2vec-metoden. Slutligen kommer vi att flytta hur Word2vec fungerar eftersom det är viktigt att förstå att det fungerar.

Metod för latent semantisk analys

Detta är tillvägagångssättet som användes innan ordinbäddningar. Den använde konceptet Bag of words där ord representeras i form av kodade vektorer. Det är en gles vektorrepresentation där dimensionen är lika med storleken på ordförrådet. Om ordet förekommer i ordboken räknas det, annars inte. För att förstå mer, se programmet nedan.

Word2vec Exempel

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

Produktion:

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

Kodförklaring

1. CountVectorizer är modulen som används för att lagra ordförrådet baserat på att orden passar in i den. Detta är importerat från sklearn.
2. Gör objektet med klassen CountVectorizer.
3. Skriv in data i listan som ska passas in i CountVectorizer.
4. Data passar in i objektet som skapats från klassen CountVectorizer.
5. Använd en påse med ord för att räkna ord i data med hjälp av ordförråd. Om ord eller token inte är tillgängligt i vokabulären, så sätts sådan indexposition till noll.
6. Variabel på rad 5 som är x konverteras till en array (metod tillgänglig för x). Detta kommer att ge räkningen av varje token i meningen eller listan i rad 3.
7. Detta kommer att visa funktionerna som är en del av ordförrådet när det är anpassat med hjälp av data i rad 4.

I Latent Semantic-metoden representerar raden unika ord medan kolumnen representerar antalet gånger som ordet förekommer i dokumentet. Det är en representation av ord i form av dokumentmatrisen. Term-Frequency inverse document frequency (TFIDF) används för att räkna frekvensen av ord i dokumentet, vilket är termens frekvens i dokumentet/termens frekvens i hela korpusen.

Brist på Bag of Words-metoden

• Den ignorerar ordningen på ordet, till exempel, det här är dåligt = dåligt är det här.
• Den ignorerar ordens sammanhang. Antag att om jag skriver meningen "Han älskade böcker. Utbildning finns bäst i böcker”. Det skulle skapa två vektorer, en för "Han älskade böcker" och en annan för "Utbildning finns bäst i böcker." Det skulle behandla dem båda ortogonala vilket gör dem oberoende, men i verkligheten är de relaterade till varandra

För att övervinna dessa begränsningar utvecklades ordinbäddning och Word2vec är ett sätt att implementera sådant.

Hur fungerar Word2vec?

Word2vec lär sig ord genom att förutsäga dess omgivande kontext. Låt oss till exempel ta ordet "Han älskar Fotboll."

Vi vill beräkna Word2vec för ordet: älskar.

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. 	

ord älskar flyttar över varje ord i korpusen. Syntaktisk såväl som semantisk relation mellan ord är kodad. Detta hjälper till att hitta liknande ord och analogier.

Alla slumpmässiga drag i ordet älskar beräknas. Dessa funktioner ändras eller uppdateras gällande grann- eller sammanhangsord med hjälp av en Ryggförökning metod.

Ett annat sätt att lära sig är att om sammanhanget för två ord är lika eller två ord har liknande egenskaper, så är sådana ord relaterade.

Word2vec Architecture

Det finns två arkitekturer som används av Word2vec:

1. Kontinuerlig påse med ord (CBOW)
2. Hoppa över gram

Innan vi går vidare i denna Word2vec-handledning, låt oss diskutera varför dessa arkitekturer eller modeller är viktiga ur ordrepresentationssynpunkt. Att lära sig ordrepresentation är i huvudsak oövervakat, men mål/etiketter behövs för att träna modellen. Skip-gram och CBOW konverterar oövervakad representation till övervakad form för modellträning.

I CBOW förutsägs det aktuella ordet med fönstret för omgivande sammanhangsfönster. Till exempel, om w_i-1,w_i-2,w_{i + 1},w_{i + 2}ges ord eller sammanhang, kommer denna modell att ge w_i

Skip-Gram utför motsatsen till CBOW vilket innebär att det förutsäger den givna sekvensen eller sammanhanget från ordet. Du kan vända exemplet för att förstå det. Om w_i ges, kommer detta att förutsäga sammanhanget eller w_i-1,w_i-2,w_{i + 1},w_i+2.

Word2vec ger ett alternativ att välja mellan CBOW (continuous Bag of words) och skim-gram. Sådana parametrar tillhandahålls under träning av modellen. Man kan ha möjlighet att använda negativ sampling eller hierarkiskt softmax-lager.

Kontinuerlig påse med ord

Låt oss rita ett enkelt Word2vec-exempeldiagram för att förstå den kontinuerliga påsen av ordarkitektur.

Låt oss beräkna ekvationerna matematiskt. Antag att V är ordförrådets storlek och N är storleken på det dolda lagret. Indata definieras som { x_i-1, x_i-2, x_i+1, x_{i + 2}}. Vi får viktmatrisen genom att multiplicera V * N. En annan matris erhålls genom att multiplicera ingångsvektorn med viktmatrisen. Detta kan också förstås av följande ekvation.

h=xi^tW

där xi^t? W är ingångsvektorn respektive viktmatrisen,

För att beräkna matchningen mellan kontext och nästa ord, se nedanstående ekvation

u=förutspådd representation*h

där förutspådd representation erhålls modell?h ​​i ovanstående ekvation.

Skip-Gram-modell

Skip-Gram-metoden används för att förutsäga en mening med ett inmatningsord. För att förstå det bättre låt oss rita diagrammet som visas i Word2vec-exemplet nedan.

Man kan behandla det som det omvända till modellen för kontinuerlig påse med ord där ingången är ordet och modellen ger sammanhanget eller sekvensen. Vi kan också dra slutsatsen att målet matas till ingångs- och utgångsskiktet replikeras flera gånger för att tillgodose det valda antalet kontextord. Felvektor från hela utgångsskiktet summeras för att justera vikter via en backpropagation-metod.

Vilken modell ska man välja?

CBOW är flera gånger snabbare än hoppa över gram och ger en bättre frekvens för vanliga ord medan hoppa över gram behöver en liten mängd träningsdata och representerar till och med sällsynta ord eller fraser.

Relationen mellan Word2vec och NLTK

Nltk är en naturlig språkverktygslåda. Den används för förbearbetning av texten. Man kan göra olika operationer som delar av taltaggning, lemmatisering, stemming, stoppa borttagning av ord, ta bort sällsynta ord eller minst använda ord. Det hjälper till att rengöra texten samt hjälper till att förbereda funktionerna från de effektiva orden. På det andra sättet används Word2vec för semantisk (nära relaterade objekt tillsammans) och syntaktisk (sekvens) matchning. Med Word2vec kan man hitta liknande ord, olika ord, dimensionsreduktion och många andra. En annan viktig egenskap hos Word2vec är att konvertera den högre dimensionella representationen av texten till lägre dimensionella vektorer.

Var använder man NLTK och Word2vec?

Om man måste utföra några allmänna uppgifter som nämnts ovan som tokenisering, POS-taggning och parsning måste man använda NLTK medan man för att förutsäga ord enligt något sammanhang, ämnesmodellering eller dokumentlikhet måste använda Word2vec.

Relation mellan NLTK och Word2vec med hjälp av kod

NLTK och Word2vec kan användas tillsammans för att hitta liknande ordrepresentation eller syntaktisk matchning. NLTK verktygslåda kan användas för att ladda många paket som kommer med NLTK och modell kan skapas med Word2vec. Det kan sedan testas på realtidsord. Låt oss se kombinationen av båda i följande kod. Innan du bearbetar vidare, vänligen ta en titt på de korpus som NLTK tillhandahåller. Du kan ladda ner med kommandot

nltk(nltk.download('all'))

Se skärmdumpen för 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)

Produktion:

[('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)]

Förklaring av koden

1. nltk-biblioteket importeras varifrån du kan ladda ner abc-korpusen som vi kommer att använda i nästa steg.
2. Gensim är importerad. Om Gensim Word2vec inte är installerat, installera det med kommandot "pip3 install gensim". Se skärmdumpen nedan.

3. importera corpus abc som har laddats ner med nltk.download('abc').
4. Skicka filerna till modellen Word2vec som importeras med Gensim som meningar.
5. Ordförrådet lagras i form av variabeln.
6. Modellen testas på exempel på ordvetenskap eftersom dessa filer är relaterade till vetenskap.
7. Här förutsägs det liknande ordet "vetenskap" av modellen.

Aktivatorer och Word2Vec

Neuronens aktiveringsfunktion definierar utsignalen från den neuronen givet en uppsättning ingångar. Biologiskt inspirerad av en aktivitet i våra hjärnor där olika neuroner aktiveras med hjälp av olika stimuli. Låt oss förstå aktiveringsfunktionen genom följande diagram.

Här är x1,x2,..x4 noden för det neurala nätverket.

w1, w2, w3 är vikten av noden,

? är summeringen av alla vikt- och nodvärden som fungerar som aktiveringsfunktion.

Varför aktiveringsfunktion?

Om ingen aktiveringsfunktion används skulle utmatningen vara linjär men den linjära funktionens funktionalitet är begränsad. För att uppnå komplex funktionalitet som objektdetektering behövs bildklassificering, att skriva text med röst och många andra icke-linjära utgångar vilket uppnås med aktiveringsfunktion.

Hur aktiveringsskiktet beräknas i ordet inbäddning (Word2vec)

Softmax Layer (normaliserad exponentiell funktion) är utgångslagerfunktionen som aktiverar eller avfyrar varje nod. Ett annat tillvägagångssätt som används är Hierarchical softmax där komplexiteten beräknas med O(log₂V) där softmax det är O(V) där V är ordförrådets storlek. Skillnaden mellan dessa är minskningen av komplexiteten i hierarkiskt softmax-skikt. För att förstå dess (hierarkiska softmax) funktionalitet, titta på nedanstående Word-inbäddningsexempel:

Anta att vi vill beräkna sannolikheten att observera ordet älskar givet ett visst sammanhang. Flödet från roten till lövnoden blir det första steget till nod 2 och sedan till nod 5. Så om vi har haft ordförrådsstorleken 8 behövs bara tre beräkningar. Så det tillåter nedbrytning, beräkning av sannolikheten för ett ord (älskar).

Vilka andra alternativ finns tillgängliga förutom Hierarchical Softmax?

Om man talar i en allmän betydelse för ordinbäddning är alternativen Differentiated Softmax, CNN-Softmax, Importance Sampling, Adaptive Importance Sampling, Noise Contrastive Estimations, Negative Sampling, Self-Normalization och infrequent normalization.

När vi pratar specifikt om Word2vec har vi negativt urval tillgängligt.

Negativ sampling är ett sätt att ta prov på träningsdata. Det är lite som stokastisk gradientnedstigning, men med viss skillnad. Negativt urval letar bara efter negativa träningsexempel. Den är baserad på bruskontrastuppskattning och tar slumpmässigt urval av ord, inte i sammanhanget. Det är en snabb träningsmetod och väljer sammanhanget slumpmässigt. Om det förutsagda ordet förekommer i det slumpmässigt valda sammanhanget ligger båda vektorerna nära varandra.

Vilken slutsats kan man dra?

Aktivatorer avfyrar neuronerna precis som våra neuroner avfyras med hjälp av externa stimuli. Softmax-skiktet är en av utgångsskiktsfunktionerna som avfyrar neuronerna i händelse av ordinbäddningar. I Word2vec har vi alternativ som hierarkisk softmax och negativ sampling. Med hjälp av aktivatorer kan man konvertera den linjära funktionen till den olinjära funktionen, och en komplex maskininlärningsalgoritm kan implementeras med hjälp av en sådan.

Denna handledning handlar om Word2vec så vi kommer att hålla oss till det aktuella ämnet.

Hur man implementerar Word2vec med Gensim

Hittills har vi diskuterat vad Word2vec är, dess olika arkitekturer, varför det sker ett skifte från en påse med ord till Word2vec, relationen mellan Word2vec och NLTK med livekod och aktiveringsfunktioner.

Nedan är steg-för-steg-metoden för att implementera Word2vec med Gensim:

Steg 1) Datainsamling

Det första steget för att implementera någon maskininlärningsmodell eller implementera naturlig språkbehandling är datainsamling

Vänligen observera data för att bygga en intelligent chatbot som visas i Gensim Word2vec-exemplet nedan.

[{"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"]
        }
   ]

Här är vad vi förstår från uppgifterna

• Denna data innehåller tre saker, tagg, mönster och svar. Taggen är avsikten (vilket är diskussionsämnet).
• Uppgifterna är i JSON-format.
• Ett mönster är en fråga som användare kommer att ställa till boten
• Svar är svaret som chatbot kommer att ge på motsvarande fråga/mönster.

Steg 2) Dataförbehandling

Det är mycket viktigt att bearbeta rådata. Om rensad data matas till maskinen kommer modellen att svara mer exakt och lära sig data mer effektivt.

Detta steg innebär att man tar bort stoppord, stemming, onödiga ord etc. Innan man går vidare är det viktigt att ladda data och konvertera den till en dataram. Se koden nedan för sådant

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

Förklaring av kod:

1. Eftersom data är i form av json-format så importeras json
2. Filen lagras i variabeln
3. Filen är öppen och laddad i datavariabel

Nu importeras data och det är dags att konvertera data till dataram. Se koden nedan för att se nästa steg

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

Förklaring av kod:

1. Data konverteras till dataram med hjälp av pandor som importerades ovan.

2. Det kommer att konvertera listan i kolumnmönster till sträng.

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't']= 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 not x in stop))
df['patterns'] = df['patterns'].apply(lambda x: " ".join([Word(word).lemmatize() for word in x.split()]))

Kodförklaring:

1. Engelska stoppord importeras med stoppordsmodulen från nltk toolkit

2. Alla ord i texten konverteras till små bokstäver med hjälp av villkor och lambda-funktion. Lambdafunktion är en anonym funktion.

3. Alla textrader i dataramen kontrolleras för stränginterpunktion, och dessa filtreras.

4. Tecken som siffror eller punkt tas bort med ett reguljärt uttryck.

5. Digits tas bort från texten.

6. Stoppord tas bort i detta skede.

7. Ord filtreras nu, och olika former av samma ord tas bort med lemmatisering. Med dessa har vi avslutat dataförbehandlingen.

Produktion:

, 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 don’t worry']",payments

Steg 3) Byggande av neuralt nätverk med Word2vec

Nu är det dags att bygga en modell med Gensim Word2vec-modul. Vi måste importera Word2vec från Gensim. Låt oss göra detta, och sedan bygger vi och i slutskedet kommer vi att kontrollera modellen på realtidsdata.

from gensim.models import Word2Vec

Nu i denna Gensim Word2vec-handledning kan vi framgångsrikt bygga modellen med Word2Vec. Se nästa kodrad för att lära dig hur du skapar modellen med Word2Vec. Text tillhandahålls till modellen i form av en lista så vi kommer att konvertera texten från dataram till lista med koden nedan

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)

Förklaring av kod:

1. Skapade bigger_list där den inre listan läggs till. Detta är formatet som matas till modellen Word2Vec.

2. Loop implementeras och varje inmatning av mönsterkolumnen i dataramen itereras.

3. Varje element i kolumnmönstren delas och lagras i den inre listan li

4. Den inre listan läggs till den yttre listan.

5. Denna lista tillhandahålls för Word2Vec-modellen. Låt oss förstå några av parametrarna som tillhandahålls här

Min_antal: Den kommer att ignorera alla ord med en total frekvens som är lägre än detta.

Storlek: Det talar om dimensionaliteten hos ordet vektorer.

arbetare: Det här är trådarna för att träna modellen

Det finns också andra alternativ tillgängliga, och några viktiga förklaras nedan

fönster: Maximalt avstånd mellan det aktuella och det förutsagda ordet i en mening.

Sg: Det är en träningsalgoritm och 1 för skip-gram och 0 för en kontinuerlig påse med ord. Vi har diskuterat dessa i detalj ovan.

Hs: Om detta är 1 så använder vi hierarkisk softmax för träning och om 0 används negativ sampling.

Alfa: Inledande inlärningshastighet

Låt oss visa den slutliga koden nedan:

#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)
# print(df['patterns'])
#print(df['patterns'])
#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 not x 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)
#print(model)

Steg 4) Modellsparande

Modell kan sparas i form av bin och modellform. Bin är det binära formatet. Se nedanstående rader för att spara modellen

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

Förklaring av ovanstående kod

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

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

Vi kommer att använda den här modellen för att testa i realtid som liknande ord, olika ord och de vanligaste orden.

Steg 5) Laddar modellen och utför realtidstestning

Modellen laddas med följande kod:

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

Om du vill skriva ut vokabulären från det görs med följande kommando:

vocab = list(model.wv.vocab)

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

Steg 6) De flesta liknande ord kontrollerar

Låt oss implementera sakerna praktiskt:

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

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

Steg 7) Matchar inte ord från de ord som tillhandahålls

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

Vi har tillhandahållit orden "Vi ses senare, tack för besöket". Detta kommer skriv ut de mest olika orden från dessa ord. Låt oss köra den här koden och hitta resultatet

Resultatet efter exekvering av ovanstående kod:

Thanks

Steg 8) Hitta likheten mellan två ord

Detta kommer att berätta resultatet i sannolikheten för likhet mellan två ord. Se koden nedan hur du utför detta avsnitt.

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

Resultatet av ovanstående kod är enligt nedan

0.13706

Du kan ytterligare hitta liknande ord genom att köra koden nedan

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

Utmatning av ovanstående kod:

[('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)] 

Slutsats

• Ordinbäddning är en typ av ordrepresentation som gör att ord med liknande betydelse kan förstås av maskininlärningsalgoritmer
• Ordinbäddning används för att beräkna liknande ord, Skapa en grupp av relaterade ord, Funktion för textklassificering, Dokumentklustring, Naturligt språkbehandling
• Word2vec förklarade: Word2vec är en grund tvålagers neural nätverksmodell för att producera ordinbäddningar för bättre ordrepresentation
• Word2vec representerar ord i vektorrumsrepresentation. Ord representeras i form av vektorer och placering görs på ett sådant sätt att liknande betydelseord visas tillsammans och olika ord är placerade långt borta
• Word2vec-algoritmen använder 2 arkitekturer Continuous Bag of words (CBOW) och hoppa över gram
• CBOW är flera gånger snabbare än hoppa över gram och ger en bättre frekvens för vanliga ord medan hoppa över gram behöver en liten mängd träningsdata och representerar till och med sällsynta ord eller fraser.
• NLTK och Word2vec kan användas tillsammans för att skapa kraftfulla applikationer
• Neuronens aktiveringsfunktion definierar utsignalen från den neuronen givet en uppsättning ingångar. I Word2vec. Softmax Layer (normaliserad exponentiell funktion) är utgångslagerfunktionen som aktiverar eller avfyrar varje nod. Word2vec har också negativ sampling tillgänglig
• Gensim är en verktygssats för ämnesmodellering som är implementerad i python