La sémantique est importante car dans la PNL, ce sont les relations entre les mots qui sont étudiés. L'une des procédures les plus simples mais très efficaces est le sac continu de mots (CBOW) qui mappe les mots à des vecteurs très significatifs appelés vecteurs de mots. CBOW est utilisé dans le cadre Word2Vec et prédit un mot basé sur les mots qui y sont adjacents qui capturent le sens sémantique et syntaxique du langage. Dans cet article, le lecteur se rendra compte du fonctionnement du modèle CBOW, ainsi que des méthodes de son utilisation.

Objectifs d'apprentissage

• Comprendre la théorie derrière le modèle CBOW.
• Apprenez les différences entre CBOW et Skip-Gram.
• Implémentez le modèle CBOW dans Python avec un exemple de jeu de données.
• Analyser les avantages et les limitations de CBOW.
• Explorez les cas d'utilisation pour les incorporations de mots générées par CBOW.

Table des matières

• Qu'est-ce que le sac de mots continu?
• Comment fonctionne le sac de mots continu
• CBOW Architecture expliqué en détail
• Codage cbow à partir de zéro (avec des exemples python)
• Avantages du sac continu de mots
• Limites du sac continu de mots
• Questions fréquemment posées

Qu'est-ce que le sac de mots continu?

Le sac continu de mots (CBOW) est également un modèle qui est utilisé lors de la détermination de l'intégration des mots à l'aide d'un réseau de neurones et fait partie des modèles Word2Vec de Tomas Mikolov. CBOW essaie de prédire un mot cible en fonction des mots de contexte l'observant dans une phrase donnée. De cette fa?on, il est capable de capturer les relations sémantiques, donc les mots proches sont représentés étroitement dans un espace de grande dimension.

Par exemple, dans la phrase ?Le chat s'est assis sur le tapis? , si la taille de la fenêtre de contexte est 2, les mots de contexte pour ?SAT? sont [le ??, ?chat?, ?on?, ?le?] , et la tache du modèle est de prédire le mot ?SAT? .

CBOW opère en agrégeant les mots de contexte (par exemple, en moyenne leurs intérêts) et en utilisant cette représentation agrégée pour prédire le mot cible. L'architecture du modèle implique une couche d'entrée pour les mots de contexte, une couche cachée pour la génération d'intégration et une couche de sortie pour prédire le mot cible à l'aide d'une distribution de probabilité.

Il s'agit d'un modèle rapide et efficace adapté à la gestion des mots fréquents, ce qui le rend idéal pour les taches nécessitant une compréhension sémantique, telles que la classification du texte, les systèmes de recommandation et l'analyse des sentiments.

Comment fonctionne le sac de mots continu

Le CBOW est l'une des techniques les plus simples et les plus efficaces selon le contexte de l'intégration des mots où l'ensemble du vocabulaire des mots est cartographié aux vecteurs. Cette section décrit également le fonctionnement du système CBOW comme un moyen de comprendre la méthode à son niveau le plus élémentaire, discutant des principales idées qui sous-tendent la méthode CBOW, ainsi que d'offrir un guide complet de la disposition architecturale du système de calcul de Hit CBOW.

Comprendre le contexte et les mots cibles

CBOW s'appuie sur deux concepts clés: les mots de contexte et le mot cible.

• Mots de contexte : Ce sont les mots entourant un mot cible dans une taille de fenêtre définie. Par exemple, dans la phrase:
  "Le renard brun rapide saute par-dessus le chien paresseux" ,
  Si le mot cible est ?renard? et que la taille de la fenêtre de contexte est de 2, les mots de contexte sont [?rapides?, ?brun?, ?sauts?, ?sur?] .
• Mot cible : c'est le mot que CBOW vise à prédire, compte tenu des mots de contexte. Dans l'exemple ci-dessus, le mot cible est ?Fox? .

En analysant la relation entre le contexte et les mots cibles dans les grands corpus, CBOW génère des intégres qui capturent les relations sémantiques entre les mots.

Processus étape par étape de CBOW

Voici une ventilation du fonctionnement du CBOW, étape par étape:

étape 1: Préparation des données

• Choisissez un corpus de texte (par exemple, des phrases ou des paragraphes).
• Tokenize le texte en mots et construisez un vocabulaire.
• Définissez une taille de fenêtre de contexte nnn (par exemple, 2 mots de chaque c?té).

étape2: générer des paires de cibles contextuelles

• Pour chaque mot du corpus, extraire ses mots de contexte environnant en fonction de la taille de la fenêtre.
• Exemple: Pour la phrase ?J'adore l'apprentissage automatique? et n = 2n = 2n = 2, les paires sont: les mots de mot cible Motchs Love [?I?, ?Machine?] Machine [?Love?, ?Apprentissage?]

étape 3: Encodage à un hot

Convertissez les mots de contexte et le mot cible en vecteurs à un hot basé sur la taille du vocabulaire. Pour un vocabulaire de la taille 5, la représentation à un hot du mot ?amour? pourrait ressembler à [0, 1, 0, 0, 0] .

étape 4: Couche d'intégration

Passez les mots de contexte codés à un hot à travers une couche d'intégration. Cette couche mappe chaque mot à une représentation vectorielle dense, généralement d'une dimension inférieure que la taille du vocabulaire.

étape 5: Aggrégation de contexte

Agréger les intérêts de tous les mots de contexte (par exemple, en les faisant la moyenne ou en les additionnant) pour former un seul vecteur de contexte.

étape 6: Prédiction

• Fournitez le vecteur de contexte agrégé dans un réseau neuronal entièrement connecté avec une couche de sortie Softmax.
• Le modèle prédit le mot le plus probable comme cible en fonction de la distribution de probabilité sur le vocabulaire.

étape7: Calcul et optimisation des pertes

• Calculez l'erreur entre le mot cible prévu et réel à l'aide d'une fonction de perte entre l'entropie.
• Backpropagate l'erreur pour ajuster les poids dans les couches d'incorporation et de prédiction.

étape8: Répétez pour toutes les paires

Répétez le processus pour toutes les paires de cibles contextuelles dans le corpus jusqu'à ce que le modèle converge.

CBOW Architecture expliqué en détail

L'architecture du modèle de mots continu (CBOW) est con?ue pour prédire un mot cible basé sur ses mots contextuels environnants. Il s'agit d'un réseau neuronal peu profond avec une structure simple mais efficace. L'architecture CBOW se compose des composants suivants:

Couche d'entrée

• Représentation des entrées :
  L'entrée du modèle est les mots de contexte représentés comme des vecteurs codés à un hot .
  • Si la taille du vocabulaire est V, chaque mot est représenté comme un vecteur à un hot de taille V avec un seul 1 à l'index correspondant au mot, et 0s ailleurs.
  • Par exemple, si le vocabulaire est [?chat?, ?chien?, ?renard?, ?arbre?, ?oiseau?] et le mot ?renard? est le troisième mot, son vecteur à un chaud est [0,0,1,0,0] [0, 0, 1, 0, 0] [0,0,1,0,0].
• Fenêtre de contexte :
  La taille de la fenêtre de contexte n détermine le nombre de mots de contexte utilisés. Si n = 2, deux mots de chaque c?té du mot cible sont utilisés.
  • Pour une phrase: ?Le renard brun rapide saute par-dessus le chien paresseux? et le mot cible ?renard? , les mots de contexte avec n = 2 sont [?rapides?, ?brun?, ?sauts?, ?over?] .

Couche d'incorporation

• But :
  Cette couche convertit les vecteurs à un hot qui existent dans une dimension élevée en vecteurs de dimensions denses et de faibles de faibles. Contrairement au fait que dans les mots d'intégration des mots, les mots sont représentés comme des vecteurs avec des valeurs principalement nulles, dans la couche d'incorporation, chaque mot est codé par le vecteur continu des dimensions requises qui reflètent des caractéristiques spécifiques du sens du mot.
• Matrice d'intégration de mot :
  La couche d'incorporation maintient une matrice d'intégration de mot W de taille V × D, où V est la taille du vocabulaire et D est la dimension d'intégration.
  • Chaque rangée de w représente l'incorporation d'un mot.
  • Pour un vecteur à un hot xxx, l'incorporation est calculée comme w ^ tx x.
