Comment former le modèle word2vec en utilisant la bibliothèque gensim

Qu’est-ce que l’intégration de mots ?

L’intégration de mots est un processus de compréhension du texte par des algorithmes d’apprentissage automatique, aussi nous disons que l’intégration de mots est une représentation apprise pour le texte où il capture le contexte du mot dans un document, la similarité sémantique et syntaxique ainsi que la relation entre les autres mots dans le corpus.

Cette approche détient la clé pour résoudre les problèmes de traitement du langage naturel en utilisant l’apprentissage automatique et l’algorithme d’apprentissage profond. Fondamentalement, l’intégration des mots est une représentation vectorielle des mots. En calculant la distance ou la position des mots, il représente les mots de sens, les phrases, les paragraphes ou les documents.

Il y a plusieurs techniques d’intégration de mots a été introduit jusqu’à présent. Généralement, nous disons qu’il existe deux types d’incorporation de mots –

• Intégration de mots statiques
• Intégration de mots contextuels

1. Incorporation de mots statiques : Les méthodes traditionnelles telles que Skip-Gram et Continuous Bag-of-Words apprennent l’incorporation statique en formant des tables de consultation qui traduisent les mots en vecteur dense. L’incorporation statique est directement utile pour résoudre la tâche de sémantique lexicale.

Problème : ne peut pas résoudre les ambiguïtés pour les mots polysémiques. Par exemple, lorsqu’un mot représente plusieurs significations dans deux phrases différentes, les méthodes Skip-Gram ou BOW échouent.

2. Incorporation de mots contextuels : L’incorporation de mots contextualisés vise à capturer la sémantique des mots dans différents contextes pour résoudre le problème de la polysémie et de la nature dépendante du contexte des mots. Le modèle LSTM, LSTM bi-directionnel etc. aide à obtenir la forme vectorielle des mots.

Modèle Word2Vec : Word2Vec est une méthode pour construire un tel encastrement statique des mots. Cela a été réalisé en utilisant deux méthodes Skip Gram et Common Bag of Words (CBOW) avec l’aide de réseaux neuronaux. Elle a été développée par Tomas Mikolov en 2013 chez Google.

Pourquoi en avons-nous besoin ?

Disons que nous avons les phrases suivantes.

« J’aime coder dans Jupyter. » et « J’aime coder dans Pycharm ».

Les deux phrases sont très proches les unes des autres. Si nous construisons un vocabulaire exhaustif (appelons-le V), il aura V = {I, love, enjoy, coding, in, Jupyter, Pycharm}. Si nous choisissons un seul encodage chaud. Nous ne serons pas en mesure d’obtenir le sens exact que l’amour, profiter, codage chaque mot sont traités comme même, alors que l’amour et profiter et très proche les uns des autres.

Notre motif est d’avoir des mots avec un contexte similaire sera très proche position spatiale. Mathématiquement, la distance cosinus identifiera la proximité de deux mots. La distance cosinus du mot le plus proche ou Cosinus de l’ange sera proche de 0 et pour le plus éloigné, elle sera proche de 1.

Comment fonctionne Word2Vec ?

Le modèle Word2Vec peut fonctionner sur deux algorithmes –

• Skip-gram
• CBOW (Continuous Bag of Words)

Modèle CBOW : Cette méthode prend le contexte de chaque mot comme entrée et essaie de prédire le mot correspondant au contexte. Dans le processus de prédiction du mot cible, nous apprenons la représentation vectorielle du mot cible. Comme entrée, plusieurs mots seront là selon la taille de la fenêtre(5 mots) mais il retournera un seul mot comme sortie.

Regardons plus profondément l’architecture:

Modèle Skip-Gram : C’est un autre algorithme pour Word2Vec. Il est à l’opposé du modèle CBOW. Le modèle prendra un mot en entrée, mais il renverra plusieurs mots selon la taille de la fenêtre.

