Om de computer een geschreven tekst te laten begrijpen, kunnen we de woorden weergeven als numerieke vectoren. Eén manier om dit te doen is door gebruik te maken van Word-inbedding; dit is een manier om woorden weer te geven als numerieke vectoren. Deze vectoren leggen de betekenis van de woorden en hun relaties met andere woorden in de taal vast. Woordinsluitingen kunnen worden gegenereerd met behulp van onbewaakte leeralgoritmen zoals Woord2vec, Handschoen , of SnelTekst .
Word2vec is een op een neuraal netwerk gebaseerde methode voor het genereren van woordinsluitingen, dit zijn dichte vectorrepresentaties van woorden die hun semantische betekenis en relaties vastleggen. Er zijn twee hoofdbenaderingen voor het implementeren van Word2vec:
- Continue zak met woorden (CBOW)
- Skip-gram
Wat is een Continuous Bag of Words (CBOW)?
Continuous Bag of Words (CBOW) is een populaire natuurlijke taalverwerkingstechniek die wordt gebruikt om woordinsluitingen te genereren. Woordinbedding is belangrijk voor veel NLP-taken omdat ze semantische en syntactische relaties tussen woorden in een taal vastleggen. CBOW is een op een neuraal netwerk gebaseerd algoritme dat een doelwoord voorspelt op basis van de omringende contextwoorden. Het is een soort ongecontroleerd leren, wat betekent dat het kan leren van niet-gelabelde gegevens, en het wordt vaak gebruikt om woordinsluitingen vooraf te trainen die kunnen worden gebruikt voor verschillende NLP-taken, zoals sentimentanalyse en automatische vertaling.
Voorbeeld van een CBOW-model
Is er een verschil tussen het Bag-of-Words (BoW)-model en het Continuous Bag-of-Words (CBOW)?
- Het Bag-of-Words-model en het Continuous Bag-of-Words-model zijn beide technieken die worden gebruikt bij natuurlijke taalverwerking om tekst weer te geven in een computerleesbaar formaat, maar ze verschillen in de manier waarop ze de context vastleggen.
- Het BoW-model representeert tekst als een verzameling woorden en hun frequentie in een bepaald document of corpus. Er wordt geen rekening gehouden met de volgorde of context waarin de woorden verschijnen, en daarom kan het zijn dat de volledige betekenis van de tekst niet wordt weergegeven. Het BoW-model is eenvoudig en gemakkelijk te implementeren, maar kent beperkingen bij het vastleggen van de betekenis van taal.
- Het CBOW-model is daarentegen een op neurale netwerken gebaseerde benadering die de context van woorden vastlegt. Het leert het doelwoord voorspellen op basis van de woorden die ervoor en erna verschijnen in een bepaald contextvenster. Door rekening te houden met de omringende woorden kan het CBOW-model de betekenis van een woord in een bepaalde context beter vastleggen.
Architectuur van het CBOW-model
Het CBOW-model gebruikt het doelwoord rond het contextwoord om dit te voorspellen. Beschouw het bovenstaande voorbeeld Ze is een geweldige danseres. Het CBOW-model zet deze zin om in paren van contextwoorden en doelwoorden. De woordparen zouden er als volgt uitzien ([zij, een], is), ([is, geweldig], a) ([a, danseres], geweldig) met venstergrootte=2.
CBOW-architectuur
Het model houdt rekening met de contextwoorden en probeert de doelterm te voorspellen. De vier 1∗W invoervectoren worden doorgegeven aan de invoerlaag als er vier woorden zijn, aangezien contextwoorden worden gebruikt om één doelwoord te voorspellen. De verborgen laag ontvangt de invoervectoren en vermenigvuldigt deze vervolgens met een W∗N-matrix. De 1∗N-uitvoer van de verborgen laag komt uiteindelijk in de somlaag terecht, waar de vectoren elementsgewijs worden opgeteld voordat een laatste activering wordt uitgevoerd en de uitvoer wordt verkregen van de uitvoerlaag.
Code-implementatie van CBOW
Laten we een woordinbedding implementeren om de gelijkenis van woorden te tonen met behulp van het CBOW-model. In dit artikel heb ik mijn eigen woordencorpus gedefinieerd, je gebruikt elke dataset. Eerst zullen we alle benodigde bibliotheken importeren en de dataset laden. Vervolgens zullen we elk woord tokeniseren en omzetten in een vector van gehele getallen.
Python3
faculteit in c
import> tensorflow as tf> from> tensorflow.keras.models>import> Sequential> from> tensorflow.keras.layers>import> Dense,> >Embedding, Lambda> from> tensorflow.keras.preprocessing.text>import> Tokenizer> import> numpy as np> import> matplotlib.pyplot as plt> from> sklearn.decomposition>import> PCA> # Define the corpus> corpus>=> [>'The cat sat on the mat'>,> >'The dog ran in the park'>,> >'The bird sang in the tree'>]> # Convert the corpus to a sequence of integers> tokenizer>=> Tokenizer()> tokenizer.fit_on_texts(corpus)> sequences>=> tokenizer.texts_to_sequences(corpus)> print>('After converting our words>in> the corpus> into vector of integers:')> print>(sequences)> |
>
>
Uitgang:
After converting our words in the corpus into vector of integers: [[1, 3, 4, 5, 1, 6], [1, 7, 8, 2, 1, 9], [1, 10, 11, 2, 1, 12]]>
Nu gaan we het CBOW-model bouwen met venstergrootte = 2.
Python3
# Define the parameters> vocab_size>=> len>(tokenizer.word_index)>+> 1> embedding_size>=> 10> window_size>=> 2> # Generate the context-target pairs> contexts>=> []> targets>=> []> for> sequence>in> sequences:> >for> i>in> range>(window_size,>len>(sequence)>-> window_size):> >context>=> sequence[i>-> window_size:i]>+>> >sequence[i>+> 1>:i>+> window_size>+> 1>]> >target>=> sequence[i]> >contexts.append(context)> >targets.append(target)> # Convert the contexts and targets to numpy arrays> X>=> np.array(contexts)> # Define the CBOW model> model>=> Sequential()> model.add(Embedding(input_dim>=>vocab_size,> >output_dim>=>embedding_size,> >input_length>=>2>*>window_size))> model.add(Lambda(>lambda> x: tf.reduce_mean(x, axis>=>1>)))> model.add(Dense(units>=>vocab_size, activation>=>'softmax'>))> model.save_weights(>'cbow_weights.h5'>)> # Load the pre-trained weights> model.load_weights(>'cbow_weights.h5'>)> |
>
if else-verklaring java
>
Vervolgens zullen we het model gebruiken om de inbedding te visualiseren.
Python3
# Get the word embeddings> embeddings>=> model.get_weights()[>0>]> # Perform PCA to reduce the dimensionality> # of the embeddings> pca>=> PCA(n_components>=>2>)> reduced_embeddings>=> pca.fit_transform(embeddings)> # Visualize the embeddings> plt.figure(figsize>=>(>5>,>5>))> for> i, word>in> enumerate>(tokenizer.word_index.keys()):> >x, y>=> reduced_embeddings[i]> >plt.scatter(x, y)> >plt.annotate(word, xy>=>(x, y), xytext>=>(>5>,>2>),> >textcoords>=>'offset points'>,> >ha>=>'right'>, va>=>'bottom'>)> plt.show()> |
>
hernoem map op linux
>
Uitgang:
Gevectoriseerde weergave van de woorden met behulp van het CBOW-model
Met deze visualisatie kunnen we de gelijkenis van de woorden observeren op basis van hun inbedding. Van woorden die qua betekenis of context vergelijkbaar zijn, wordt verwacht dat ze in de plot dicht bij elkaar liggen.