• Context Word Embeddings :
  Chaque mot de contexte est transformé en son vecteur dense correspondant en utilisant la matrice d'incorporation. Si la taille de la fenêtre n = 2, et que nous avons 4 mots de contexte, les intérêts pour ces mots sont extraits.

Couche cachée: agrégation de contexte

• But :
  Les intérêts des mots de contexte sont combinés pour former un seul vecteur de contexte.
• Méthodes d'agrégation :
  • En moyenne : les intérêts de tous les mots de contexte sont moyennés pour calculer le vecteur de contexte.

• Résumé : Au lieu de faire la moyenne, les intérêts sont additionnés.

• Vector de contexte résultant : Le résultat est un Vector dense unique HHH, qui représente le contexte agrégé des mots environnants.

Couche de sortie

• Objectif : La couche de sortie prédit le mot cible en utilisant le vecteur de contexte HHH.
• Couche entièrement connectée : le vecteur de contexte HHH est passé à travers une couche entièrement connectée, qui obtient un score brut pour chaque mot dans le vocabulaire. Ces scores sont appelés logits.
• Fonction Softmax : les logits sont passés à travers une fonction Softmax pour calculer une distribution de probabilité sur le vocabulaire:

• Mot cible prévu : La première cause est qu'à la sortie Softmax, l'algorithme définit le mot cible comme le mot avec la probabilité la plus élevée.

Fonction de perte

• La perte de l'entropie croisée est utilisée pour comparer la distribution de probabilité prévue avec le mot cible réel (vérité au sol).
• La perte est minimisée à l'aide de techniques d'optimisation comme la descente de gradient stochastique (SGD) ou ses variantes.

Exemple de CBOW en action

Saisir :
Phrase: ?J'adore l'apprentissage automatique? , Target Word: ?Machine? , Mots de contexte: [?I?, ?Love?, ?Learning?] .

Encodage à un hot :
Vocabulaire: [?I?, ?Love?, ?Machine?, ?Learning?, ?AI?]

• Vecteurs à un hot:
  • ?I?: [1,0,0,0,0] [1, 0, 0, 0, 0] [1,0,0,0,0]
  • ?Amour?: [0,1,0,0,0] [0, 1, 0, 0, 0] [0,1,0,0,0]
  • ?Apprentissage?: [0,0,0,1,0] [0, 0, 0, 1, 0] [0,0,0,1,0]

Couche d'intégration :

• Dimension d'intégration: D = 3.
• Matrice d'intégration W:

Embeddings:

• ?I?: [0,1,0.2,0.3]
• ?Amour?: [0,4,0,5,0,6]
• ?Apprentissage?: [0,2,0,3,0,4]

Agrégation :

• En moyenne les intérêts:

Couche de sortie :

• Calculez les logits, appliquez Softmax et prédisez le mot cible.

Diagramme de l'architecture CBOW

 Couche d'entrée: ["I", "Love", "Learning"]
    -> Encodage à un hot
    -> Couche d'intégration
        -> des incorporations denses
        -> vecteur contextuel agrégé
        -> calque entièrement connecté softmax
Sortie: mot prévu "machine"

Codage cbow à partir de zéro (avec des exemples python)

Nous allons maintenant parcourir la mise en ?uvre du modèle CBOW à partir de zéro dans Python.

Préparer des données pour CBOW

La première pointe consiste à transformer le texte en jetons, des mots générés en paires de cibles de contexte avec le contexte comme les mots contenant le mot cible.

 Corpus = "Le renard brun rapide saute par-dessus le chien paresseux"
corpus = corpus.lower (). Split () # tokenisation et conversion minuscule

# Définir la taille de la fenêtre de contexte
C = 2
context_target_pairs = []

# Générer des paires de cibles contextuelles
pour I à portée (C, Len (Corpus) - C):
    context = corpus [i - c: i] corpus [i 1: i c 1]
    Target = corpus [i]
    context_target_pairs.append ((contexte, cible))

