Woordembedding en Word2Vec met een voorbeeld

Wat is woordinsluiting?

Woord insluiten is een type woordrepresentatie waarmee machine learning-algoritmen woorden met vergelijkbare betekenissen kunnen begrijpen. Het is een taalmodellerings- en feature learning-techniek om woorden in vectoren van reële getallen te projecteren met behulp van neurale netwerken, probabilistische modellen of dimensiereductie op de woordco-occurrence-matrix. Enkele voorbeelden van woordembeddingmodellen zijn Word2vec (Google), GloVe (Stanford) en fastText (Facebook).

Woordembedding wordt ook wel een gedistribueerd semantisch model, een gedistribueerd gerepresenteerd model, een semantische vectorruimte of een vectorruimtemodel genoemd. Bij het lezen van deze namen kom je het woord tegen. semantischDit betekent dat gelijksoortige woorden bij elkaar worden gecategoriseerd. Zo zouden fruitsoorten zoals appel, mango en banaan dicht bij elkaar moeten worden geplaatst, terwijl boeken ver van deze woorden af ​​zouden moeten staan. In bredere zin creëert woordembedding een vector van fruitsoorten die ver verwijderd is van de vectorrepresentatie van boeken.

Waar wordt Word-insluiting gebruikt?

Woordembedding helpt bij het genereren van kenmerken, het clusteren van documenten, tekstclassificatie en taken op het gebied van natuurlijke taalverwerking. Laten we deze toepassingen opsommen en ze stuk voor stuk bespreken.

• Bereken soortgelijke woorden: Woordembedding wordt gebruikt om vergelijkbare woorden voor te stellen bij het woord dat aan het voorspellingsmodel wordt onderworpen. Daarnaast worden ook ongelijksoortige woorden en de meest voorkomende woorden voorgesteld.
• Maak een groep verwante woorden: Het wordt gebruikt voor semantische groepering.ping, waarbij dingen met vergelijkbare kenmerken bij elkaar worden geplaatst en dingen met verschillende kenmerken ver van elkaar worden verwijderd.
• Functie voor tekstclassificatie: Tekst wordt omgezet in arrays van vectoren die aan het model worden aangeboden voor zowel training als voorspelling. Tekstgebaseerde classificatiemodellen kunnen niet worden getraind op strings, dus dit zet de tekst om in een vorm die door een machine kan worden getraind. De semantische opbouw ervan helpt verder bij tekstgebaseerde classificatie.
• Documentclustering: Dit is een andere toepassing waar Word Embedding en Word2vec veelvuldig worden gebruikt.
• Natuurlijke taalverwerking: Er zijn veel toepassingen waar woordembedding nuttig is en de voorkeur verdient boven feature ex.tracfases zoals het toekennen van woordsoorten, sentimentanalyse en syntactische analyse.

Nu je begrijpt waar woordembedding wordt toegepast, laten we eens kijken naar het meest gebruikte model om deze embeddings te creëren.

Wat is Word2vec?

Woord2vec Het is een techniek of model dat woordembeddings produceert voor een betere woordrepresentatie. Het is een methode voor natuurlijke taalverwerking die een groot aantal precieze syntactische en semantische woordrelaties vastlegt. Het is een ondiep, tweelaags neuraal netwerk dat synoniemen kan detecteren en, na training, aanvullende woorden kan suggereren voor gedeeltelijke zinnen.

Voordat we verdergaan, bekijk eerst het verschil tussen een ondiep en een diep neuraal netwerk, zoals weergegeven in het onderstaande voorbeeld van woordembedding:

Een ondiep neuraal netwerk bestaat uit slechts één verborgen laag tussen invoer en uitvoer, terwijl een diep neuraal netwerk meerdere verborgen lagen tussen invoer en uitvoer bevat. De invoer wordt verwerkt door knooppunten, terwijl de verborgen laag, evenals de uitvoerlaag, neuronen bevat.

Word2vec is een tweelaags neuraal netwerk met een invoerlaag, een verborgen laag en een uitvoerlaag.

Word2vec is ontwikkeld door een groep onderzoekers onder leiding van Tomas Mikolov bij GoogleWord2vec is beter en efficiënter dan het latent semantische analysemodel.

Waarom Word2vec?

Word2vec representeert woorden in een vectorruimte. Woorden worden weergegeven in de vorm van vectoren, waarbij woorden met een vergelijkbare betekenis bij elkaar staan ​​en woorden met een verschillende betekenis verder van elkaar verwijderd zijn. Dit wordt ook wel een semantische relatie genoemd. Neurale netwerken begrijpen geen tekst, maar alleen getallen. Word Embedding biedt een manier om tekst om te zetten naar een numerieke vector.

