Enrichir les Vecteurs de Mots avec des Informations de Sous-Mots

Introduction

 Consultez le Code|  Consultez le Repository

Source :

Intuition

La signification d’un mot dépend des mots qui l’entourent.

Comprendre la morphologie

Par exemple, en français ou en espagnol, la plupart des verbes ont plus de quarante formes conjuguées, tandis que le finlandais a quinze cas pour les noms. Ces langues contiennent de nombreuses formes de mots qui se présentent rarement (ou pas du tout) dans le corpus d’entraînement, ce qui rend difficile l’apprentissage de bonnes représentations de mots. Puisque de nombreuses formations de mots suivent des règles, il est possible d’améliorer les représentations vectorielles pour les langues riches morphologiquement en utilisant une information à niveau de caractères (character level information).

« La couleur rouge ressort »
« Qu’est-ce qui a une couleur verte ? »
« Les nuances de la couleur jaune te vont bien »

An example of word morphology

L’Objectif

Étant donné un vocabulaire de mot de taille $W$, où un mot est identifié par son index $w\in \{1,...,W\}$ le but est d’apprendre une représentation vectorielle de chaque mot w. Étant donné un large corpus d’entraînement représentant une séquence de mots l’objectif du modèle skip-gram est de maximiser la log-vraisemblance suivante :

Cependant, un tel modèle n’est pas adapté à notre cas, car il implique que, étant donné un mot $w_t$ , nous ne prédisions qu’un seul mot de contexte $w_c$ .

Espace de sous-mots

En utilisant une représentation vectorielle distincte pour chaque mot, le modèle skipgram ignore la structure interne des mots.

>>>word = "where"
>>>word = f"<{word}>"
>>>n_grams = [word[i:i+3] for i in range(len(word)-2)]+[word]
n_grams
>>>n_grams
['<wh', 'whe', 'her', 'ere', 're>', '<where>']

Supposons que nous soit donné un dictionnaire de n-grams de taille $G$. Étant donné un mot w, désignons par by $G_w \sub \{1,...,G\}$ le set de n-grams qui apparaît dans $w$. Nous associons une représentation vectorielle $z_g$ à chaque n-gram $g$. Nous représentons un mot par la somme des représentations vectorielles de ses n-grams. Ainsi, nous obtenons la fonction de score :

Code

 Consulter le Code |  Consulter le Repository

# Create a `tf.data` with all the non-negative sentences
>>> text_ds = tf.data.TextLineDataset(path_to_file).filter(lambda x: tf.cast(tf.strings.length(x), bool))

>>> for text in text_ds.take(5):
    	print(text)

tf.Tensor(b'First Citizen:', shape=(), dtype=string)
tf.Tensor(b'Before we proceed any further, hear me speak.', shape=(), dtype=string)
tf.Tensor(b'All:', shape=(), dtype=string)
tf.Tensor(b'Speak, speak.', shape=(), dtype=string)
tf.Tensor(b'First Citizen:', shape=(), dtype=string) 

# We create a custom standardization function to lowercase the text and 
# remove punctuation.
def custom_standardization(input_data):
    lowercase = tf.strings.lower(input_data)
    return tf.strings.regex_replace(lowercase,
                                    '[%s]' % re.escape(string.punctuation), '')

# Define the vocabulary size and number of words in a sequence.
vocab_size = 4096
sequence_length = 10

# Use the text vectorization layer to normalize, split, and map strings to
# integers. Set output_sequence_length length to pad all samples to same length.
vectorize_layer = TextVectorization(
    standardize=custom_standardization,
    max_tokens=vocab_size,
    output_mode='int',
    output_sequence_length=sequence_length)

# build the vocab
vectorize_layer.adapt(text_ds.batch(1024))

Source: Word2Vec

Pour notre processus d’entraînement, nous n’utilisons pas le tf.random.log_uniform_candidate_sampler et à la place, nous personnalisons le processus pour inclure de meilleurs samples négatifs dans le processus d’entraînement. Thread StackOverFlow pour suivre la discussion.

(1000, None) - 1000 ngrams.
(1000, 5, 1) - 1000 5-pieces context words.
(1000, 5) - 1000 5-piece labels.

class Word2Vec(Model):
    def __init__(self, subword_vocab_size, vocab_size, embedding_dim):
        super(Word2Vec, self).__init__()
        self.target_embedding = Embedding(subword_vocab_size+1, 
                                        embedding_dim,
                                        input_length=None,
                                        name="w2v_embedding",)
        self.context_embedding = Embedding(vocab_size+1, 
                                        embedding_dim, 
                                        input_length=num_ns+1)
        self.dots = Dot(axes=(3,1))
        self.flatten = Flatten()

    def call(self, pair):
        target, context = pair
        we = tf.math.reduce_sum(self.target_embedding(target),axis=1)
        ce = self.context_embedding(context)
        dots = self.dots([ce, we])
        return self.flatten(dots)

Résultats

Projections d’Embeddings

Contexte

Mot recherché : "for"

Mot recherché : "secrets"

Cible

Mot recherché : "<th"

Mot recherché : "the"

Conclusion