Incorporation de mots et modèle Word2Vec avec exemple

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

Incorporation de mots est un type de représentation de mots qui permet aux algorithmes d'apprentissage automatique de comprendre des mots ayant des significations similaires. Il s'agit d'une technique de modélisation du langage et d'apprentissage de fonctionnalités permettant de mapper des mots en vecteurs de nombres réels à l'aide de réseaux de neurones, de modèles probabilistes ou d'une réduction de dimension sur la matrice de cooccurrence de mots. Certains modèles d'intégration de mots sont Word2vec (Google), Glove (Stanford) et Fastest (Facebook).

L'incorporation de mots est également appelée modèle sémantique distribué ou espace vectoriel représenté ou sémantique distribué ou modèle d'espace vectoriel. En lisant ces noms, vous tombez sur le mot sémantique, qui signifie catégoriser ensemble des mots similaires. Par exemple les fruits comme la pomme, la mangue, la banane devront être placés à proximité alors que les livres seront éloignés de ces mots. Dans un sens plus large, l'incorporation de mots créera le vecteur de fruits qui sera placé loin de la représentation vectorielle des livres.

Où l’intégration de mots est-elle utilisée ?

L'intégration de mots facilite les tâches de génération de fonctionnalités, de regroupement de documents, de classification de texte et de traitement du langage naturel. Énumérons-les et discutons de chacune de ces applications.

• Calculez des mots similaires : L'intégration de mots est utilisée pour suggérer des mots similaires au mot soumis au modèle de prédiction. Parallèlement à cela, il suggère également des mots différents, ainsi que les mots les plus courants.
• Créez un groupe de mots apparentés : Il est utilisé pour le regroupement sémantique qui regroupera des éléments de caractéristiques similaires et de distances différentes.
• Fonctionnalité de classification de texte : Le texte est mappé dans des tableaux de vecteurs qui sont transmis au modèle à des fins de formation et de prédiction. Les modèles de classificateur basés sur du texte ne peuvent pas être entraînés sur la chaîne, cela convertira donc le texte en une forme pouvant être entraînée par une machine. Approfondir ses fonctionnalités de création d'une aide sémantique dans la classification basée sur du texte.
• Regroupement de documents : est une autre application où Word Embedding Word2vec est largement utilisé
• Traitement du langage naturel: Il existe de nombreuses applications dans lesquelles l'intégration de mots est utile et l'emporte sur les phases d'extraction de fonctionnalités telles que le marquage de parties du discours, l'analyse sentimentale et l'analyse syntaxique. Nous avons maintenant une certaine connaissance de l'intégration de mots. Un peu de lumière est également jetée sur différents modèles pour implémenter l’intégration de mots. L’ensemble de ce didacticiel Word Embedding se concentre sur l’un des modèles (Word2vec).

Qu’est-ce que Word2vec ?

Mot2vec est une technique/modèle pour produire l'intégration de mots pour une meilleure représentation des mots. Il s'agit d'une méthode de traitement du langage naturel qui capture un grand nombre de relations syntaxiques et sémantiques précises entre les mots. Il s'agit d'un réseau neuronal peu profond à deux couches qui peut détecter des mots synonymes et suggérer des mots supplémentaires pour des phrases partielles une fois formé.

Avant d'aller plus loin dans ce didacticiel Word2vec, veuillez voir la différence entre un réseau neuronal superficiel et profond, comme indiqué dans le diagramme d'exemple d'intégration de Word ci-dessous :

Le réseau neuronal peu profond consiste en la seule couche cachée entre l'entrée et la sortie, tandis que le réseau neuronal profond contient plusieurs couches cachées entre l'entrée et la sortie. L'entrée est soumise aux nœuds tandis que la couche cachée, ainsi que la couche de sortie, contiennent des neurones.

Word2vec est un réseau à deux couches où il y a une entrée, une couche cachée et une sortie.

Word2vec a été développé par un groupe de chercheurs dirigé par Tomas Mikolov chez Google. Word2vec est meilleur et plus efficace que le modèle d'analyse sémantique latente.

Pourquoi Word2vec ?