Word2vec reconstrueert de taalkundige context van woorden. Laten we, voordat we verder gaan, eerst begrijpen wat taalkundige context is. In een algemeen scenario proberen mensen, wanneer we spreken of schrijven om te communiceren, de bedoeling van de zin te achterhalen. Bijvoorbeeld: "Wat is de temperatuur in India?" De context is hier dat de gebruiker de "temperatuur in India" wil weten. Kortom, de belangrijkste functie van een zin is de context. De woorden of zinnen die de gesproken of geschreven taal omringen, helpen bij het bepalen van de betekenis van de context. Word2vec leert de vectorrepresentatie van woorden aan de hand van deze contexten.

Wat Word2vec doet?

Vóór het insluiten van woorden

Het is belangrijk om te weten welke aanpak vóór woordembedding werd gebruikt en wat de nadelen ervan zijn. Vervolgens zullen we bekijken hoe deze nadelen worden ondervangen door woordembedding met behulp van de Word2vec-aanpak. Tot slot zullen we ingaan op de werking van Word2vec, omdat het belangrijk is om de werking ervan te begrijpen.

Aanpak voor latente semantische analyse

Dit is de aanpak die werd gebruikt vóór de introductie van woordembedding. Het maakte gebruik van het concept van een 'Bag of Words', waarbij woorden worden weergegeven in de vorm van gecodeerde vectoren. Het is een schaarse vectorrepresentatie waarbij de dimensie gelijk is aan de grootte van de woordenschat. Als het woord in het woordenboek voorkomt, wordt het meegeteld; anders niet. Zie het onderstaande programma voor meer informatie.

Word2vec-voorbeeld

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

Output:

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

1. CountVectorizer is de module die gebruikt wordt om de woordenschat op te slaan door de woorden erin te passen. Deze module wordt geïmporteerd uit scikit-learn.
2. Maak het object met behulp van de klasse CountVectorizer.
3. Schrijf de gegevens die in de CountVectorizer moeten worden verwerkt in de lijst.
4. Gegevens passen in het object dat is gemaakt op basis van de klasse CountVectorizer.
5. Gebruik de bag-of-words-methode om woorden in de data te tellen aan de hand van de woordenschat. Als een woord of token niet in de woordenschat voorkomt, wordt de bijbehorende indexpositie op nul gezet.
6. De variabele x in regel 5 wordt omgezet naar een array (een methode die beschikbaar is voor x). Dit geeft het aantal keren dat elk token voorkomt in de zin of lijst die in regel 3 wordt gegeven.
7. Dit toont de kenmerken die deel uitmaken van de woordenschat wanneer deze wordt aangepast met behulp van de gegevens in regel 4.

Bij de Latent Semantic-benadering vertegenwoordigt elke rij unieke woorden, terwijl elke kolom het aantal keren aangeeft dat een woord in het document voorkomt. Het is een weergave van woorden in de vorm van een documentmatrix. Term Frequency-Inverse Document Frequency (TF-IDF) wordt gebruikt om de frequentie van woorden in het document te berekenen. Dit is de frequentie van de term in het document gedeeld door de frequentie van de term in het gehele corpus.

Tekortkoming van de Bag of Words-methode

• Het negeert de woordvolgorde; bijvoorbeeld, dit is slecht = is dit erg?.
• Het negeert de context van woorden. Stel dat we de zin schrijven: "Hij hield van boeken. Het beste onderwijs vind je in boeken." Dan zouden er twee vectoren ontstaan: één voor "Hij hield van boeken" en één voor "Het beste onderwijs vind je in boeken." Beide vectoren zouden als orthogonaal worden beschouwd, waardoor ze onafhankelijk van elkaar lijken, maar in werkelijkheid zijn ze met elkaar verbonden.

Om deze beperkingen te overkomen, werd woordembedding ontwikkeld, en Word2vec is een van de methoden die gebruikt worden om dit te implementeren.

Hoe werkt Word2vec?

Word2vec leert een woord door de context eromheen te voorspellen. Laten we bijvoorbeeld het woord "Hij" nemen. houdt Voetbal."

We willen de Word2vec berekenen voor het woord: houdt.

Veronderstellen:

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

Het woord houdt Het programma doorloopt elk woord in het corpus. Zowel syntactische als semantische relaties tussen woorden worden gecodeerd. Dit helpt bij het vinden van vergelijkbare en analoge woorden.