Implémentation de l’incorporation de mots avec le modèle Word2Vec de Gensim:

Ici, je vais expliquer étape par étape comment former le modèle word2vec en utilisant Gensim. Dataset, j’ai recueilli de la plate-forme Kaggle. Ce jeu de données provient des données publiques du Myers-Briggs Type Indicator. Il contient deux colonnes : type et post. « type » définit 16 types de personnalité et « post » définit le commentaire de ces 16 types d’individu personnalisé.

1. Chargement et description des données

# Chargement du jeu de données
data_df = pd.read_csv(« data/mbti_1.csv »)
data_df.head()

2. Nettoyage et prétraitement des données

Après avoir chargé les données, il faut trouver si les données contiennent une valeur NA, si une valeur NA dans l’ensemble de données, nous la laisserons tomber.

# Suppression des valeurs na du dataframe
def data_na_value_cleaning(data):
print(« \nBefore cleaning, Data Shape : « , data.shape)
print(« \nBefore removing Null values : – – – – – – -« )
print(data.isna().sum())
data.dropna(inplace=True)
data.reset_index(inplace=True,drop=True)
print(« \n After removing Null values : – – – – – -« )
print(data.isna().sum())
print(« \nAfter cleaning, Data Shape : « , data.shape)
return data

Comme nos données en n’ont pas de valeurs NA. Donc, aucune ligne n’a été supprimée. Maintenant, nous vérifions s’il y a des valeurs dupliquées dans le Dataset.

# Suppression des valeurs dupliquées
def duplicate_content_removal(data, col, ini_row):
print(« \nBefore removing duplicates, number of data was : « , ini_row)
duplicate_count = data.duplicated().sum()
print(« \nNombre de doublons : « , duplicate_count)

description_data = data.drop_duplicates()
cleaned_row = len(description_data)
if (ini_row – cleaned_row) > 0:
print(« \nTotal data reduction : « , (ini_row – cleaned_row))
print(« \nAprès suppression des doublons, le nombre de données est de : », cleaned_row)
else:
print(« \nDataset ne contient pas de données en double. »)
return list(description_data)

posts = duplicate_content_removal(data_df, ‘posts’, data_df.shape)

Maintenant, dans le cadre du processus de nettoyage, nous allons supprimer les liens et la ponctuation. En outre, pour une meilleure formation seulement, nous allons considérer les mots non numériques et alphanumériques. Nous supprimerons les mots d’arrêt pour une meilleure compréhension et une meilleure précision du modèle.