Word2vec représente les mots dans une représentation spatiale vectorielle. Les mots sont représentés sous forme de vecteurs et le placement est effectué de telle manière que les mots de signification similaire apparaissent ensemble et que les mots différents sont situés au loin. Ceci est également appelé relation sémantique. Les réseaux de neurones ne comprennent pas le texte, mais uniquement les chiffres. Word Embedding fournit un moyen de convertir du texte en vecteur numérique.

Word2vec reconstruit le contexte linguistique des mots. Avant d’aller plus loin, comprenons qu’est-ce que le contexte linguistique ? Dans un scénario de vie général, lorsque nous parlons ou écrivons pour communiquer, d'autres personnes essaient de comprendre quel est l'objectif de la phrase. Par exemple, « Quelle est la température de l'Inde », ici le contexte est l'utilisateur veut connaître « la température de l'Inde » qui est le contexte. Bref, l'objectif principal d'une phrase est le contexte. Un mot ou une phrase entourant le langage parlé ou écrit (divulgation) aide à déterminer la signification du contexte. Word2vec apprend la représentation vectorielle des mots à travers les contextes.

Que fait Word2vec ?

Avant l'intégration de mots

Il est important de savoir quelle approche est utilisée avant l'intégration de mots et quels sont ses inconvénients, puis nous passerons au sujet de la façon dont les inconvénients sont surmontés par l'intégration de Word à l'aide de l'approche Word2vec. Enfin, nous aborderons le fonctionnement de Word2vec car il est important de comprendre qu'il fonctionne.

Approche pour l'analyse sémantique latente

C'est l'approche qui était utilisée avant les intégrations de mots. Il a utilisé le concept de Sac de mots où les mots sont représentés sous forme de vecteurs codés. Il s'agit d'une représentation vectorielle clairsemée où la dimension est égale à la taille du vocabulaire. Si le mot apparaît dans le dictionnaire, il est compté, sinon pas. Pour en savoir plus, veuillez consulter le programme ci-dessous.

Exemple Word2vec

from sklearn.feature_extraction.text import CountVectorizer

vectorizer = CountVectorizer()
data_corpus = ["guru99 is the best site for online tutorials. I love to visit guru99."]
vocabulary = vectorizer.fit(data_corpus)
X = vectorizer.transform(data_corpus)

print(X.toarray())
print(vectorizer.get_feature_names_out())

Sortie :

[[1 2 1 1 1 1 1 1 1 1]]

[u'best', u'guru99', u'is', u'love', u'online', u'sitefor', u'the', u'to', u'tutorials', u'visit']

Explication du code

1. CountVectorizer est le module utilisé pour stocker le vocabulaire en fonction de l'ajustement des mots qu'il contient. Ceci est importé du sklearn.
2. Créez l'objet en utilisant la classe CountVectorizer.
3. Écrivez les données dans la liste qui doivent être intégrées dans le CountVectorizer.
4. Les données sont adaptées à l'objet créé à partir de la classe CountVectorizer.
5. Appliquez une approche par sac de mots pour compter les mots dans les données à l’aide du vocabulaire. Si le mot ou le jeton n'est pas disponible dans le vocabulaire, alors cette position d'index est mise à zéro.
6. La variable de la ligne 5 qui est x est convertie en tableau (méthode disponible pour x). Cela fournira le nombre de chaque jeton dans la phrase ou la liste fournie à la ligne 3.
7. Cela montrera les caractéristiques qui font partie du vocabulaire lorsqu'il est ajusté à l'aide des données de la ligne 4.

Dans l'approche sémantique latente, la ligne représente des mots uniques tandis que la colonne représente le nombre de fois que ce mot apparaît dans le document. Il s'agit d'une représentation de mots sous la forme d'une matrice de document. La fréquence de document inverse terme-fréquence (TFIDF) est utilisée pour compter la fréquence des mots dans le document qui est la fréquence du terme dans le document/la fréquence du terme dans l'ensemble du corpus.

Lacune de la méthode Bag of Words

• Il ignore l'ordre du mot, par exemple, ceci est mauvais = mauvais est-ce.
• Il ignore le contexte des mots. Supposons que j'écrive la phrase « Il aimait les livres. L’éducation se trouve mieux dans les livres ». Cela créerait deux vecteurs, l’un pour « Il aimait les livres » et l’autre pour « L’éducation se trouve mieux dans les livres ». Cela les traiterait tous les deux orthogonalement, ce qui les rend indépendants, mais en réalité, ils sont liés l'un à l'autre.