Allemaal willekeurige kenmerken van het woord houdt worden berekend. Deze kenmerken worden gewijzigd of bijgewerkt met betrekking tot naburige of contextwoorden met behulp van een Terug Voortplanting methode.

Een andere manier om te leren is dat als de context van twee woorden vergelijkbaar is, of als twee woorden vergelijkbare kenmerken hebben, die woorden verwant zijn.

Woord2vec Architectuur

Word2vec gebruikt twee architecturen:

1. Continue Woordenzak (CBOW)
2. Gram overslaan

Voordat we verdergaan, laten we eerst bespreken waarom deze architecturen of modellen belangrijk zijn vanuit het oogpunt van woordrepresentatie. Het leren van woordrepresentatie is in principe ongesuperviseerd, maar er zijn doelen/labels nodig om het model te trainen. Skip-gram en CBOW zetten de ongesuperviseerde representatie om in een gesuperviseerde vorm voor modeltraining.

In CBOW wordt het huidige woord voorspeld met behulp van het venster van de omliggende contextvensters. Bijvoorbeeld, als w_i-1, _i-2, _{ik + 1}, _{ik + 2} woorden of context krijgen, zal dit model w_i.

Skip-Gram doet het tegenovergestelde van CBOW, wat inhoudt dat het de gegeven volgorde of context voorspelt op basis van het woord. Je kunt het voorbeeld omdraaien om het te begrijpen. Als w_i als dit gegeven is, zal dit de context voorspellen, of w_i-1, _i-2, _{ik + 1}, _{ik + 2}.

Word2vec biedt de mogelijkheid om te kiezen tussen CBOW (Continuous Bag of Words) en skip-gram. Deze parameters worden tijdens de training van het model doorgegeven. Men kan er ook voor kiezen om negatieve sampling of een hiërarchische softmax-laag te gebruiken.

Doorlopende zak met woorden

Laten we een eenvoudig Word2vec-voorbeelddiagram tekenen om de continue bag-of-words-architectuur te begrijpen.

Laten we de vergelijkingen wiskundig berekenen. Stel dat V de grootte van de woordenschat is en N de grootte van de verborgen laag. Invoer wordt gedefinieerd als { x_i-1, x_i-2, x_{ik + 1}, x_{ik + 2} We verkrijgen de gewichtsmatrix door V * N te vermenigvuldigen. Een andere matrix wordt verkregen door de invoervector met de gewichtsmatrix te vermenigvuldigen. Dit kan ook worden begrepen aan de hand van de volgende vergelijking.

h = xi^tW

waar xi^t en W zijn respectievelijk de invoervector en de gewichtsmatrix.

Om de overeenkomst tussen de context en het volgende woord te berekenen, kunt u de onderstaande formule gebruiken.

u = voorspelde representatie * h

waarbij de voorspelde representatie wordt verkregen uit het model in de bovenstaande vergelijking.

Skip-Gram-model

De Skip-Gram-methode wordt gebruikt om een ​​zin te voorspellen op basis van een gegeven woord. Om dit beter te begrijpen, kunnen we het diagram in het onderstaande Word2vec-voorbeeld bekijken.

Je kunt het zien als het omgekeerde van het Continuous Bag of Words-model, waarbij de input het woord is en het model de context of de sequentie levert. We kunnen ook concluderen dat het doelwoord als input wordt gebruikt en dat de uitvoerlaag meerdere keren wordt herhaald om het gekozen aantal contextwoorden te kunnen verwerken. De foutvector van alle uitvoerlagen wordt opgeteld om de gewichten aan te passen via een backpropagatie-methode.

Welk model te kiezen?

CBOW is vele malen sneller dan skip-gram en levert een betere frequentie voor veelvoorkomende woorden, terwijl skip-gram slechts een kleine hoeveelheid trainingsdata nodig heeft en zelfs zeldzame woorden of woordgroepen kan weergeven. De onderstaande tabel vergelijkt beide architecturen in één oogopslag.

De relatie tussen Word2vec en NLTK

NLTK is de natuurlijke Language ToolDe kit wordt gebruikt voor de voorbewerking van tekst. Men kan verschillende bewerkingen uitvoeren, zoals het taggen van woordsoorten, lemmatiseren, stammen, het verwijderen van stopwoorden en het verwijderen van zeldzame of minst gebruikte woorden. Het helpt bij het opschonen van de tekst en het voorbereiden van kenmerken op basis van de effectieve woorden. Word2vec daarentegen wordt gebruikt voor semantische (naaste items bij elkaar plaatsen) en syntactische (sequentie) matching. Met Word2vec kan men gelijksoortige woorden vinden, ongelijksoortige woorden, dimensionale reductie en nog veel meer. Een andere belangrijke functie van Word2vec is het omzetten van de hogerdimensionale representatie van tekst naar lagerdimensionale vectoren.

Waar NLTK en Word2vec gebruiken?

Voor algemene taken zoals tokenisatie, POS-tagging en parsing, zoals hierboven vermeld, is NLTK de aangewezen tool. Voor het voorspellen van woorden op basis van context, topicmodellering of documentgelijkenis, is Word2vec echter de beste keuze.

Relatie van NLTK en Word2vec met behulp van code

NLTK en Word2vec kunnen samen worden gebruikt om vergelijkbare woordrepresentaties of syntactische overeenkomsten te vinden. De NLTK-toolkit kan worden gebruikt om veel van de meegeleverde pakketten te laden, en met Word2vec kan een model worden gemaakt. Dit model kan vervolgens worden getest op woorden uit de praktijk. Laten we de combinatie van beide in de volgende code bekijken. Voordat we verdergaan, raden we aan om de corpora te bekijken die NLTK aanbiedt. U kunt deze downloaden met het volgende commando:

nltk(nltk.download('all'))

Zie de schermafbeelding voor de code.

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)