print ("Paies de contexte-cible:", context_target_pairs)

Sortir:

 Context-Target Pairs: [(['the', 'quick', 'fox', 'jumps'], 'brown'), (['quick', 'brown', 'jumps', 'over'], 'fox'), (['brown', 'fox', 'over', 'the'], 'jumps'), (['fox', 'jumps', 'the', 'lazy'], 'over'), (['jumps', ?Over?, ?paresseux?, ?chien?], ?le?)]

Créer le mot dictionnaire

Nous construisons un vocabulaire (un ensemble unique de mots), puis cartons chaque mot à un index unique et vice versa pour des recherches efficaces pendant la formation.

 # Créer un vocabulaire et cartographier chaque mot à un index
vocab = set (corpus)
word_to_index = {word: idx pour idx, word in énumérer (vocab)}
index_to_word = {idx: word pour word, idx dans word_to_index.items ()}

Print ("Word à Index Dictionary:", word_to_index)

Sortir:

 Word to index Dictionary: {'Brown': 0, 'Dog': 1, 'Quick': 2, 'Jump': 3, 'Fox': 4, 'Over': 5, 'The': 6, 'Lazy': 7}

Exemple d'encodage à un chaud

Le codage d'un hot fonctionne en transformant chaque mot dans le système de formation de mots en un vecteur, où l'indicateur du mot est ?1? tandis que le reste des lieux prend ?0?, pour des raisons qui seront bient?t claires.

 def one_hot_encode (word, word_to_index):
    one_hot = np.zeros (len (word_to_index)))
    one_hot [word_to_index [word]] = 1
    retourner un_hot

# Exemple utilisation pour un mot "rapide"
context_one_hot = [one_hot_encode (word, word_to_index) pour word dans ['the', 'Quick']]
print ("Encodage à un hot pour 'Quick':", context_one_hot [1])

Sortir:

 Encodage à un hot pour ?Quick?: [0. 0. 1. 0. 0. 0. 0. 0.]

Construire le modèle CBOW à partir de zéro

Dans cette étape, nous créons un réseau neuronal de base avec deux couches: un pour les incorporations de mots et une autre pour calculer la sortie en fonction des mots de contexte, en moyenne le contexte et en le faisant passer par le réseau.

 Classe CBOW:
    def __init __ (self, vocab_size, embedding_dim):
        # Initialiser aléatoirement des poids pour les couches d'incorporation et de sortie
        self.w1 = np.random.randn (vocab_size, embedding_dim)
        self.w2 = np.random.randn (embedding_dim, vocab_size)
        
    Def en avant (self, context_words):
        # Calculez la couche cachée (moyenne des mots de contexte)
        h = np.mean (context_words, axe = 0)
        # Calculez la couche de sortie (SoftMax Probabilités)
        sortie = np.dot (h, self.w2)
        Sortie de retour
    
    Def Backward (self, context_words, cible_word, apprentissage_rate = 0,01):
        # Passe avant
        h = np.mean (context_words, axe = 0)
        sortie = np.dot (h, self.w2)
        
        # Calculer l'erreur et les gradients
        error = cible_word - sortie
        self.w2 = apprentissage_rate * np.outer (h, erreur)
        self.w1 = apprentissage_rate * np.outer (context_words, erreur)

# Exemple de création d'un objet CBow
vocab_size = len (word_to_index)
Embedding_dim = 5 # Supposons des intégres à 5 dimensions

cbow_model = cbow (vocab_size, embedding_dim)

# Utilisation de mots de contexte aléatoire et de cible (comme exemple)
context_words = [one_hot_encode (word, word_to_index) pour word dans ['le', 'rapide', 'Fox', 'saute']]]
context_words = np.array (context_words)
context_words = np.mean (context_words, axe = 0) # Moyens de contexte Mots
Target_word = one_hot_encode ('Brown', word_to_index)

# Passage avant le modèle CBOW
output = cbow_model.forward (context_words)
Imprimer ("Sortie de CBow Forward Pass:", sortie)