Pour surmonter ces limitations, l'intégration de mots a été développée et Word2vec est une approche pour la mettre en œuvre.

Comment fonctionne Word2vec ?

Word2vec apprend le mot en prédisant son contexte environnant. Par exemple, prenons le mot « Il aime Football."

Nous voulons calculer le Word2vec pour le mot : aime.

Supposer

loves =  Vin. P(Vout / Vin) is calculated	
where,	
Vin is the input word. 	
P is the probability of likelihood.	
Vout is the output word. 	

Word aime se déplace sur chaque mot du corpus. La relation syntaxique et sémantique entre les mots est codée. Cela aide à trouver des mots similaires et des analogies.

Toutes les caractéristiques aléatoires du mot aime est calculé. Ces fonctionnalités sont modifiées ou mises à jour concernant les mots voisins ou contextuels à l'aide d'un Rétropropagation méthode.

Une autre façon d’apprendre est que si le contexte de deux mots est similaire ou si deux mots ont des caractéristiques similaires, alors ces mots sont liés.

Mot2vec Architecture

Il existe deux architectures utilisées par Word2vec :

1. Sac de mots continu (CBOW)
2. Sauter le gramme

Avant d'aller plus loin dans ce didacticiel Word2vec, expliquons pourquoi ces architectures ou modèles sont importants du point de vue de la représentation des mots. L'apprentissage de la représentation des mots est essentiellement non supervisé, mais des cibles/étiquettes sont nécessaires pour entraîner le modèle. Skip-gram et CBOW convertissent la représentation non supervisée en forme supervisée pour la formation de modèles.

Dans CBOW, le mot actuel est prédit à l'aide de la fenêtre des fenêtres contextuelles environnantes. Par exemple, si w_i-1,w_i-2,w_{i + 1},w_{i + 2}reçoivent des mots ou un contexte, ce modèle fournira w_i

Skip-Gram fonctionne à l'opposé de CBOW, ce qui implique qu'il prédit la séquence ou le contexte donné à partir du mot. Vous pouvez inverser l’exemple pour le comprendre. Si w_i est donné, cela prédira le contexte ou w_i-1,w_i-2,w_{i + 1},w_je+2.

Word2vec offre la possibilité de choisir entre CBOW (sac continu de mots) et skim-gram. Ces paramètres sont fournis lors de la formation du modèle. On peut avoir la possibilité d'utiliser un échantillonnage négatif ou une couche softmax hiérarchique.

Sac continu de mots

Dessinons un exemple simple de diagramme Word2vec pour comprendre le sac continu d'architecture de mots.

Calculons les équations mathématiquement. Supposons que V soit la taille du vocabulaire et N soit la taille de la couche cachée. L'entrée est définie comme {x_i-1, X_je-2, x_je+1, x_{i + 2}}. Nous obtenons la matrice de poids en multipliant V * N. Une autre matrice est obtenue en multipliant le vecteur d'entrée par la matrice de poids. Cela peut également être compris par l’équation suivante.

h=xi^tW

où xi^t? W sont respectivement le vecteur d'entrée et la matrice de poids,

Pour calculer la correspondance entre le contexte et le mot suivant, veuillez vous référer à l'équation ci-dessous

u=représentation prévue*h

où la représentation prédite est obtenue modèle ?h dans l’équation ci-dessus.

Modèle Skip-Gram

L'approche Skip-Gram est utilisée pour prédire une phrase à partir d'un mot saisi. Pour mieux le comprendre, dessinons le diagramme comme indiqué dans l'exemple Word2vec ci-dessous.

On peut le traiter comme l'inverse du modèle de sac continu de mots où l'entrée est le mot et le modèle fournit le contexte ou la séquence. Nous pouvons également conclure que la cible est transmise à la couche d'entrée et que la couche de sortie est répliquée plusieurs fois pour s'adapter au nombre choisi de mots de contexte. Le vecteur d'erreur de toute la couche de sortie est résumé pour ajuster les poids via une méthode de rétropropagation.

Quel modèle choisir ?

CBOW est plusieurs fois plus rapide que skip gram et offre une meilleure fréquence pour les mots fréquents, tandis que skip gram nécessite une petite quantité de données d'entraînement et représente même des mots ou des phrases rares.