Output:

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

Uitleg van Code

1. De nltk-bibliotheek wordt geïmporteerd, vanwaar je het abc-corpus kunt downloaden dat we in de volgende stap zullen gebruiken.
2. Gensim is geïmporteerd. Als Gensim Word2vec niet is geïnstalleerd, installeer het dan met het commando "pip3 install gensim". Zie de onderstaande schermafbeelding.

3. Importeer het abc-corpus, dat is gedownload met nltk.download('abc').
4. Geef de bestanden, die via Gensim zijn geïmporteerd, door als zinnen aan het Word2vec-model.
5. De woordenschat wordt opgeslagen in de vorm van een variabele.
6. Het model wordt getest op het voorbeeldwoord. wetenschap, aangezien deze bestanden betrekking hebben op wetenschap.
7. Hier voorspelt het model een soortgelijk woord als "wetenschap".

Activators en Word2Vec

De activeringsfunctie van een neuron definieert de output van dat neuron gegeven een reeks inputs. Het is biologisch geïnspireerd op de activiteit in onze hersenen, waar verschillende neuronen worden geactiveerd door verschillende stimuli. Laten we de activeringsfunctie begrijpen aan de hand van het volgende diagram.

Hier zijn x1, x2, … x4 de knooppunten van het neurale netwerk.

w1, w2, w3 zijn de gewichten van de knooppunten.

De som (Σ) van alle gewichten en knooppuntwaarden fungeert als de activeringsfunctie.

Waarom activeringsfunctie?

Als er geen activeringsfunctie wordt gebruikt, is de uitvoer lineair, maar de functionaliteit van een lineaire functie is beperkt. Om complexe functionaliteit te bereiken, zoals objectdetectie, beeldclassificatie, enzovoort, is een activeringsfunctie nodig.ping Voor tekstverwerking via spraak en vele andere niet-lineaire outputs is een activeringsfunctie nodig.

Hoe de activeringslaag wordt berekend in de woordinbedding (Word2vec)

De softmax-laag (genormaliseerde exponentiële functie) is de uitvoerlaagfunctie die elk knooppunt activeert of aanstuurt. Een andere gebruikte aanpak is hiërarchische softmax, waarbij de complexiteit wordt berekend als O(log).₂Bij softmax is de complexiteit O(V), terwijl deze bij softmax O(V) is, waarbij V de grootte van de woordenschat is. Het verschil zit hem in de reductie van de complexiteit in de hiërarchische softmax-laag. Om de werking ervan te begrijpen, kunt u het onderstaande voorbeeld van woordembedding bekijken:

Stel dat we de waarschijnlijkheid willen berekenen dat we het woord waarnemen liefde gegeven een bepaalde context. De stroom van de wortel naar het bladknooppunt gaat eerst naar knooppunt 2 en vervolgens naar knooppunt 5. Dus als we een woordenschatgrootte van 8 hebben, zijn er slechts drie berekeningen nodig. Dit maakt het mogelijk om de berekening van de waarschijnlijkheid van één woord op te splitsen (liefde).