def remove_link_punc(string):
# suppression des liens
temp_string = re.sub(‘http?://(?:|||( ?:%))+’, ‘ ‘, chaîne)

# suppression de tout sauf les lettres anglaises a-z
regex = re.compile( »)
temp_string = regex.sub(‘ ‘, temp_string)

# suppression des espaces supplémentaires
clean_string = re.sub(‘ +’, ‘ ‘, temp_string).lower()

return clean_string

Méthode suivante data_cleaning

def data_cleaning(content):
sentences =
for idx in tqdm(range(len(content))):
if content != «  »:
# Tokenisation des phrases à l’aide de la bibliothèque NLTK
for each_sent in sent_tokenize(str(content)):
if each_sent != «  »:
temp_sent =
# Suppression du lien et de la ponctuation
each_sent = remove_link_punc(each_sent.lower())

# Suppression des mots d’arrêt et application de la lemmatisation
for each_word in each_sent.split():
if each_word not in stop_words and len(each_word)>= 3:
temp_sent.append(lemmatizer.lemmatize(each_word))

# Seulement en prenant la longueur de la liste de mots est supérieure à égale à 5
if len(temp_sent) >= 5:
sentences.append(temp_sent)
return sentences

sent_corpus = data_cleaning(posts)

# Statistiques des mots des phrases
len_count =
for l in sent_corpus:
len_count.append(len(l))

print(« Nombre total de phrases : « , len(len_count))
word_sent_df = pd.DataFrame(sorted(Counter(len_count).items()), columns=)
word_sent_df.head(10)

Après nettoyage et prétraitement des données, les données ressemblent à chaque mot dans une liste. Chaque liste est la représentation d’une phrase. Genism word2vec nécessite qu’un format de ‘liste de listes’ pour la formation où chaque document est contenu dans une liste et chaque liste contient des tokens de ce document.

3. Entraînement du modèle

Nous allons maintenant entraîner le modèle word2vec en utilisant la bibliothèque Gensim avec notre propre jeu de données.

modèle = Word2Vec(phrases=sent_corpus, size=200, window=4, min_count=1, workers=4)

sentences : où nous pouvons passer notre jeu de données préparé qui est sent_corpus

size : Dimension de la forme vectorielle générée de chaque mot, par défaut la taille est 100.

window : Distance maximale entre le mot actuel et le mot prédit dans une phrase, la valeur par défaut est 5

min_count : Ignorer tous les mots où la fréquence de chaque mot est inférieure à min_count, la valeur par défaut est 5. Comme nous voulions ajouter tous les mots du corpus, la valeur que nous avons fournie est 1.

workers : Utilise ces nombreux threads pour entraîner le modèle. La valeur par défaut est 3

sg : Utilisé pour choisir l’algorithme d’entraînement : 1 pour skip-gram ; 0 pour CBOW. Par défaut, CBOW est utilisé pour l’entraînement.

4. Mot de forme vectorisé

Après la formation du modèle est terminée. On peut aller chercher la forme vectorisée de chaque mot. Il y a deux méthodes pour obtenir la forme vectorielle. La forme du vecteur sera 200 selon la taille donnée.

# Obtenir la forme vectorielle du mot king
model.wv.get_vector(‘king’)

Or

# Une autre façon d’obtenir la forme vectorielle du mot2vec
model.wv.word_vec(‘king’)

5. Similitude et distance entre deux mots

Nous allons fournir deux listes de mots ‘roi’, ‘homme’ dans une liste et ‘reine’, ‘femme’ dans une autre liste. Nous allons essayer de trouver à quel point ces deux listes de mots sont similaires.

# Liste de similarité de mots
model.wv.n_similarité(,)

Ici nous allons regarder, quelle est la distance entre deux mots.

# Distance entre deux mots
model.wv.distance(‘king’,’queen’)

Si nous voulons obtenir des mots similaires alors nous pouvons utiliser le code ci-dessous.

# Mot similaire pour roi
model.wv.similar_by_word(‘king’)

6. Autres techniques utilisant word2Vec

# Odd one out from list of words
model.wv.doesnt_match()

Cela nous aidera à trouver les mots impairs présents dans une liste.

# évaluation des paires de mots
model.wv.evaluate_word_pairs(‘data/SimLex-999/SimLex-999_2.txt’,)

Cela nous aidera à tp évaluer la paire de mots

# Analogies de mots à partir de la liste de mots
model.wv.evaluate_word_analogies(‘data/questions-words.txt’)

Ceci sera utile pour l’analogie des mots

7. Chargement du modèle entraîné

Si nous devons utiliser le modèle entraîné, ce qui peut être réalisé en utilisant le code ci-dessous.

# Chargement du modèle pré-entraîné de google
from gensim import models

models.KeyedVectors.load_word2vec_format(‘data/GoogleNews-vectors-negative300.bin’, binary=True)

Ici j’ai essayé de charger le modèle pré-entraîné de google. Nous pouvons le télécharger à partir du lien. Ce modèle est également très puissant et entraîné sur d’énormes ensembles de données.

Pour plus de détails sur la mise en œuvre, vous pouvez jeter un coup d’œil à mon code sur github.

Merci de lire, s’il vous plaît laissez-moi si la question ou le doute est là. Je serai heureux de répondre à vos questions.