La relation entre Word2vec et NLTK

NLTK est une boîte à outils en langage naturel. Il est utilisé pour le prétraitement du texte. On peut effectuer différentes opérations telles que le marquage de parties du discours, la lemmatisation, la radicalisation, la suppression des mots vides, la suppression des mots rares ou des mots les moins utilisés. Il aide à nettoyer le texte ainsi qu'à préparer les fonctionnalités à partir des mots efficaces. D'une autre manière, Word2vec est utilisé pour la correspondance sémantique (éléments étroitement liés) et syntaxique (séquence). En utilisant Word2vec, on peut trouver des mots similaires, des mots différents, une réduction dimensionnelle et bien d'autres. Une autre fonctionnalité importante de Word2vec est de convertir la représentation de dimension supérieure du texte en dimensions inférieures de vecteurs.

Où utiliser NLTK et Word2vec ?

Si l'on doit accomplir certaines tâches générales comme mentionnées ci-dessus, comme la tokenisation, le marquage POS et l'analyse, il faut utiliser NLTK, tandis que pour prédire les mots en fonction d'un contexte, d'une modélisation de sujet ou d'une similarité de documents, il faut utiliser Word2vec.

Relation entre NLTK et Word2vec à l'aide du code

NLTK et Word2vec peuvent être utilisés ensemble pour trouver une représentation de mots similaires ou une correspondance syntaxique. La boîte à outils NLTK peut être utilisée pour charger de nombreux packages fournis avec NLTK et le modèle peut être créé à l'aide de Word2vec. Il peut ensuite être testé sur les mots en temps réel. Voyons la combinaison des deux dans le code suivant. Avant de poursuivre le traitement, veuillez consulter les corpus fournis par NLTK. Vous pouvez télécharger en utilisant la commande

nltk(nltk.download('all'))

Veuillez consulter la capture d'écran pour le code.

import nltk
import gensim
from nltk.corpus import abc

model= gensim.models.Word2Vec(abc.sents())
X= list(model.wv.vocab)
data=model.most_similar('science')
print(data)

Sortie :

[('law', 0.9415997266769409), ('practice', 0.9276568293571472), ('discussion', 0.9259148836135864), ('agriculture', 0.9257254004478455), ('media', 0.9232194423675537), ('policy', 0.922248125076294), ('general', 0.9166069030761719), ('undertaking', 0.916458249092102), ('tight', 0.9129181504249573), ('board', 0.9107444286346436)]

Explication du code

1. La bibliothèque nltk est importée, à partir de laquelle vous pouvez télécharger le corpus abc que nous utiliserons à l'étape suivante.
2. Gensim est importé. Si Gensim Word2vec n'est pas installé, veuillez l'installer à l'aide de la commande « pip3 install gensim ». Veuillez consulter la capture d'écran ci-dessous.

3. importez le corpus abc qui a été téléchargé à l'aide de nltk.download('abc').
4. Transmettez les fichiers au modèle Word2vec qui est importé en utilisant Gensim sous forme de phrases.
5. Le vocabulaire est stocké sous la forme d'une variable.
6. Le modèle est testé sur des exemples de mots scientifiques car ces fichiers sont liés à la science.
7. Ici, le mot similaire de « science » est prédit par le modèle.

Activateurs et Word2Vec

La fonction d'activation du neurone définit la sortie de ce neurone à partir d'un ensemble d'entrées. Biologiquement inspiré d'une activité dans notre cerveau où différents neurones sont activés à l'aide de différents stimuli. Comprenons la fonction d'activation à travers le schéma suivant.

Ici x1,x2,..x4 est le nœud du réseau neuronal.

w1, w2, w3 est le poids du nœud,

? est la somme de tous les poids et valeurs de nœuds qui fonctionnent comme fonction d'activation.

Pourquoi la fonction d'activation ?

Si aucune fonction d'activation n'est utilisée, la sortie serait linéaire mais la fonctionnalité de la fonction linéaire est limitée. Pour obtenir des fonctionnalités complexes telles que la détection d'objets, la classification d'images, la saisie de texte à l'aide de la voix et de nombreuses autres sorties non linéaires, elles sont réalisées à l'aide de la fonction d'activation.