Welke andere opties zijn er naast Hiërarchische Softmax?

In algemene zin zijn de beschikbare woordembedding-opties: Differentiated Softmax, CNN-Softmax, Importance Sampling, Adaptive Importance Sampling, Noise Contrastive Estimation, Negative Sampling, Self-Normalization en Infrequent Normalization.

Wat Word2vec betreft, hebben we de mogelijkheid tot negatieve sampling.

Negatieve sampling is een manier om trainingsdata te bemonsteren. Het lijkt enigszins op stochastische gradiëntdaling, maar met een aantal verschillen. Negatieve sampling zoekt alleen naar negatieve trainingsvoorbeelden. Het is gebaseerd op ruiscontrastieve schatting en selecteert willekeurig woorden die niet in de context voorkomen. Het is een snelle trainingsmethode die de context willekeurig kiest. Als het voorspelde woord in de willekeurig gekozen context voorkomt, liggen beide vectoren dicht bij elkaar.

Welke conclusie kan worden getrokken?

Activators activeren de neuronen net zoals onze neuronen worden geactiveerd door externe stimuli. De softmax-laag is een van de uitvoerlaagfuncties die de neuronen activeert in het geval van woordembeddings. In Word2vec hebben we opties zoals hiërarchische softmax en negatieve sampling. Met behulp van activators kan een lineaire functie worden omgezet in een niet-lineaire functie, en een complex machine learning-algoritme kan met behulp van dergelijke functies worden geïmplementeerd.

Wat is Gensim?

gensim is een open-source toolkit voor onderwerpmodellering en natuurlijke taalverwerking die is geïmplementeerd in Python en Cython. De Gensim-toolkit stelt gebruikers in staat om Word2vec te importeren voor topicmodellering om verborgen structuren in de tekst te ontdekken. Gensim biedt niet alleen een implementatie van Word2vec, maar ook van Doc2vec en FastText.

Dit gedeelte richt zich op Word2vec, dus we blijven bij het huidige onderwerp.

Hoe Word2vec te implementeren met Gensim

Tot nu toe hebben we besproken wat Word2vec is, de verschillende architecturen ervan, waarom er een verschuiving plaatsvindt van een bag-of-words-model naar Word2vec, de relatie tussen Word2vec en NLTK met live code, en activatiefuncties.

Hieronder volgt de stapsgewijze methode om Word2vec te implementeren met behulp van Gensim:

Stap 1) Gegevensverzameling

De eerste stap bij het implementeren van een machine learning-model of het toepassen van natuurlijke taalverwerking is het verzamelen van gegevens.

Bekijk de gegevens om een ​​intelligente chatbot te bouwen, zoals weergegeven in het onderstaande Gensim Word2vec-voorbeeld.

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

Dit is wat we uit de gegevens kunnen opmaken:

• Deze data bevat drie elementen: tag, patroon en reacties. De tag is de intentie (wat is het onderwerp van de discussie).
• De gegevens zijn in JSON-formaat.
• Een patroon is een vraag die gebruikers aan de bot zullen stellen.
• De antwoorden zijn de informatie die de chatbot geeft op de betreffende vraag/het bijbehorende patroon.

Stap 2) Voorverwerking van gegevens

Het is van groot belang om de ruwe data te verwerken. Als opgeschoonde gegevens naar de machine worden gevoerd, reageert het model nauwkeuriger en leert het de gegevens efficiënter.

Deze stap omvat het verwijderen van stopwoorden, het afleiden van stammen, overbodige woorden, enz. Voordat we verdergaan, is het belangrijk om de gegevens te laden en om te zetten naar een dataframe. Zie de onderstaande code hiervoor.

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

Uitleg van Code:

1. Aangezien de gegevens in JSON-formaat zijn, worden ze geïmporteerd.
2. Het bestand is opgeslagen in de variabele.
3. Het bestand wordt geopend en in de data-variabele geladen.

De gegevens zijn nu geïmporteerd en het is tijd om ze om te zetten naar een dataframe. Zie onderstaande code voor de volgende stap.

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

Uitleg van Code:

1. De gegevens worden met behulp van pandas, dat hierboven is geïmporteerd, omgezet in een dataframe.

2. Het converteert de lijst in de kolom 'patterns' naar een tekenreeks.

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

1. Engelse stopwoorden worden geïmporteerd met behulp van de stopwoordmodule uit de NLTK-toolkit.

2. Alle woorden in de tekst worden omgezet naar kleine letters met behulp van een for-lus en een lambdafunctie. A Lambda-functie is een anonieme functie.