Sortir:

 Sortie de CBOW Pass Forward: [[-0.20435729 -0.23851241 -0.08105261 -0.14251447 0.20442154 0,14336586
  -0,06523201 0,0255063]
 [-0.0192184 -0.12958821 0.1019369 0.11101922 -0.17773069 -0.02340574
  -0.22222151 -0.23863179]
 [0.21221977 -0.15263454 -0.015248 0,27618767 0,02959409 0,2177961
   0.16619577 -0.20560026]
 [0,05354038 0,06903295 0,0592706 -0.13509918 -0.00439649 0,18007843
   0,1611929 0,2449023]
 [0.01092826 0.19643582 -0.07430934 -0.16443165 -0.01094085 -0.27452367
  -0.13747784 0,31185284]]

Utilisation de TensorFlow pour implémenter CBOW

TensorFlow simplifie le processus en définissant un réseau neuronal qui utilise une couche d'intégration pour apprendre des représentations de mots et une couche dense pour la sortie, en utilisant des mots contextuels pour prédire un mot cible.

 Importer TensorFlow comme TF

# Définissez un modèle CBOW simple à l'aide de TensorFlow
classe CBowModel (tf.keras.model):
    def __init __ (self, vocab_size, embedding_dim):
        super (cbowmodel, self) .__ init __ ()
        self.embeddings = tf.keras.layers.embedding (input_dim = vocab_size, output_dim = embedding_dim)
        self.output_layer = tf.keras.layers.dense (vocab_size, activation = 'softmax')
    
    Def Call (self, context_words):
        embedded_context = self.embeddings (context_words)
        context_avg = tf.reduce_mean (embedded_context, axe = 1)
        output = self.output_layer (context_avg)
        Sortie de retour

# Exemple d'utilisation
modèle = cbowmodel (vocab_size = 8, embedding_dim = 5)
context_input = np.random.randint (0, 8, taille = (1, 4)) # entrée de contexte aléatoire
context_input = tf.convert_to_tensor (context_input, dtype = tf.int32)

# Passe avant
Output = modèle (context_input)
Print ("Sortie de TensorFlow CBOW Modèle:", Output.Numpy ())

Sortir:

 Sortie du modèle CBOW TensorFlow: [[0,12362909 0,12616573 0,12758036 0,12601459 0,12477358 0,1237749
  0.12319998 0.12486169]]

Utilisation de Gensim pour CBOW

Gensim propose une implémentation prête à l'emploi de CBOW dans la fonction word2vec () où l'on n'a pas besoin de travailler lors de la formation, car Gensim entra?ne des intégrations de mots dans un corpus de texte.

 importer gensim
de gensim.models importe word2vec

# Préparer les données (liste des listes de mots)
Corpus = [["le", "rapide", "Brown", "Fox"], ["sauts", "Over", "le", "paresseux", "chien"]]

# Entra?ner le modèle Word2Vec à l'aide de CBOW
modèle = word2vec (corpus, vector_size = 5, window = 2, min_count = 1, sg = 0)

# Obtenez la représentation vectorielle d'un mot
vector = modèle.wv ['Fox']
Print ("Représentation vectorielle de 'Fox':", Vector)

Sortir:

 Représentation vectorielle de 'Fox': [-0.06810732 -0.01892803 0.11537147 -0.15043275 -0.07872207]

Avantages du sac continu de mots

Nous allons maintenant explorer les avantages du sac continu de mots:

• Apprentissage efficace des représentations des mots : CBOW apprend efficacement les représentations de vecteur denses pour les mots en utilisant des mots contextuels. Il en résulte des vecteurs à moindre dimension par rapport au codage traditionnel à un hot, qui peut être co?teux en calcul.
• Capture les relations sémantiques : CBOW capture les relations sémantiques entre les mots en fonction de leur contexte dans un grand corpus. Cela permet au modèle d'apprendre des similitudes de mots, des synonymes et d'autres nuances contextuelles, qui sont utiles dans des taches telles que la recherche d'informations et l'analyse des sentiments.
• évolutivité : Le modèle CBOW est très évolutif et peut traiter efficacement de grands ensembles de données, ce qui le rend bien adapté aux applications avec de grandes quantités de données texte, telles que les moteurs de recherche et les plateformes de médias sociaux.
• Flexibilité contextuelle : CBOW peut gérer des quantités variables de contexte (c'est-à-dire le nombre de mots environnants considérés), offrant une flexibilité dans la quantité de contexte requise pour apprendre les représentations des mots.
• Performances améliorées dans les taches NLP : les incorporations de mots de CBOW améliorent les performances des taches NLP en aval, telles que la classification du texte, la reconnaissance des entités nommées et la traduction automatique, en fournissant des représentations de fonctionnalités de haute qualité.

Limites du sac continu de mots

Discutons maintenant des limites de CBOW:

• Sensibilité à la taille de la fenêtre de contexte : Les performances de CBOW dépendent fortement de la taille de la fenêtre de contexte. Une petite fenêtre peut entra?ner la capture de relations locales, tandis qu'une grande fenêtre peut brouiller le caractère distinctif des mots. Trouver la taille optimale du contexte peut être difficile et dépendant des taches.
• Manque de sensibilité de l'ordre des mots : CBOW ne tient pas compte de l'ordre des mots dans le contexte, ce qui signifie qu'il ne capture pas la nature séquentielle du langage. Cette limitation peut être problématique pour les taches qui nécessitent une compréhension approfondie de l'ordre des mots, comme l'analyse syntaxique et la modélisation du langage .
• Difficulty with Rare Words : CBOW struggles to generate meaningful embeddings for rare or out-of-vocabulary (OOV) words. Le modèle s'appuie sur le contexte, mais les données clairsemées pour les mots peu fréquents peuvent conduire à de mauvaises représentations vectorielles.
• Limité à la compréhension contextuelle peu profonde : Bien que CBOW capture les significations des mots basées sur des mots environnants, il a des capacités limitées de compréhension des phénomènes linguistiques plus complexes, tels que des dépendances à longue portée, l'ironie ou le sarcasme, qui peut nécessiter des modèles plus sophistiqués comme les transformateurs.
• L'incapacité à gérer bien la polysémie : les mots avec plusieurs significations (polysémie) peuvent être problématiques pour CBOW. étant donné que le modèle génère une seule intégration pour chaque mot, il peut ne pas capturer les différentes significations qu'un mot peut avoir dans différents contextes, contrairement aux modèles plus avancés comme Bert ou Elmo .

Conclusion

Le modèle continu de mots (CBOW) s'est avéré être une approche efficace et intuitive pour générer des incorporations de mots en tirant parti du contexte environnant. Grace à son architecture simple mais efficace, CBOW comble l'écart entre le texte brut et les représentations vectorielles significatives, permettant un large éventail d'applications NLP. En comprenant le mécanisme de travail de CBOW, ses forces et ses limites, nous gagnons plus approfondie de l'évolution des techniques de PNL. Avec son r?le fondamental dans la génération d'intégration, CBOW continue d'être un tremplin pour explorer des modèles de langage avancé.

Principaux à retenir

• CBOW prédit un mot cible utilisant son contexte environnant, ce qui le rend efficace et simple.
• Il fonctionne bien pour des mots fréquents, offrant une efficacité de calcul.
• Les intérêts appris par CBOW capturent les relations sémantiques et syntaxiques.
• CBOW est fondamental pour comprendre les techniques d'intégration des mots modernes.
• Les applications pratiques comprennent l'analyse des sentiments, la recherche sémantique et les recommandations de texte.

Questions fréquemment posées

R: CBOW prédit un mot cible en utilisant des mots contextuels, tandis que Skip-Gram prédit des mots contextuels en utilisant le mot cible.

R: CBOW traite simultanément plusieurs mots de contexte, tandis que Skip-Gram évalue chaque mot de contexte indépendamment.

R: Non, Skip-Gram est généralement meilleur dans l'apprentissage des représentations pour des mots rares.

R: La couche d'intégration transforme des vecteurs clairsemés à un hot en représentations denses, capturant la sémantique de mots.

R: Oui, alors que des modèles plus récents comme Bert existent, CBOW reste un concept fondamental dans les incorporations de mots.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!