Comment la couche d'activation est calculée dans l'intégration de mots (Word2vec)

Softmax Layer (fonction exponentielle normalisée) est la fonction de couche de sortie qui active ou déclenche chaque nœud. Une autre approche utilisée est le softmax hiérarchique où la complexité est calculée par O(log₂V) où le softmax est O(V) où V est la taille du vocabulaire. La différence entre ceux-ci réside dans la réduction de la complexité de la couche hiérarchique softmax. Pour comprendre sa fonctionnalité (softmax hiérarchique), veuillez consulter l'exemple d'intégration de Word ci-dessous :

Supposons que nous voulions calculer la probabilité d'observer le mot love étant donné un certain contexte. Le flux de la racine vers le nœud feuille sera le premier déplacement vers le nœud 2 puis vers le nœud 5. Donc, si nous avons une taille de vocabulaire de 8, seuls trois calculs sont nécessaires. Cela permet donc de décomposer, de calculer la probabilité d'un mot (love).

Quelles autres options sont disponibles autres que Hierarchical Softmax ?

Si nous parlons d'une manière générale, les options d'intégration de mots disponibles sont Softmax différencié, CNN-Softmax, échantillonnage d'importance, échantillonnage d'importance adaptatif, estimations de contraste de bruit, échantillonnage négatif, auto-normalisation et normalisation peu fréquente.

En parlant spécifiquement de Word2vec, nous disposons d'un échantillonnage négatif.

L'échantillonnage négatif est un moyen d'échantillonner les données d'entraînement. Cela ressemble un peu à la descente de gradient stochastique, mais avec quelques différences. L'échantillonnage négatif recherche uniquement les exemples de formation négatifs. Il est basé sur une estimation contrastive du bruit et échantillonne les mots de manière aléatoire, et non dans le contexte. C'est une méthode de formation rapide et choisit le contexte de manière aléatoire. Si le mot prédit apparaît dans le contexte choisi au hasard, les deux vecteurs sont proches l'un de l'autre.

Quelle conclusion peut-on en tirer ?

Les activateurs activent les neurones tout comme nos neurones sont activés à l’aide de stimuli externes. La couche Softmax est l'une des fonctions de la couche de sortie qui déclenche les neurones en cas d'intégration de mots. Dans Word2vec, nous avons des options telles que le softmax hiérarchique et l'échantillonnage négatif. À l’aide d’activateurs, on peut convertir la fonction linéaire en fonction non linéaire, et un algorithme d’apprentissage automatique complexe peut être implémenté à l’aide de ceux-ci.

Ce tutoriel concerne Word2vec, nous nous en tiendrons donc au sujet actuel.

Comment implémenter Word2vec à l'aide de Gensim

Jusqu'à présent, nous avons discuté de ce qu'est Word2vec, de ses différentes architectures, de la raison pour laquelle il y a un passage d'un sac de mots à Word2vec, de la relation entre Word2vec et NLTK avec du code en direct et des fonctions d'activation.

Vous trouverez ci-dessous la méthode étape par étape pour implémenter Word2vec à l'aide de Gensim :

Étape 1) Collecte de données

La première étape pour mettre en œuvre tout modèle d'apprentissage automatique ou mettre en œuvre le traitement du langage naturel est la collecte de données.

Veuillez observer les données pour créer un chatbot intelligent, comme indiqué dans l'exemple Gensim Word2vec ci-dessous.

[{"tag": "welcome",
"patterns": ["Hi", "How are you", "Is any one to talk?", "Hello", "hi are you available"],
"responses": ["Hello, thanks for contacting us", "Good to see you here"," Hi there, how may I assist you?"]

        },
{"tag": "goodbye",
"patterns": ["Bye", "See you later", "Goodbye", "I will come back soon"],
"responses": ["See you later, thanks for visiting", "have a great day ahead", "Wish you Come back again soon."]
        },

{"tag": "thankful",
"patterns": ["Thanks for helping me", "Thank your guidance", "That's helpful and kind from you"],
"responses": ["Happy to help!", "Any time!", "My pleasure", "It is my duty to help you"]
        },
        {"tag": "hoursopening",
"patterns": ["What hours are you open?", "Tell your opening time?", "When are you open?", "Just your timing please"],
"responses": ["We're open every day 8am-7pm", "Our office hours are 8am-7pm every day", "We open office at 8 am and close at 7 pm"]
        },

{"tag": "payments",
"patterns": ["Can I pay using credit card?", " Can I pay using Mastercard?", " Can I pay using cash only?" ],
"responses": ["We accept VISA, Mastercard and credit card", "We accept credit card, debit cards and cash. Please don’t worry"]
        }
   ]

