1. Introduction
Dernière mise à jour:08/04/2024
Embedding textuel
Le plongement textuel désigne le processus de transformation des 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 les choses comme suit:
Le texte est comme une langue complexe, pleine de nuances et d'ambiguïtés.
L'intégration de texte traduit ce langage dans un format mathématique plus simple que les ordinateurs peuvent comprendre et manipuler.
Avantages des représentations vectorielles continues de texte
- Permet un traitement efficace: les ordinateurs traitent les représentations numériques beaucoup plus rapidement que le texte brut. Cela est essentiel pour des tâches telles que les moteurs de recherche, les systèmes de recommandation et la traduction automatique.
- Capture 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 de machine learning: les représentations vectorielles continues de texte peuvent être utilisées 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 le modèle de sujets.
Cas d'utilisation des représentations vectorielles continues de texte
En transformant le texte en représentations numériques, les embeddings de texte ouvrent la voie à de nombreuses applications dans le traitement du langage naturel (TLN). Voici quelques cas d'utilisation clés:
1. Moteurs de recherche et récupération d'informations:
Les représentations vectorielles continues de texte permettent aux moteurs de recherche de comprendre la signification sémantique des requêtes et de les mettre en correspondance avec des documents pertinents, même si les mots clés exacts ne sont pas présents.
En comparant les représentations vectorielles continues d'une requête de recherche aux représentations vectorielles continues des documents, les moteurs de recherche peuvent identifier les documents qui couvrent des sujets ou des concepts similaires.
2. Systèmes de recommandation:
Les systèmes de recommandation utilisent des représentations vectorielles continues de texte pour analyser le comportement et les préférences des utilisateurs exprimés par le biais d'avis, de notes ou de l'historique de navigation.
Le système peut ensuite recommander des éléments similaires en comparant les représentations vectorielles continues des produits, articles ou autres contenus avec lesquels l'utilisateur a interagi.
3. Détection du plagiat:
Comparer les représentations vectorielles continues de deux textes peut aider à identifier un plagiat potentiel en détectant des similitudes significatives dans leur structure sémantique.
Il ne s'agit là que de quelques exemples, et les possibilités ne cessent de croître à mesure que les techniques d'intégration de texte évoluent. À mesure que les ordinateurs comprennent mieux le langage grâce aux représentations vectorielles continues, nous pouvons nous attendre à voir apparaître encore plus d'applications innovantes à l'avenir.
textembedding-gecko@003
Textembedding-gecko@003 est une version spécifique d'un modèle d'encapsulation de texte 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 :
- Utilisez 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
- Effectuez une requête dans notre base de données de vecteurs simulés en comparant les vecteurs et obtenez la réponse la plus probable.
Points abordés
- Utiliser l'embedding de texte dans GCP
- Appeler textembedding-gecko@003
- Exécuter ce code dans Workbench
- Utiliser Vertex AI Workbench pour exécuter des scripts
Prérequis
- Une version récente de Chrome
- Connaissances de 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 le 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 section "Détails" de la boîte de dialogue "Créer une instance", fournissez les informations suivantes pour votre nouvelle instance:
Nom : donnez un nom à la nouvelle instance. Le nom doit commencer par une lettre suivie d'un maximum de 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.
Pas besoin d'installer de 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 Compute (roles/compute.networkUser) à l'agent de service Notebooks à partir du projet de service.
Dans le champ "Network" (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 celle par défaut.
Dans les propriétés de l'instance, vous pouvez conserver 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 un lien "Ouvrir JupyterLab". Cliquez dessus.
Créer un notebook Python 3
- Dans JupyterLab, dans le 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 du navigateur de fichiers sur la gauche ou le laisser tel quel.
Nous pouvons maintenant commencer à mettre 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.
Vous aurez besoin de:
- numpy
- pandas
- TextEmbeddingInput, TextEmbeddingModel de 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 ses vecteurs respectifs traduits à l'aide du modèle d'encapsulation de texte gecko@003.
L'objectif est que les utilisateurs recherchent un texte, le convertissent en vecteur, le recherchent dans notre base de données et obtiennent le résultat le plus proche.
Notre base de données vectorielle contiendra trois enregistrements. Voici comment 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
Elle 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 leur contenu. Ces "documents" font référence à un manuel simulé d'une voiture Google.
Sur la ligne suivante, nous créons une liste à partir de ces trois documents (dictionnaires).
documents = [DOCUMENT1, DOCUMENT2, DOCUMENT3]
Enfin, en utilisant 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 entraînement de texte à l'aide du modèle gecko@003 pour chaque enregistrement de notre base de données simulée de documents.
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
Elle 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 à utiliser pour l'embedding. La fonction renvoie ensuite le texte encodé en tant que 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 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 framedata, 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 standard et renvoyer son vecteur à l'aide du modèle gecko@003, nous initialisons le modèle de variable, où 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 les représentations vectorielles continues variables, 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 la trame de données appelée "Texte intégré", qui contiendra la liste des vecteurs créés sur la base 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, ainsi qu'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 de vecteurs
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 ce faire, 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 devrait ressembler à ceci:
Analysons le code
Comme pour la fonction de l'étape précédente, nous initialiserons d'abord la variable de 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 de modèle, nous définissons le modèle que nous souhaitons 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 à présent d'une liste de vecteurs dans notre base de données simulée et d'une question transformée en vecteur. Autrement dit, nous pouvons maintenant comparer le vecteur de la question à tous les vecteurs de notre base de données pour déterminer celui qui est le plus proche de la réponse à notre question.
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 des vecteurs. Pour cet atelier de programmation spécifique, nous utiliserons 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}')
Voici le résultat attendu :
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 sur 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.
Nous calculons leur distance à l'aide de la fonction numpy linalg.norm.
Si la distance calculée est inférieure à celle de la variable "shortest_distance", la distance calculée est définie sur cette variable.
Nous enregistrons 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
Connaissant la position dans la liste du vecteur qui détient 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'exécution, vous obtiendrez un résultat semblable à celui-ci:
9. Félicitations
Félicitations, vous avez créé votre première application à l'aide du modèle textembedding-gecko@003 dans un cas d'utilisation réel.
Vous avez découvert les principes de base des embeddings de texte et comment utiliser le modèle gecko003 sur GCP Workbench.
Vous connaissez maintenant les étapes clés à suivre pour continuer à appliquer vos connaissances à d'autres cas d'utilisation.
Et ensuite ?
Découvrez quelques-uns des ateliers de programmation...