1. Introduction
Dernière mise à jour : 2024-04-08
Embedding textuel
L'embedding textuel est le processus de transformation de données textuelles en représentations numériques. Ces représentations numériques, souvent des vecteurs, capturent la signification sémantique et les relations entre les mots d'un texte. Imaginez-le comme ceci :
Le texte est comme un langage complexe, plein de nuances et d'ambiguïtés.
L'embedding textuel traduit ce langage dans un format mathématique plus simple que les ordinateurs peuvent comprendre et manipuler.
Avantages de l'embedding textuel
- Traitement efficace : les représentations numériques sont beaucoup plus rapides à traiter pour les ordinateurs que le texte brut. Ceci est essentiel pour les tâches telles que les moteurs de recherche, les systèmes de recommandation et la traduction automatique.
- Capture de la signification sémantique : les embeddings vont au-delà de la signification littérale des mots. Ils capturent le contexte et les relations entre les mots, ce qui permet une analyse plus nuancée.
- Amélioration des performances du machine learning : les embeddings textuels peuvent être utilisés comme caractéristiques dans les modèles de machine learning, ce qui améliore les performances dans des tâches telles que l'analyse des sentiments, la classification de texte et la modélisation de sujets.
Cas d'utilisation de l'embedding textuel
En transformant le texte en représentations numériques, les embeddings textuels ouvrent la voie à diverses applications dans le domaine du traitement du langage naturel (TLN). Voici quelques cas d'utilisation clés :
1. Moteurs de recherche et récupération d'informations :
Les embeddings textuels permettent aux moteurs de recherche de comprendre la signification sémantique des requêtes et de les faire correspondre à des documents pertinents, même si les mots clés exacts ne sont pas présents.
En comparant les embeddings d'une requête de recherche avec les embeddings de documents, les moteurs de recherche peuvent identifier les documents qui traitent de sujets ou de concepts similaires.
2. Systèmes de recommandation :
Les systèmes de recommandation utilisent des embeddings textuels pour analyser le comportement et les préférences des utilisateurs exprimés dans les avis, les notes ou l'historique de navigation.
Le système peut ensuite recommander des articles similaires en comparant les embeddings des produits, des articles ou d'autres contenus avec lesquels l'utilisateur a interagi.
3. Détection du plagiat :
La comparaison des embeddings de deux textes peut aider à identifier un plagiat potentiel en détectant des similitudes importantes dans leur structure sémantique.
Ce ne sont là que quelques exemples, et les possibilités ne cessent de croître à mesure que les techniques d'embedding textuel évoluent. À mesure que les ordinateurs comprennent mieux le langage grâce aux embeddings, nous pouvons nous attendre à des applications encore plus innovantes à l'avenir.
textembedding-gecko@003
Textembedding-gecko@003 est une version spécifique d'un modèle d'embedding textuel pré-entraîné proposé par Google Cloud Platform (GCP) via Vertex AI et sa suite d'outils et de services d'IA.
Objectifs de l'atelier
Dans cet atelier de programmation, vous allez créer un script Python. Ce script permet de :
- Utiliser l'API Vertex pour appeler textembedding-gecko@003 et transformer du texte en embeddings textuels (vecteurs)
- Créer une base de données simulée composée de texte et de ses vecteurs
- Effectuer une requête dans notre base de données vectorielle simulée en comparant les vecteurs et obtenir la réponse la plus probable
Points abordés
- Utiliser l'embedding textuel dans GCP
- Appeler textembedding-gecko@003
- Exécuter cette opération dans Workbench
- Utiliser Vertex AI Workbench pour exécuter des scripts
Prérequis
- Une version récente de Chrome
- Connaissances sur Python
- Un projet Google Cloud
- Accès à Vertex AI Workbench
2. Configuration
Créer une instance Vertex AI Workbench
- Dans la console Google Cloud, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.
- Accéder au sélecteur de projet
- Vérifiez que la facturation est activée pour votre projet Google Cloud.
- Activez l'API Notebooks.
Vous pouvez créer une instance Vertex AI Workbench à l'aide de la console Google Cloud, de gcloud CLI ou de Terraform. Pour les besoins de ce tutoriel, nous allons la créer à l'aide de la console Google Cloud. Pour en savoir plus sur les autres méthodes, cliquez ici.
- Dans la console Google Cloud, accédez à la page "Instances" accessible dans le menu Vertex AI, section "Notebooks", puis cliquez sur "Workbench".
- Accédez à "Instances".
- Cliquez sur "Créer".
- Dans la boîte de dialogue "Créer une instance", dans la section "Détails", fournissez les informations suivantes pour la nouvelle instance :
Nom : donnez un nom à la nouvelle instance. Le nom doit commencer par une lettre suivie de 1 à 62 caractères (lettres minuscules, chiffres ou traits d'union). Il ne peut pas se terminer par un trait d'union.
Région et zone : sélectionnez une région et une zone pour la nouvelle instance. Pour obtenir les meilleures performances réseau, sélectionnez la région la plus proche de vous géographiquement.
Inutile d'installer un GPU
Dans la section "Mise en réseau", indiquez les éléments suivants :
Mise en réseau : ajustez les options réseau pour utiliser un réseau dans votre projet actuel ou un réseau VPC partagé d'un projet hôte, le cas échéant. Si vous utilisez un VPC partagé dans le projet hôte, vous devez également accorder le rôle d'utilisateur de réseau de Compute (roles/compute.networkUser) à l'agent de service Notebooks à partir du projet de service.
Dans le champ "Réseau" : sélectionnez le réseau de votre choix. Vous pouvez sélectionner un réseau VPC, à condition que l'accès privé à Google soit activé sur ce réseau, ou que le réseau puisse accéder à Internet.
Dans le champ "Sous-réseau" : sélectionnez le sous-réseau de votre choix. Vous pouvez choisir celui par défaut.
Dans les propriétés de l'instance, vous pouvez laisser la valeur par défaut, à savoir e2-standard-4.
- Cliquez sur "Créer".
Vertex AI Workbench crée une instance et la démarre automatiquement. Lorsque l'instance est prête à l'emploi, Vertex AI Workbench active automatiquement un lien "Ouvrir JupyterLab". Cliquez dessus.
Créer un notebook Python 3
- Dans JupyterLab, à partir du lanceur d'applications, dans la section "Notebook", cliquez sur l'icône avec le logo Python qui indique "Python3".
- Un notebook Jupyter est créé avec le nom "Untitled" et l'extension "ipynb".
- Vous pouvez le renommer à l'aide de la section de l'explorateur de fichiers sur la gauche ou le laisser tel quel.
Nous pouvons maintenant commencer à placer notre code dans le notebook.
3. Importer les bibliothèques requises
Une fois l'instance créée et JupyterLab ouvert, nous devons installer toutes les bibliothèques requises pour notre atelier de programmation.
Nous aurons besoin des éléments suivants :
- numpy
- pandas
- TextEmbeddingInput, TextEmbeddingModel from vertexai.language_models
Copiez et collez le code ci-dessous dans une cellule :
from vertexai.language_models import TextEmbeddingInput, TextEmbeddingModel
import numpy as np
import pandas as pd
Celle-ci se présente alors sous la forme suivante :
4. Créer une base de données vectorielle simulée
Pour tester notre code, nous allons créer une base de données composée de texte et de leurs vecteurs respectifs traduits à l'aide du modèle d'embedding textuel gecko@003.
L'objectif est que les utilisateurs recherchent un texte, le traduisent en vecteur, le recherchent dans notre base de données et renvoient le résultat le plus approximatif.
Notre base de données vectorielle contiendra trois enregistrements. Voici comment nous allons la créer :
Copiez et collez le code ci-dessous dans une nouvelle cellule.
DOCUMENT1 = {
"title": "Operating the Climate Control System",
"content": "Your Googlecar has a climate control system that allows you to adjust the temperature and airflow in the car. To operate the climate control system, use the buttons and knobs located on the center console. Temperature: The temperature knob controls the temperature inside the car. Turn the knob clockwise to increase the temperature or counterclockwise to decrease the temperature. Airflow: The airflow knob controls the amount of airflow inside the car. Turn the knob clockwise to increase the airflow or counterclockwise to decrease the airflow. Fan speed: The fan speed knob controls the speed of the fan. Turn the knob clockwise to increase the fan speed or counterclockwise to decrease the fan speed. Mode: The mode button allows you to select the desired mode. The available modes are: Auto: The car will automatically adjust the temperature and airflow to maintain a comfortable level. Cool: The car will blow cool air into the car. Heat: The car will blow warm air into the car. Defrost: The car will blow warm air onto the windshield to defrost it."}
DOCUMENT2 = {
"title": "Touchscreen",
"content": "Your Googlecar has a large touchscreen display that provides access to a variety of features, including navigation, entertainment, and climate control. To use the touchscreen display, simply touch the desired icon. For example, you can touch the \"Navigation\" icon to get directions to your destination or touch the \"Music\" icon to play your favorite songs."}
DOCUMENT3 = {
"title": "Shifting Gears",
"content": "Your Googlecar has an automatic transmission. To shift gears, simply move the shift lever to the desired position. Park: This position is used when you are parked. The wheels are locked and the car cannot move. Reverse: This position is used to back up. Neutral: This position is used when you are stopped at a light or in traffic. The car is not in gear and will not move unless you press the gas pedal. Drive: This position is used to drive forward. Low: This position is used for driving in snow or other slippery conditions."}
documents = [DOCUMENT1, DOCUMENT2, DOCUMENT3]
df_initial_db = pd.DataFrame(documents)
df_initial_db.columns = ['Title', 'Text']
df_initial_db
Cela se présente comme suit :
Analysons le code
Dans les variables DOCUMENT1, DOCUMENT2 et DOCUMENT3, nous stockons un dictionnaire qui émule des documents avec leurs titres et leurs contenus. Ces "documents" font référence à un manuel simulé d'une voiture fabriquée par Google.
À la ligne suivante, nous créons une liste à partir de ces trois documents (dictionnaires).
documents = [DOCUMENT1, DOCUMENT2, DOCUMENT3]
Enfin, à l'aide de pandas, nous créons un DataFrame à partir de cette liste, qui sera appelé df_initial_db.
df_initial_db = pd.DataFrame(documents)
df_initial_db.columns = ['Title', 'Text']
df_initial_db
5. Créer des embeddings textuels
Nous allons maintenant obtenir un embedding textuel à l'aide du modèle gecko@003 pour chaque enregistrement de notre base de données de documents simulée.
Copiez et collez le code ci-dessous dans une nouvelle cellule :
def embed_fn(df_input):
list_embedded_values = []
for index, row in df_input.iterrows():
model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
embeddings = model.get_embeddings([(row['Text'])])
list_embedded_values.append(embeddings[0].values)
df_input['Embedded text'] = list_embedded_values
return df_input
df_embedded_values_db = embed_fn(df_initial_db)
df_embedded_values_db
Cela se présente comme suit :
Analysons le code
Nous avons défini une fonction appelée embed_fn qui recevra en entrée un DataFrame pandas contenant le texte à intégrer. La fonction renvoie ensuite le texte encodé sous forme de vecteur.
def embed_fn(df_input):
list_embedded_values = []
for index, row in df_input.iterrows():
model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
embeddings = model.get_embeddings([(row['Text'])])
list_embedded_values.append(embeddings[0].values)
df_input['Embedded text'] = list_embedded_values
return df_input
Dans la liste appelée list_embedded_values, nous allons stocker et ajouter le texte encodé de chaque ligne.
À l'aide de la méthode iterrows de pandas, nous pouvons itérer chaque ligne du DataFrame, en obtenant les valeurs de la colonne "Text" (qui contient les informations manuelles de notre base de données simulée).
Pour envoyer du texte normal et renvoyer son vecteur à l'aide du modèle gecko@003, nous initialisons la variable model dans laquelle nous définissons le modèle à utiliser en appelant la fonction TextEmbeddingModel.from_pretrained.
model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
embeddings = model.get_embeddings([(row['Text'])])
Ensuite, dans la variable embeddings, nous capturons le vecteur du texte que nous envoyons via la fonction model.get_embeddings.
À la fin de la fonction, nous créons une colonne dans le DataFrame appelée "Embedded text" qui contient la liste des vecteurs créés en fonction du modèle gecko@003.
df_input['Embedded text'] = list_embedded_values
return df_input
Enfin, dans la variable df_embedded_values_db, nous capturons le DataFrame contenant nos données d'origine de la base de données simulée, plus une nouvelle colonne contenant la liste des vecteurs pour chaque ligne.
df_embedded_values_db = embed_fn(df_initial_db)
df_embedded_values_db
6. Poser une question à la base de données vectorielle
Maintenant que notre base de données contient du texte et ses vecteurs, nous pouvons poser une question et interroger notre base de données pour trouver une réponse.
Pour cela, copiez et collez le code ci-dessous dans une nouvelle cellule :
question='How do you shift gears in the Google car?'
model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
embeddings = model.get_embeddings([(question)])
text_to_search=embeddings[0].values
len(text_to_search)
Le résultat doit ressembler à ceci :
Analysons le code
Comme pour la fonction de l'étape précédente, nous initialisons d'abord la variable question avec ce que nous avons l'intention de demander à notre base de données.
question='How do you shift gears in the Google car?'
Ensuite, dans la variable model, nous définissons le modèle que nous voulons utiliser via la fonction TextEmbeddingModel.from_pretrained, qui dans ce cas est le modèle gecko@003.
model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
Dans la variable embeddings, nous appelons la fonction model.get_embeddings et transmettons le texte à convertir en vecteur. Dans ce cas, nous transmettons la question à poser.
embeddings = model.get_embeddings([(question)])
Enfin, la variable text_to_search contient la liste des vecteurs traduits à partir de la question.
Nous imprimons la longueur du vecteur à titre de référence.
text_to_search=embeddings[0].values
len(text_to_search)
7. Comparer des vecteurs
Nous disposons maintenant d'une liste de vecteurs dans notre base de données simulée et d'une question transformée en vecteur. Nous pouvons donc comparer le vecteur de la question avec tous les vecteurs de notre base de données pour déterminer celui qui est le plus proche de répondre à notre question plus précisément.
Pour ce faire, nous allons mesurer la distance entre le vecteur de la question et chaque vecteur de la base de données. Il existe plusieurs techniques pour mesurer les distances entre les vecteurs. Pour cet atelier de programmation spécifique, nous allons utiliser la distance euclidienne ou la norme L2.
En Python, nous pouvons utiliser la fonction numpy pour ce faire.
Copiez et collez le code ci-dessous dans une nouvelle cellule :
list_embedded_text_from_db = df_embedded_values_db['Embedded text']
shortest_distance=1
for position, embedded_value in enumerate(list_embedded_text_from_db):
distance=np.linalg.norm((np.array(embedded_value) - np.array(text_to_search)), ord = 2)
print(distance)
if distance<shortest_distance:
shortest_distance=distance
shortest_position=position
print(f'The shortest distance is {shortest_distance} and the position of that value is {shortest_position}')
Le résultat doit ressembler à ceci :
Analysons le code
Nous commençons par convertir la colonne contenant le texte intégré ou les vecteurs de notre base de données en liste et la stockons dans list_embedded_text_from_db.
Nous avons également initialisé la variable shortest_distance à 1 afin de la mettre à jour jusqu'à ce que nous trouvions la distance la plus courte.
list_embedded_text_from_db = df_embedded_values_db['Embedded text']
shortest_distance=1
Ensuite, à l'aide d'une boucle for, nous itérons et obtenons la distance entre le vecteur de la question et chaque vecteur de la base de données.
À l'aide de la fonction numpy linalg.norm, nous calculons leur distance.
Si la distance calculée est inférieure à celle de la variable shortest_distance, elle est définie sur cette variable.
Nous capturons ensuite la distance la plus courte ainsi que la position dans la liste où elle a été trouvée. Dans les variables shortest_distance et shortest_position.
for position, embedded_value in enumerate(list_embedded_text_from_db):
distance=np.linalg.norm((np.array(embedded_value) - np.array(text_to_search)), ord = 2)
print(distance)
if distance<shortest_distance:
shortest_distance=distance
shortest_position=position
8. Résultats
En connaissant la position dans la liste du vecteur contenant la distance la plus courte entre la question et la base de données, nous pouvons imprimer les résultats.
Copiez et collez le code ci-dessous dans une nouvelle cellule :
print("Your question was:\n "+question+ " \nAnd our answer is:\n "+
df_embedded_values_db.at[shortest_position, 'Title']+": "+
df_embedded_values_db.at[shortest_position, 'Text'])
Après l'avoir exécuté, vous obtenez quelque chose de semblable à ceci :
9. Félicitations
Félicitations, vous venez de créer votre première application à l'aide du modèle textembedding-gecko@003 dans un cas d'utilisation réel.
Vous avez appris les bases des embeddings textuels et comment utiliser le modèle gecko003 dans GCP Workbench.
Vous connaissez maintenant les étapes clés requises pour continuer à appliquer vos connaissances à d'autres cas d'utilisation.
Et ensuite ?
Découvrez quelques-uns des ateliers de programmation...