Voici ce que nous comprenons des données

• Ces données contiennent trois éléments : balise, modèle et réponses. La balise est l'intention (quel est le sujet de discussion).
• Les données sont au format JSON.
• Un modèle est une question que les utilisateurs poseront au bot
• Les réponses sont la réponse que le chatbot fournira à la question/modèle correspondant.

Étape 2) Prétraitement des données

Il est très important de traiter les données brutes. Si des données nettoyées sont transmises à la machine, le modèle répondra avec plus de précision et apprendra les données plus efficacement.

Cette étape consiste à supprimer les mots vides, les radicaux, les mots inutiles, etc. Avant de continuer, il est important de charger les données et de les convertir en bloc de données. Veuillez consulter le code ci-dessous pour cela

import json
json_file =’intents.json'
with open('intents.json','r') as f:
    data = json.load(f)

Explication du code :

1. Comme les données sont au format json, json est donc importé
2. Le fichier est stocké dans la variable
3. Le fichier est ouvert et chargé dans la variable de données

Les données sont maintenant importées et il est temps de convertir les données en bloc de données. Veuillez consulter le code ci-dessous pour voir l'étape suivante

import pandas as pd
df = pd.DataFrame(data)
df['patterns'] = df['patterns'].apply(', '.join) 

Explication du code :

1. Les données sont converties en bloc de données à l'aide des pandas importés ci-dessus.

2. Il convertira la liste des modèles de colonnes en chaîne.

from nltk.corpus import stopwords
from textblob import Word
stop = stopwords.words('english')
df['patterns'] = df['patterns'].apply(lambda x:' '.join(x.lower() for x in x.split()))
df['patterns't']= df['patterns''].apply(lambda x: ' '.join(x for x in x.split() if x not in string.punctuation)
df['patterns']= df['patterns'].str.replace('[^\w\s]','')
df['patterns']= df['patterns'].apply(lambda x: ' '.join(x for x in x.split() if  not x.isdigit()))
df['patterns'] = df['patterns'].apply(lambda x:' '.join(x for x in x.split() if not x in stop))
df['patterns'] = df['patterns'].apply(lambda x: " ".join([Word(word).lemmatize() for word in x.split()]))

Explication du code :

1. Les mots vides anglais sont importés à l'aide du module de mots vides de la boîte à outils nltk

2. Tous les mots du texte sont convertis en minuscules en utilisant la condition et la fonction lambda. Fonction Lambda est une fonction anonyme.

3. Toutes les lignes du texte du bloc de données sont vérifiées pour les chaînes de ponctuation et celles-ci sont filtrées.

4. Les caractères tels que les chiffres ou les points sont supprimés à l'aide d'une expression régulière.

5. DigiLes ts sont supprimés du texte.

6. Les mots vides sont supprimés à ce stade.

7. Les mots sont désormais filtrés et les différentes formes du même mot sont supprimées à l'aide de la lemmatisation. Avec ceux-ci, nous avons terminé le prétraitement des données.

Sortie :

, patterns, responses, tag
0,hi one talk hello hi available,"['Hello, thanks for contacting us', 'Good to see you here', ' Hi there, how may I assist you?']",welcome
1,bye see later goodbye come back soon,"['See you later, thanks for visiting', 'have a great day ahead', 'Wish you Come back again soon.']",goodbye
2,thanks helping thank guidance thats helpful kind,"['Happy to help!', 'Any time!', 'My pleasure', 'It is my duty to help you']",thankful
3,hour open tell opening time open timing please,"[""We're open every day 8am-7pm"", 'Our office hours are 8am-7pm every day', 'We open office at 8 am and close at 7 pm']",hoursopening
4,pay using credit card pay using mastercard pay using cash,"['We accept VISA, Mastercard and credit card', 'We accept credit card, debit cards and cash. Please don’t worry']",payments

Étape 3) Création d'un réseau neuronal à l'aide de Word2vec

