Afin de faire comprendre à l’ordinateur un texte écrit, nous pouvons représenter les mots sous forme de vecteurs numériques. Une façon d'y parvenir consiste à utiliser des intégrations de mots, elles constituent un moyen de représenter les mots sous forme de vecteurs numériques. Ces vecteurs capturent le sens des mots et leurs relations avec d’autres mots de la langue. Les intégrations de mots peuvent être générées à l'aide d'algorithmes d'apprentissage non supervisés tels que Word2vec, Gant , ou Texte rapide .
Word2vec est une méthode basée sur un réseau neuronal pour générer des intégrations de mots, qui sont des représentations vectorielles denses de mots qui capturent leur signification sémantique et leurs relations. Il existe deux approches principales pour implémenter Word2vec :
- Sac de mots continu (CBOW)
- Sauter le gramme
Qu'est-ce qu'un sac continu de mots (CBOW) ?
Le sac continu de mots (CBOW) est une technique populaire de traitement du langage naturel utilisée pour générer des incorporations de mots. Les incorporations de mots sont importantes pour de nombreuses tâches de PNL car elles capturent les relations sémantiques et syntaxiques entre les mots d'une langue. CBOW est un algorithme basé sur un réseau neuronal qui prédit un mot cible en fonction des mots du contexte environnant. C'est un type de sans surveillance l'apprentissage, ce qui signifie qu'il peut apprendre à partir de données non étiquetées, et il est souvent utilisé pour pré-entraîner des incorporations de mots qui peuvent être utilisées pour diverses tâches de PNL telles que l'analyse des sentiments, la traduction automatique.
Exemple de modèle CBOW
Y a-t-il une différence entre le modèle Bag-of-Words (BoW) et le modèle Continu Bag-of-Words (CBOW) ?
- Le modèle Bag-of-Words et le modèle Continu Bag-of-Words sont tous deux des techniques utilisées dans le traitement du langage naturel pour représenter du texte dans un format lisible par ordinateur, mais ils diffèrent par la manière dont ils capturent le contexte.
- Le modèle BoW représente le texte comme un ensemble de mots et leur fréquence dans un document ou un corpus donné. Il ne prend pas en compte l’ordre ou le contexte dans lequel les mots apparaissent et, par conséquent, il se peut qu’il ne capte pas le sens complet du texte. Le modèle BoW est simple et facile à mettre en œuvre, mais il présente des limites dans la capture du sens du langage.
- En revanche, le modèle CBOW est une approche basée sur un réseau neuronal qui capture le contexte des mots. Il apprend à prédire le mot cible en fonction des mots qui apparaissent avant et après dans une fenêtre contextuelle donnée. En considérant les mots environnants, le modèle CBOW peut mieux saisir le sens d'un mot dans un contexte donné.
Architecture du modèle CBOW
Le modèle CBOW utilise le mot cible autour du mot contextuel afin de le prédire. Considérez l'exemple ci-dessus C'est une grande danseuse. Le modèle CBOW convertit cette phrase en paires de mots contextuels et de mots cibles. Les paires de mots apparaîtraient comme ceci ([elle, une], est), ([est, génial], a) ([une, danseuse], génial) ayant une taille de fenêtre = 2.
Architecture CBOW
Le modèle prend en compte les mots contextuels et tente de prédire le terme cible. Les quatre vecteurs d'entrée 1∗W seront transmis à la couche d'entrée si quatre mots comme mots de contexte sont utilisés pour prédire un mot cible. La couche cachée recevra les vecteurs d'entrée puis les multipliera par une matrice W∗N. La sortie 1∗N de la couche cachée entre finalement dans la couche de somme, où les vecteurs sont additionnés élément par élément avant qu'une activation finale ne soit effectuée et la sortie est obtenue de la couche de sortie.
logo Java
Mise en œuvre du code CBOW
Implémentons une intégration de mots pour montrer la similitude des mots en utilisant le modèle CBOW. Dans cet article, j'ai défini mon propre corpus de mots, vous utilisez n'importe quel ensemble de données. Tout d’abord, nous importerons toutes les bibliothèques nécessaires et chargerons l’ensemble de données. Ensuite, nous allons tokeniser chaque mot et le convertir en un vecteur d'entiers.
Python3
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)> |
>
Edith Mack Hirsch
>
Sortir:
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]]>
Maintenant, nous allons construire le modèle CBOW avec une taille de fenêtre = 2.
Python3
année où l'ordinateur a été inventé
# 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'>)> |
>
>
Ensuite, nous utiliserons le modèle pour visualiser les intégrations.
Python3
convertir une chaîne en entier en Java
# 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()> |
>
jdbc jdbc
>
Sortir:
Représentation vectorisée des mots à l'aide du modèle CBOW
Cette visualisation nous permet d'observer la similitude des mots en fonction de leurs intégrations. Les mots dont le sens ou le contexte est similaire devraient être proches les uns des autres dans l’intrigue.