3. Alle tekstregels in het dataframe worden gecontroleerd op leestekens en deze worden vervolgens gefilterd.

4. Tekens zoals cijfers of punten worden verwijderd met behulp van een reguliere expressie.

5. Digits worden uit de tekst verwijderd.

6. Stopwoorden worden in dit stadium verwijderd.

7. De woorden worden nu gefilterd en verschillende vormen van hetzelfde woord worden verwijderd met behulp van lemmatisatie. Hiermee is de voorbewerking van de gegevens voltooid.

Output:

, 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

Stap 3) Neuraal netwerk opbouwen met Word2vec

Nu is het tijd om een ​​model te bouwen met behulp van de Gensim Word2vec-module. We moeten Word2vec importeren vanuit Gensim. Laten we dat doen, vervolgens bouwen we het model en in de laatste fase controleren we het model met realtime data.

from gensim.models import Word2Vec

Nu kunnen we het model succesvol bouwen met Word2Vec. Raadpleeg de volgende regel code om te leren hoe u het model met Word2Vec kunt maken. De tekst wordt aan het model aangeleverd in de vorm van een lijst, dus we converteren de tekst uit het dataframe naar een lijst met behulp van de onderstaande code.

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)

Uitleg van Code:

1. De grotere lijst is aangemaakt waaraan de binnenste lijst is toegevoegd. Dit is het formaat dat aan het Word2Vec-model wordt doorgegeven.

2. Er wordt een lus geïmplementeerd, waarbij elk element van de kolom 'patterns' in het dataframe wordt doorlopen.

3. Elk element van de kolompatronen wordt gesplitst en opgeslagen in de interne lijst li.

4. De binnenste lijst wordt aangevuld met de buitenste lijst.

5. Deze lijst wordt aan het Word2Vec-model doorgegeven. Laten we enkele van de hier verstrekte parameters eens nader bekijken.

Min_count: Het negeert alle woorden met een totale frequentie die lager is dan dit.

Afmetingen: Het vertelt de dimensionaliteit van de woordvectoren.

Werknemers: Dit zijn de threads om het model te trainen.

Er zijn ook andere opties beschikbaar, waarvan enkele belangrijke hieronder worden toegelicht.

venster: Maximale afstand tussen het huidige en voorspelde woord binnen een zin.

Sg: Het is een trainingsalgoritme: 1 voor skip-gram en 0 voor een Continuous Bag of Words. We hebben deze hierboven al uitgebreid besproken.

Hs: Als dit 1 is, gebruiken we hiërarchische softmax voor de training, en als het 0 is, wordt negatieve sampling gebruikt.

Alpha: Initiële leercurve.

Laten we de uiteindelijke code hieronder weergeven:

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

Stap 4) Model opslaan

Het model kan worden opgeslagen als een binair bestand (bin-bestand). Zie onderstaande regels voor het opslaan van het model.

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

Uitleg van de bovenstaande code

1. Het model wordt opgeslagen als een .model-bestand.

2. Het model wordt opgeslagen als een .bin-bestand.

We zullen dit model gebruiken voor realtime tests, zoals het vergelijken van gelijksoortige woorden, ongelijksoortige woorden en de meest voorkomende woorden.

Stap 5) Model laden en realtime testen uitvoeren

Het model wordt geladen met behulp van de onderstaande code:

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

Als je de woordenschat wilt afdrukken, doe je dat met het volgende commando:

vocab = list(model.wv.vocab)

Zie het resultaat:

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

Stap 6) Controle van de meeste vergelijkbare woorden

Laten we de dingen praktisch implementeren:

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

Zie het resultaat:

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

Stap 7) Komt niet overeen met het woord en de opgegeven woorden

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

Wij hebben de woorden geleverd 'Tot later, bedankt voor je bezoek'Dit print het woord dat het meest afwijkt van deze woorden. Laten we deze code uitvoeren en het resultaat bekijken.

Het resultaat na uitvoering van bovenstaande code:

Thanks

Stap 8) De gelijkenis tussen twee woorden vinden

Dit geeft het resultaat weer in termen van de waarschijnlijkheid van gelijkenis tussen twee woorden. Zie onderstaande code voor een voorbeeld van hoe dit gedeelte uitgevoerd kan worden.

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

Het resultaat van bovenstaande code is als volgt:

0.13706

Je kunt vergelijkbare woorden vinden door de onderstaande code uit te voeren:

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

Uitvoer van de bovenstaande code:

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

Veelgestelde vragen