Il est maintenant temps de créer un modèle à l'aide du module Gensim Word2vec. Nous devons importer Word2vec depuis Gensim. Faisons cela, puis nous construirons et dans la dernière étape nous vérifierons le modèle sur des données en temps réel.

from gensim.models import Word2Vec

Maintenant, dans ce didacticiel Gensim Word2vec, nous pouvons réussir à créer le modèle à l'aide de Word2Vec. Veuillez vous référer à la ligne de code suivante pour savoir comment créer le modèle à l'aide de Word2Vec. Le texte est fourni au modèle sous la forme d'une liste, nous allons donc convertir le texte du bloc de données en liste à l'aide du code ci-dessous.

Bigger_list=[]
for i in df['patterns']
     li = list(i.split(""))
     Bigger_list.append(li)	
Model= Word2Vec(Bigger_list,min_count=1,size=300,workers=4)

Explication du code :

1. Création de la plus grande_list où la liste interne est ajoutée. C'est le format qui alimente le modèle Word2Vec.

2. La boucle est implémentée et chaque entrée de la colonne de modèles de la trame de données est itérée.

3. Chaque élément des modèles de colonnes est divisé et stocké dans la liste interne li

4. La liste interne est ajoutée à la liste externe.

5. Cette liste est fournie au modèle Word2Vec. Comprenons certains des paramètres fournis ici

Min_count : Il ignorera tous les mots dont la fréquence totale est inférieure à celle-ci.

Taille: Il indique la dimensionnalité des vecteurs de mots.

Travailleurs: Ce sont les fils de discussion pour entraîner le modèle

Il existe également d'autres options disponibles, dont certaines importantes sont expliquées ci-dessous.

Fenêtre: Distance maximale entre le mot actuel et le mot prédit dans une phrase.

Sg : Il s'agit d'un algorithme d'entraînement et 1 pour skip-gram et 0 pour un sac continu de mots. Nous en avons discuté en détail ci-dessus.

HS : Si la valeur est 1, alors nous utilisons le softmax hiérarchique pour la formation et si 0, alors un échantillonnage négatif est utilisé.

Alpha: Taux d'apprentissage initial

Affichons le code final ci-dessous :

#list of libraries used by the code
import string
from gensim.models import Word2Vec
import logging
from nltk.corpus import stopwords
from textblob import Word
import json
import pandas as pd
#data in json format
json_file = 'intents.json'
with open('intents.json','r') as f:
    data = json.load(f)
#displaying the list of stopwords
stop = stopwords.words('english')
#dataframe
df = pd.DataFrame(data)

df['patterns'] = df['patterns'].apply(', '.join)
# print(df['patterns'])
#print(df['patterns'])
#cleaning the data using the NLP approach
print(df)
df['patterns'] = df['patterns'].apply(lambda x:' '.join(x.lower() for x in x.split()))
df['patterns']= df['patterns'].apply(lambda x: ' '.join(x for x in x.split() if x not in string.punctuation))
df['patterns']= df['patterns'].str.replace('[^\w\s]','')
df['patterns']= df['patterns'].apply(lambda x: ' '.join(x for x in x.split() if  not x.isdigit()))
df['patterns'] = df['patterns'].apply(lambda x:' '.join(x for x in x.split() if not x in stop))
df['patterns'] = df['patterns'].apply(lambda x: " ".join([Word(word).lemmatize() for word in x.split()]))
#taking the outer list
bigger_list=[]
for i in df['patterns']:
    li = list(i.split(" "))
    bigger_list.append(li)
#structure of data to be taken by the model.word2vec
print("Data format for the overall list:",bigger_list)
#custom data is fed to machine for further processing
model = Word2Vec(bigger_list, min_count=1,size=300,workers=4)
#print(model)

Étape 4) Sauvegarde du modèle

Le modèle peut être enregistré sous forme de bac et de modèle. Bin est le format binaire. Veuillez consulter les lignes ci-dessous pour enregistrer le modèle

model.save("word2vec.model")
model.save("model.bin")

Explication du code ci-dessus

1. Le modèle est enregistré sous la forme d'un fichier .model.

2. le modèle est enregistré sous forme de fichier .bin

