La Vectorisation en Traitement du Langage Naturel (PNL) : Un Guide Complet
Cet article explore la vectorisation, une technique cruciale en PNL, en détaillant son importance et en présentant un panorama des différentes approches.
Nous avons déjà abordé les concepts fondamentaux du prétraitement et du nettoyage de texte en PNL, ainsi que les bases de la PNL, ses applications et des techniques comme la tokenisation, la normalisation et la standardisation.
Avant d’entrer dans le vif du sujet de la vectorisation, récapitulons ce qu’est la tokenisation et en quoi elle diffère de cette dernière.
Qu’est-ce que la Tokenisation ?
La tokenisation est le processus de segmentation d’une phrase en unités plus petites, appelées tokens ou jetons. Ces jetons facilitent la compréhension et le traitement du texte par les ordinateurs.
Exemple : « Cet article est intéressant »
Jetons : [‘Cet’, ‘article’, ‘est’, ‘intéressant’]
Qu’est-ce que la Vectorisation ?
Comme nous le savons, les algorithmes d’apprentissage automatique fonctionnent avec des données numériques. La vectorisation est le processus de conversion de données textuelles ou catégorielles en représentations numériques, c’est-à-dire en vecteurs. Cette transformation permet d’entraîner les modèles avec plus de précision.
Pourquoi la Vectorisation Est-Elle Nécessaire ?
- La tokenisation et la vectorisation jouent des rôles distincts en PNL. La tokenisation divise les phrases en unités plus petites, tandis que la vectorisation convertit ces unités en un format numérique compréhensible par les modèles informatiques.
- La vectorisation est cruciale, non seulement pour la conversion en format numérique, mais aussi pour la capture de la signification sémantique.
- Elle permet de réduire la dimensionnalité des données, les rendant plus efficaces, ce qui est particulièrement utile avec de grands ensembles de données.
- De nombreux algorithmes d’apprentissage automatique, tels que les réseaux neuronaux, nécessitent des entrées numériques, ce qui rend la vectorisation indispensable.
Différentes techniques de vectorisation existent, que nous allons explorer en détail dans cet article.
Le Sac de Mots (Bag of Words)
Le Sac de Mots simplifie l’analyse de documents ou de phrases en les traitant comme des collections non ordonnées de mots. Cette approche est utile pour la classification de texte, l’analyse de sentiments et la récupération d’informations.
Cette méthode crée un vocabulaire des mots uniques présents dans les données textuelles. Chaque mot est ensuite encodé sous forme de vecteur, basé sur sa fréquence d’apparition dans le texte.
Ces vecteurs sont composés de nombres non négatifs (0, 1, 2, …) représentant la fréquence des mots dans un document donné.
Le processus du Sac de Mots se déroule en trois étapes:
Étape 1: Tokenisation.
Cette étape consiste à diviser le document en jetons individuels.
Exemple : (Phrase : « J’aime le café et j’aime le thé »)
Étape 2: Identification des mots uniques/création du vocabulaire.
Ici, nous constituons une liste de tous les mots uniques dans nos phrases.
[“J’”, “aime”, “le”, “café”, “et”, “thé”]
Étape 3: Comptage des occurrences/création de vecteurs.
À cette étape, on compte le nombre de fois où chaque mot du vocabulaire apparaît et on stocke ces informations dans une matrice éparse, où chaque ligne correspond à un vecteur de phrase et chaque colonne à un mot du vocabulaire.
Importer CountVectorizer
Pour mettre en œuvre le Sac de Mots, nous allons importer `CountVectorizer`.
from sklearn.feature_extraction.text import CountVectorizer
Créer un vecteur
Nous allons maintenant créer notre modèle à l’aide de `CountVectorizer` et l’entraîner sur un exemple de document texte.
# Exemple de documents textuels
documents = [
"Ceci est le premier document.",
"Ce document est le deuxième document.",
"Et ceci est le troisième.",
"Ceci est-il le premier document?",
]
# Créer un CountVectorizer
cv = CountVectorizer()
# Entraîner et Transformer X = cv.fit_transform(documents)
Convertir en un tableau dense
Nous convertissons ici nos représentations en un tableau dense et récupérons les noms de fonctionnalités ou les mots.
# Obtenir les noms de fonctionnalités/mots feature_names = cv.get_feature_names_out() # Convertir en tableau dense X_dense = X.toarray()
Affichons la matrice document-terme et les mots clés.
# Afficher la matrice document-terme (DTM) et les noms de fonctionnalités
print("Matrice Document-Terme (DTM):")
print(X_dense)
print("\nNoms de fonctionnalités:")
print(feature_names)
Matrice Document-Terme (DTM) :
Noms des fonctionnalités :
Comme vous pouvez le constater, les vecteurs sont constitués de nombres non négatifs qui indiquent la fréquence des mots dans chaque document.
Nous avions quatre documents exemples et nous avons identifié neuf mots uniques. Ces mots sont stockés dans notre vocabulaire avec des « noms de fonctionnalités ».
Ensuite, notre modèle Sac de Mots vérifie si chaque mot unique est présent dans chaque document. S’il est présent, la valeur 1 est attribuée, sinon, c’est 0.
Si un mot apparaît plusieurs fois, par exemple deux fois, la valeur correspondante est affectée.
Par exemple, dans le deuxième document, le mot « document » est répété deux fois, donc sa valeur dans la matrice est 2.
Si nous souhaitons utiliser un seul mot comme caractéristique dans le vocabulaire, cela s’appelle une représentation Unigram.
n-grammes = Unigrammes, bigrammes, etc.
De nombreuses bibliothèques, comme Scikit-learn, permettent d’implémenter le Sac de Mots. C’est une méthode simple et utile dans divers contextes.
Le Sac de Mots est rapide, mais il a ses limites :
- Il donne le même poids à tous les mots, quelle que soit leur importance.
- Il se contente de compter la fréquence des mots, ce qui peut biaiser les résultats en faveur des mots très courants qui n’apportent pas beaucoup de sens.
- Les documents longs peuvent générer des vecteurs de grande taille, ce qui peut rendre les comparaisons difficiles et créer une matrice éparse, peu idéale pour des projets PNL complexes.
Pour pallier ces limitations, il existe des approches plus avancées, comme TF-IDF.
TF-IDF
TF-IDF (Term Frequency-Inverse Document Frequency) est une représentation numérique qui évalue l’importance des mots dans un document en fonction de leur fréquence et de leur rareté dans l’ensemble des documents.
Pourquoi Utiliser TF-IDF Plutôt que Bag of Words ?
Contrairement au Sac de Mots qui traite tous les mots de la même manière, TF-IDF accorde de l’importance aux mots en fonction de leur fréquence et de leur unicité. Cela évite que des mots fréquents, mais peu informatifs, ne surpondèrent les mots plus rares, mais plus importants.
TF (Term Frequency) : mesure la fréquence d’un mot dans un document spécifique.
IDF (Inverse Document Frequency) : mesure l’importance d’un mot dans l’ensemble de la collection de documents.
TF = Nombre d’occurrences du mot dans le document / Nombre total de mots dans le document
DF = Nombre de documents contenant le mot w / Nombre total de documents
IDF = log (Nombre total de documents / Nombre de documents contenant le mot w)
IDF est l’inverse du DF, car plus un mot est courant dans tous les documents, moins il est important dans le contexte spécifique d’un document.
Score final TF-IDF : TF-IDF = TF * IDF
TF-IDF permet d’identifier les mots à la fois fréquents dans un document spécifique et rares dans l’ensemble des documents, ce qui peut aider à déterminer le thème principal d’un document.
Par exemple :
Doc1 = « J’aime l’apprentissage automatique »
Doc2 = « J’aime exemple.com »
Nous allons déterminer la matrice TF-IDF pour ces documents.
Commençons par créer un vocabulaire des mots uniques.
Vocabulaire = [« J’ », »aime », »l’apprentissage », »automatique », « exemple.com »]
Calculons TF et IDF pour ces mots :
TF = Nombre d’occurrences du mot dans le document / Nombre total de mots dans le document
TF :
- Pour « J' » = TF pour Doc1 : 1/4 = 0,25 et pour Doc2 : 1/3 ≈ 0,33
- Pour « aime » = TF pour Doc1 : 1/4 = 0,25 et pour Doc2 : 1/3 ≈ 0,33
- Pour « l’apprentissage » = TF pour Doc1 : 1/4 = 0,25 et pour Doc2 : 0/3 ≈ 0
- Pour « automatique » = TF pour Doc1 : 1/4 = 0,25 et pour Doc2 : 0/3 ≈ 0
- Pour « exemple.com » = TF pour Doc1 : 0/4 = 0 et pour Doc2 : 1/3 ≈ 0,33
Calculons maintenant l’IDF.
IDF = log (Nombre total de documents / Nombre de documents contenant le mot w)
IDF :
- Pour « J’ »: IDF = log(2/2) = 0
- Pour « aime » : IDF = log(2/2) = 0
- Pour « l’apprentissage » : IDF = log(2/1) = log(2) ≈ 0,69
- Pour « automatique » : IDF = log(2/1) = log(2) ≈ 0,69
- Pour « exemple.com » : IDF = log(2/1) = log(2) ≈ 0,69
Calculons le score TF-IDF :
- Pour « J' » : TF-IDF pour Doc1 : 0,25 * 0 = 0 et TF-IDF pour Doc2 : 0,33 * 0 = 0
- Pour « aime » : TF-IDF pour Doc1 : 0,25 * 0 = 0 et TF-IDF pour Doc2 : 0,33 * 0 = 0
- Pour « l’apprentissage » : TF-IDF pour Doc1 : 0,25 * 0,69 ≈ 0,17 et TF-IDF pour Doc2 : 0 * 0,69 = 0
- Pour « automatique » : TF-IDF pour Doc1 : 0,25 * 0,69 ≈ 0,17 et TF-IDF pour Doc2 : 0 * 0,69 = 0
- Pour « exemple.com » : TF-IDF pour Doc1 : 0 * 0,69 = 0 et TF-IDF pour Doc2 : 0,33 * 0,69 ≈ 0,23
La matrice TF-IDF ressemble à ceci :
J’ aime l’apprentissage automatique exemple.com
Doc1 0.0 0.0 0.17 0.17 0.0
Doc2 0.0 0.0 0.0 0.0 0.23
Les valeurs de la matrice TF-IDF indiquent l’importance de chaque terme dans chaque document. Des valeurs élevées signalent un terme important, tandis que des valeurs basses indiquent un terme moins important ou moins courant.
TF-IDF est principalement utilisée pour la classification de texte, la création de systèmes de récupération d’information, de chatbots et la synthèse de texte.
Importer TfidfVectorizer
Importons `TfidfVectorizer` depuis scikit-learn.
from sklearn.feature_extraction.text import TfidfVectorizer
Créer un vecteur
Nous allons créer notre modèle TF-IDF en utilisant `TfidfVectorizer`.
# Exemple de documents textuels
text = [
"Ceci est le premier document.",
"Ce document est le deuxième document.",
"Et ceci est le troisième.",
"Ceci est-il le premier document?",
]
# Créer un TfidfVectorizer
cv = TfidfVectorizer()
Créer une matrice TF-IDF
Entraînons notre modèle et convertissons la matrice obtenue en un tableau dense.
# Entraîner et transformer pour créer la matrice TF-IDF X = cv.fit_transform(text)
# Obtenir les noms de fonctionnalités/mots feature_names = cv.get_feature_names_out() # Convertir la matrice TF-IDF en un tableau dense X_dense = X.toarray()
Afficher la matrice TF-IDF et les mots clés.
# Afficher la matrice TF-IDF et les noms de fonctionnalités
print("Matrice TF-IDF:")
print(X_dense)
print("\nNoms de fonctionnalités:")
print(feature_names)
Matrice TF-IDF :
Comme vous le voyez, les nombres décimaux indiquent l’importance des mots dans chaque document.
Vous pouvez également combiner des mots en groupes de 2, 3, 4, etc., en utilisant des n-grammes.
Il existe d’autres paramètres, comme min_df, max_feature, subliner_tf, etc., que nous pouvons inclure.
Jusqu’à présent, nous avons exploré les techniques de base basées sur la fréquence.
Cependant, TF-IDF ne fournit pas de compréhension sémantique ni contextuelle du texte. Explorons des techniques plus avancées qui ont révolutionné le monde de l’intégration de mots et qui sont plus performantes pour capturer le sens sémantique et la compréhension contextuelle.
Word2Vec
Word2Vec est une méthode populaire d’intégration de mots qui permet de capturer les similarités sémantiques et syntaxiques. Développée par Tomas Mikolov et son équipe chez Google en 2013, Word2Vec représente les mots comme des vecteurs continus dans un espace multidimensionnel.
L’objectif de Word2Vec est de représenter les mots de manière à capturer leur signification. Les vecteurs générés sont placés dans un espace vectoriel continu.
Par exemple, les vecteurs de « Chat » et « Chien » seraient plus proches que ceux de « Chat » et « Fille ».
Source : usna.edu
Word2Vec utilise deux architectures de modèles pour générer les intégrations de mots :
CBOW (Continuous Bag of Words) : cette approche tente de prédire un mot en calculant la moyenne de la signification des mots environnants. Le modèle prend une fenêtre de mots autour du mot cible, les transforme en représentations numériques, calcule leur moyenne, et utilise cette moyenne pour prédire le mot cible via un réseau neuronal.
Exemple de cible : « Renard »
Mots de la phrase : « le », « rapide », « marron », « saute », « par-dessus », « le »
Word2Vec
- CBOW prend une fenêtre de taille fixe de mots, par exemple 2 (2 mots à gauche et 2 à droite).
- Les mots sont convertis en intégrations.
- CBOW calcule la moyenne de ces intégrations.
- Le vecteur moyen tente de prédire le mot cible à l’aide d’un réseau neuronal.
Comparons maintenant Skip-gram et CBOW.
Skip-gram : Ce modèle d’intégration de mots fonctionne différemment. Au lieu de prédire le mot cible, il prédit les mots contextuels en fonction du mot cible.
Skip-gram est plus efficace pour capturer les relations sémantiques entre les mots.
Exemple : « Roi – Hommes + Femmes = Reine »
Pour utiliser Word2Vec, vous pouvez soit entraîner votre propre modèle, soit utiliser un modèle pré-entraîné. Nous allons ici utiliser un modèle pré-entraîné.
Importer Gensim
Installez Gensim avec la commande `pip install gensim`.
pip install gensim
Tokeniser la phrase avec `word_tokenize`:
Nous convertissons les phrases en minuscules, puis nous les tokenisons avec `word_tokenize`.
# Importer les librairies nécessaires
from gensim.models import Word2Vec
from nltk.tokenize import word_tokenize
# Phrases exemples
sentences = [
"J'aime thor",
"Hulk est un membre important des Avengers",
"Ironman aide Spiderman",
"Spiderman est un membre populaire des Avengers",
]
# Tokeniser les phrases
tokenized_sentences = [word_tokenize(sentence.lower()) for sentence in sentences]
Entraînons notre modèle :
Nous allons entraîner le modèle sur nos phrases tokenisées. Nous utilisons une fenêtre de 5 dans ce cas, mais cela peut être ajusté selon vos besoins.
# Entraîner un modèle Word2Vec
model = Word2Vec(sentences=tokenized_sentences, vector_size=100, window=5, min_count=1, sg=0)
# Trouver des mots similaires
similar_words = model.wv.most_similar("avengers")
# Afficher les mots similaires
print("Mots similaires à 'avengers':")
for word, score in similar_words:
print(f"{word}: {score}")
Mots similaires à ‘avengers’ :
Voici quelques-uns des mots similaires à « avengers » selon le modèle Word2Vec, avec leurs scores de similarité.
Le modèle calcule un score de similarité (principalement une similarité cosinus) entre les vecteurs de « Avengers » et les vecteurs des autres mots du vocabulaire. Ce score indique à quel point deux mots sont liés dans l’espace vectoriel.
Exemple :
Ici, le mot « aide » a une similarité cosinus de -0,005911458611011982 avec le mot « avengers ». La valeur négative indique que les deux mots sont différents.
Les scores de similarité cosinus varient de -1 à 1 :
- 1 indique que deux vecteurs sont identiques et présentent une similarité positive.
- Les valeurs proches de 1 indiquent une similarité positive élevée.
- Les valeurs proches de 0 indiquent que les vecteurs ne sont pas fortement liés.
- Les valeurs proches de -1 indiquent une forte dissimilitude.
- -1 indique que deux vecteurs sont totalement opposés et présentent une parfaite similarité négative.
Pour une meilleure compréhension des modèles Word2Vec, visitez ce lien. C’est un outil très utile pour voir CBOW et skip-gram en action.
À l’instar de Word2Vec, nous avons GloVe. GloVe peut générer des intégrations nécessitant moins de mémoire que Word2Vec. Découvrons-en plus sur GloVe.
GloVe
Les vecteurs globaux pour la représentation des mots (GloVe) sont une technique similaire à Word2Vec, utilisée pour représenter les mots sous forme de vecteurs dans un espace continu. GloVe reprend le même principe que Word2Vec en produisant des intégrations de mots contextuelles, tout en améliorant les performances de Word2Vec.
Pourquoi Utiliser GloVe ?
Word2Vec est une méthode basée sur une fenêtre et utilise les mots environnants pour comprendre les mots. La signification sémantique du mot cible est donc influencée uniquement par les mots qui l’entourent dans les phrases, ce qui constitue une utilisation inefficace des statistiques.
GloVe, quant à lui, capture à la fois les statistiques globales et locales grâce à l’intégration de mots.
Quand Utiliser GloVe ?
Utilisez GloVe quand vous souhaitez des intégrations de mots qui capturent des relations sémantiques plus larges et une association globale de mots.
GloVe est plus performant que les autres modèles pour la reconnaissance d’entités nommées, les analogies de mots et la similarité entre les mots.
Tout d’abord, installons Gensim :
pip install gensim
Étape 1 : Importer les bibliothèques importantes
# Importer les bibliothèques nécessaires import numpy as np import matplotlib.pyplot as plt from sklearn.manifold import TSNE import gensim.downloader as api
Étape 2 : Importer le modèle GloVe
import gensim.downloader as api
glove_model = api.load('glove-wiki-gigaword-300')
Étape 3 : Récupérer la représentation vectorielle du mot « mignon »
glove_model["cute"]
Vecteur du mot « mignon »
Ces valeurs capturent la signification du mot et ses relations avec d’autres mots. Les valeurs positives indiquent des associations positives avec certains concepts, tandis que les valeurs négatives indiquent des associations négatives avec d’autres concepts.
Dans un modèle GloVe, chaque dimension du vecteur de mot représente un aspect de la signification ou du contexte du mot. Les valeurs positives et négatives de ces dimensions contribuent à la façon dont « mignon » est lié sémantiquement aux autres mots du vocabulaire du modèle.
Les valeurs peuvent varier selon les modèles. Recherchons maintenant les mots similaires au mot « garçon ».
Top 10 des mots similaires qui, selon le modèle, sont les plus proches du mot « garçon » :
# Trouver des mots similaires
glove_model.most_similar("boy")
Top 10 des mots similaires à « garçon »
Comme vous pouvez le constater, le mot le plus similaire à « garçon » est « fille ».
Essayons maintenant de voir avec quelle précision le modèle peut capturer la signification sémantique des mots que nous lui fournissons.
glove_model.most_similar(positive=['boy', 'queen'], negative=['girl'], topn=1)
Le mot le plus pertinent pour « reine »
Notre modèle est capable de trouver une relation parfaite entre les mots.
Définir une liste de vocabulaire :
Essayons maintenant de comprendre la signification sémantique ou la relation entre les mots à l’aide d’un graphique. Définissons la liste des mots que nous souhaitons visualiser.
# Définir la liste des mots que vous souhaitez visualiser vocab = ["boy", "girl", "man", "woman", "king", "queen", "banana", "apple", "mango", "cow", "coconut", "orange", "cat", "dog"]
Créer une matrice d’intégration :
Écrivons le code pour créer la matrice d’intégration.
# Code pour créer la matrice d'intégration
EMBEDDING_DIM = glove_model.vectors.shape[1]
word_index = {word: index for index, word in enumerate(vocab)}
num_words = len(vocab)
embedding_matrix = np.zeros((num_words, EMBEDDING_DIM))
for word, i in word_index.items():
embedding_vector = glove_model[word]
if embedding_vector is not None:
embedding_matrix[i] = embedding_vector
Définir une fonction pour la visualisation t-SNE :
À partir de ce code, nous allons définir la fonction de notre tracé de visualisation.
def tsne_plot(embedding_matrix, words):
tsne_model = TSNE(perplexity=3, n_components=2, init="pca", random_state=42)
coordinates = tsne_model.fit_transform(embedding_matrix)
x, y = coordinates[:, 0], coordinates[:, 1]
plt.figure(figsize=(14, 8))
for i, word in enumerate(words):
plt.scatter(x[i], y[i])
plt.annotate(word,
xy=(x[i], y[i]),
xytext=(2, 2),
textcoords="offset points",
ha="right",
va="bottom")
plt.show()
Visualisons notre graphique :
# Appeler la fonction tsne_plot avec la matrice d'intégration et la liste des mots tsne_plot(embedding_matrix, vocab)
Graphique t-SNE
Comme nous pouvons le constater, des mots tels que « banane », « mangue », « orange », « noix de coco » et « pomme » se trouvent sur le côté gauche du graphique, tandis que « vache », « chien » et « chat » sont regroupés parce qu’ils sont des animaux.
Notre modèle est donc capable d’identifier la signification sémantique et les relations entre les mots.
En modifiant simplement le vocabulaire ou en créant votre modèle à partir de zéro, vous pouvez expérimenter avec différents mots.
Cette matrice d’intégration peut être utilisée comme bon vous semble : pour des tâches de similarité de mots ou intégrée dans la couche d’intégration d’un réseau neuronal.
GloVe s’entraîne sur une matrice de cooccurrence pour en extraire une signification sémantique. Il est basé sur l’idée que les cooccurrences de mots sont une source d’informations importante et que leur utilisation est un moyen efficace d’utiliser les statistiques pour produire des intégrations de mots. C’est ainsi que GloVe intègre des « statistiques globales » dans le résultat final.
Et voilà pour GloVe. Une autre méthode de vectorisation populaire est FastText. Voyons ça de plus près.
FastText
FastText est une bibliothèque open source développée par l’équipe de recherche en intelligence artificielle de Facebook pour la classification de texte et l’analyse de sentiments. FastText fournit des outils pour entraîner des intégrations de mots, qui sont des vecteurs de mots denses, utiles pour capturer la signification sémantique des documents. Il prend en charge la classification multi-étiquettes et multi-classes.
Pourquoi FastText ?
FastText est plus performant que les autres modèles grâce à sa capacité à généraliser à des mots inconnus, ce qui était un manque dans les autres méthodes. FastText fournit des vecteurs de mots pré-entraînés pour plusieurs langues, ce qui est utile dans diverses tâches nécessitant des connaissances préalables sur les mots et leur signification.
FastText et Word2Vec
Comment ça Marche ?
Les autres modèles, comme Word2