1. Introduction
Dernière mise à jour:08/04/2024
Embedding textuel
La représentation vectorielle continue de texte fait référence au processus de transformation de données textuelles en représentations numériques. Ces représentations numériques, souvent des vecteurs, captent 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.
La représentation vectorielle continue de texte traduit ce langage dans un format mathématique plus simple que les ordinateurs peuvent comprendre et manipuler.
Avantages de l'intégration 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éliore les performances du machine learning: les représentations vectorielles continues de textes 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 la modélisation des sujets.
Cas d'utilisation des représentations vectorielles continues de texte
En transformant du texte en représentations numériques, les représentations vectorielles continues de textes permettent d'accéder à de nombreuses applications de 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:
La comparaison des représentations vectorielles continues de deux éléments de texte peut vous aider à identifier les cas de plagiat potentiel en identifiant des similitudes significatives dans leur structure sémantique.
Il ne s'agit là que de quelques exemples, et les possibilités continuent de croître à mesure que les techniques de représentation vectorielle continue de texte évoluent. À mesure que les ordinateurs apprennent mieux le langage grâce aux représentations vectorielles continues, nous pouvons nous attendre à des applications encore plus innovantes.
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
- Effectuer une requête sur notre base de données de vecteur simulée en comparant les vecteurs et obtenir la réponse la plus probable.
Points abordés
- Utiliser l'intégration de texte dans GCP
- Comment 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 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, consultez cette page.
- Dans la console Google Cloud, accédez à la page "Instances" accessible depuis le menu Vertex AI, dans la 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 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 la section "Notebook" de Jupyterlab, depuis le lanceur d'applications, cliquez sur l'icône Python3 avec le logo Python.
- Un notebook Jupyter est créé. Il porte 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
Afin de tester notre code, nous allons créer une base de données composée de texte et de vecteurs correspondants traduits à l'aide du modèle de représentation vectorielle continue de texte 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 3 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
Il doit se présenter comme suit:
Analysons le code
Dans les variables DOCUMENT1, DOCUMENT2 et DOCUMENT3, nous stockons un dictionnaire qui va émuler des documents avec leurs titres et leurs contenus. Ces "documents" font référence à un manuel simulé d'une voiture Google.
Dans la ligne suivante, nous créons une liste à partir de ces trois documents (dictionnaires).
documents = [DOCUMENT1, DOCUMENT2, DOCUMENT3]
Enfin, en exploitant 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 permettant d'effectuer la représentation vectorielle continue. 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 intitulé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 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 normal et renvoyer son vecteur à l'aide du modèle gecko@003, nous initialisons le modèle de variable. C'est là que 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 nouvelle colonne dans la trame de données appelée Embedded text (Texte intégré) et celle-ci contiendra la liste des vecteurs créés à partir 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 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 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 initialisons 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 est dans ce cas le modèle gecko@003.
model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
Dans la variable de représentations vectorielles continues, 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 comme 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. Nous pouvons maintenant comparer le vecteur de la question à tous les vecteurs de notre base de données afin de déterminer lequel est le plus proche pour répondre plus précisément à 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 exploiter la fonction Numpy pour y parvenir.
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 continuer à la mettre à jour jusqu'à ce que nous trouvions la distance réelle 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 effectuons une itération 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 sur la liste du vecteur tenant 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'])
Une fois l'exécution terminée, vous obtenez un résultat semblable à celui-ci :
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 découvert les bases des représentations vectorielles continues de textes et appris à utiliser le modèle gecko003 sur GCP Workbench.
Vous connaissez maintenant les principales étapes à suivre pour continuer à appliquer vos connaissances à d'autres cas d'utilisation.
Et ensuite ?
Découvrez quelques-uns des ateliers de programmation...