Nous utiliserons ce modèle pour effectuer des tests en temps réel tels que les mots similaires, les mots différents et les mots les plus courants.

Étape 5) Chargement du modèle et réalisation de tests en temps réel

Le modèle est chargé à l'aide du code ci-dessous :

model = Word2Vec.load('model.bin')

Si vous souhaitez imprimer le vocabulaire, utilisez la commande ci-dessous :

vocab = list(model.wv.vocab)

Veuillez voir le résultat :

['see', 'thank', 'back', 'thanks', 'soon', 'open', 'mastercard', 'card', 'time', 'pay', 'talk', 'cash', 'one', 'please', 'goodbye', 'thats', 'helpful', 'hour', 'credit', 'hi', 'later', 'guidance', 'opening', 'timing', 'hello', 'helping', 'bye', 'tell', 'come', 'using', 'kind', 'available']

Étape 6) Vérification des mots les plus similaires

Mettons les choses en pratique :

similar_words = model.most_similar('thanks')	
print(similar_words)	

Veuillez voir le résultat :

[('kind', 0.16104359924793243), ('using', 0.1352398842573166), ('come', 0.11500970274209976), ('later', 0.09989878535270691), ('helping', 0.04855936020612717), ('credit', 0.04659383371472359), ('pay', 0.0329081267118454), ('thank', 0.02484947443008423), ('hour', 0.0202352125197649), ('opening', 0.018177658319473267)]

Étape 7) Le mot ne correspond pas aux mots fournis

dissimlar_words = model.doesnt_match('See you later, thanks for visiting'.split())
print(dissimlar_words)

Nous avons fourni les mots « À plus tard, merci de votre visite ». Ce sera imprimez les mots les plus différents de ces mots. Exécutons ce code et trouvons le résultat

Le résultat après exécution du code ci-dessus :

Thanks

Étape 8) Trouver la similitude entre deux mots

Cela indiquera le résultat de la probabilité de similitude entre deux mots. Veuillez consulter le code ci-dessous pour savoir comment exécuter cette section.

similarity_two_words = model.similarity('please','see')
print("Please provide the similarity between these two words:")
print(similarity_two_words)

Le résultat du code ci-dessus est le suivant

0.13706

Vous pouvez également trouver des mots similaires en exécutant le code ci-dessous

similar = model.similar_by_word('kind')
print(similar)

Sortie du code ci-dessus :

[('credit', 0.11764447391033173), ('cash', 0.11440904438495636), ('one', 0.11151769757270813), ('hour', 0.0944807156920433), ('using', 0.0705675333738327), ('thats', 0.05206916481256485), ('later', 0.04502468928694725), ('bye', 0.03960943967103958), ('back', 0.03837274760007858), ('thank', 0.0380823090672493)] 

Pour aller plus loin

• L'intégration de mots est un type de représentation de mots qui permet aux mots ayant une signification similaire d'être compris par des algorithmes d'apprentissage automatique.
• L'incorporation de mots est utilisée pour calculer des mots similaires, créer un groupe de mots apparentés, une fonctionnalité de classification de texte, un regroupement de documents, un traitement du langage naturel.
• Word2vec a expliqué : Word2vec est un modèle de réseau neuronal peu profond à deux couches pour produire des intégrations de mots pour une meilleure représentation des mots.
• Word2vec représente les mots dans une représentation spatiale vectorielle. Les mots sont représentés sous forme de vecteurs et le placement est effectué de telle manière que les mots de sens similaire apparaissent ensemble et que les mots différents sont situés au loin.
• L'algorithme Word2vec utilise 2 architectures Sac de mots continu (CBOW) et sauter gramme
• CBOW est plusieurs fois plus rapide que skip gram et offre une meilleure fréquence pour les mots fréquents, tandis que skip gram nécessite une petite quantité de données d'entraînement et représente même des mots ou des phrases rares.
• NLTK et Word2vec peuvent être utilisés ensemble pour créer des applications puissantes
• La fonction d'activation du neurone définit la sortie de ce neurone à partir d'un ensemble d'entrées. Dans Word2vec. Softmax Layer (fonction exponentielle normalisée) est la fonction de couche de sortie qui active ou déclenche chaque nœud. Word2vec propose également un échantillonnage négatif
• Gensim est une boîte à outils de modélisation de sujets implémentée en python