Cette page a été traduite par l'API Cloud Translation.

Obtenir des embeddings de texte

Vous pouvez créer un embedding de texte à l'aide de l'API d'embeddings de texte de Vertex AI. Les embeddings de texte sont des représentations numériques de texte qui capturent les relations entre les mots et les expressions. Les modèles de machine learning, en particulier les modèles d'IA générative, permettent de créer ces embeddings en identifiant des modèles dans des ensembles de données textuels volumineux. Votre application peut utiliser des embeddings de texte pour traiter et produire du langage, et reconnaître des significations complexes et des relations sémantiques spécifiques à votre contenu. Vous interagissez avec les embeddings de texte chaque fois que vous effectuez une recherche Google ou consultez des recommandations de streaming de musique.

Voici quelques cas d'utilisation courants d'embeddings de texte :

Recherche sémantique : recherche du texte classé par similarité sémantique.
Classification : renvoie la classe des éléments dont les attributs de texte sont semblables au texte donné.
Clustering : met en cluster des éléments dont les attributs textuels sont semblables au texte donné.
Détection des anomalies : renvoie les éléments dont les attributs de texte sont moins liés au texte donné.
Interface de conversation : regroupe des groupes de phrases pouvant entraîner des réponses similaires, comme dans un espace d'embedding au niveau de la conversation.

Les embeddings de texte convertissent du texte en tableaux de nombres à virgule flottante, appelés vecteurs. Ces vecteurs sont conçus pour capturer la signification du texte. La longueur du tableau d'embedding est appelée dimensionnalité du vecteur. Par exemple, un passage de texte peut être représenté par un vecteur contenant des centaines de dimensions. Ensuite, en calculant la distance numérique entre les représentations vectorielles de deux éléments de texte, une application peut déterminer la similarité entre les objets.

L'API de représentations vectorielles continues de texte Vertex AI utilise des représentations vectorielles denses : par exemple, text-embedding-gecko utilise des vecteurs de 768 dimensions. Les modèles d'embeddings vectoriels denses utilisent des méthodes d'apprentissage profond semblables à celles des grands modèles de langage. Contrairement aux vecteurs creux, qui ont tendance à mapper directement des mots à des nombres, les vecteurs denses sont conçus pour mieux représenter le sens d'un texte. L'utilisation de représentations vectorielles continues denses dans l'IA générative fait qu'au lieu de rechercher des correspondances directes de mots ou de syntaxe, vous pouvez mieux rechercher des passages correspondant au sens de la requête, même si les passages n'utilisent pas la même langue.

Pour en savoir plus sur les représentations vectorielles continues, consultez Meet AI's multitool: Vector embeddings.
Pour suivre un cours d'initiation au ML sur les représentations vectorielles continues, consultez la section Représentations vectorielles continues.
Pour en savoir plus sur le stockage d'embeddings dans une base de données, consultez la page Découverte et la Présentation de Vector Search.
Pour en savoir plus sur les modèles d'embeddings textuels, consultez Embeddings de texte.

Avant de commencer

Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Activez l'API Vertex AI

Activer l'API

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Activez l'API Vertex AI

Activer l'API

Obtenir des embeddings de texte pour un extrait de texte

Vous pouvez obtenir des représentations vectorielles continues de texte pour un extrait de texte à l'aide de l'API Vertex AI ou du SDK Vertex AI pour Python. Pour chaque requête, vous êtes limité à 250 textes d'entrée dans us-central1. Dans les autres régions, le nombre maximal de textes d'entrée maximal est de 5. Chaque texte d'entrée a une limite de 2 048 jetons. Les entrées plus longues sont tronquées en mode silencieux. Vous pouvez également désactiver la troncature en mode silencieux en définissant autoTruncate sur false.

Ces exemples utilisent le modèle text-embedding-004.

REST

Pour obtenir des représentations vectorielles continues de texte, envoyez une requête POST en spécifiant l'ID de modèle du modèle de diffuseur.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

PROJECT_ID : l'ID de votre projet.
TEXT : texte pour lequel vous souhaitez générer des représentations vectorielles continues. Limite : cinq textes de 2 048 jetons maximum par texte.
AUTO_TRUNCATE : si la valeur est false, le texte dépassant la limite de jetons entraîne l'échec de la requête. La valeur par défaut est true.

Méthode HTTP et URL :

POST https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/text-embedding-004:predict

Corps JSON de la requête :

{
  "instances": [
    { "content": "TEXT"}
  ],
  "parameters": { 
    "autoTruncate": AUTO_TRUNCATE 
  }
}

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/text-embedding-004:predict"

PowerShell

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/text-embedding-004:predict" | Select-Object -Expand Content

Vous devriez recevoir une réponse JSON semblable à la suivante. Notez que values a été tronqué pour économiser de l'espace.

Réponse

{
  "predictions": [
    {
      "embeddings": {
        "statistics": {
          "truncated": false,
          "token_count": 6
        },
        "values": [ ... ]
      }
    }
  ]
}

Exemple de commande curl

MODEL_ID="text-embedding-004"
PROJECT_ID=PROJECT_ID

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/${MODEL_ID}:predict -d \
$'{
  "instances": [
    { "content": "What is life?"}
  ],
}'

Python

Pour savoir comment installer ou mettre à jour le SDK Vertex AI pour Python, consultez la section Installer le SDK Vertex AI pour Python. Pour en savoir plus, consultez la documentation de référence de l'API Python.

from typing import List, Optional

from vertexai.language_models import TextEmbeddingInput, TextEmbeddingModel


def embed_text(
    texts: List[str] = ["banana muffins? ", "banana bread? banana muffins?"],
    task: str = "RETRIEVAL_DOCUMENT",
    model_name: str = "text-embedding-004",
    dimensionality: Optional[int] = 256,
) -> List[List[float]]:
    """Embeds texts with a pre-trained, foundational model."""
    model = TextEmbeddingModel.from_pretrained(model_name)
    inputs = [TextEmbeddingInput(text, task) for text in texts]
    kwargs = dict(output_dimensionality=dimensionality) if dimensionality else {}
    embeddings = model.get_embeddings(inputs, **kwargs)
    return [embedding.values for embedding in embeddings]

Go

Avant d'essayer cet exemple, suivez les instructions de configuration pour Go décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Go.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

import (
	"context"
	"fmt"
	"regexp"

	aiplatform "cloud.google.com/go/aiplatform/apiv1"
	"cloud.google.com/go/aiplatform/apiv1/aiplatformpb"

	"google.golang.org/api/option"
	"google.golang.org/protobuf/types/known/structpb"
)

func embedTexts(
	apiEndpoint, project, model string, texts []string,
	task string, customOutputDimensionality *int) ([][]float32, error) {
	ctx := context.Background()

	client, err := aiplatform.NewPredictionClient(ctx, option.WithEndpoint(apiEndpoint))
	if err != nil {
		return nil, err
	}
	defer client.Close()

	match := regexp.MustCompile(`^(\w+-\w+)`).FindStringSubmatch(apiEndpoint)
	location := "us-central1"
	if match != nil {
		location = match[1]
	}
	endpoint := fmt.Sprintf("projects/%s/locations/%s/publishers/google/models/%s", project, location, model)
	instances := make([]*structpb.Value, len(texts))
	for i, text := range texts {
		instances[i] = structpb.NewStructValue(&structpb.Struct{
			Fields: map[string]*structpb.Value{
				"content":   structpb.NewStringValue(text),
				"task_type": structpb.NewStringValue(task),
			},
		})
	}
	outputDimensionality := structpb.NewNullValue()
	if customOutputDimensionality != nil {
		outputDimensionality = structpb.NewNumberValue(float64(*customOutputDimensionality))
	}
	params := structpb.NewStructValue(&structpb.Struct{
		Fields: map[string]*structpb.Value{"outputDimensionality": outputDimensionality},
	})

	req := &aiplatformpb.PredictRequest{
		Endpoint:   endpoint,
		Instances:  instances,
		Parameters: params,
	}
	resp, err := client.Predict(ctx, req)
	if err != nil {
		return nil, err
	}
	embeddings := make([][]float32, len(resp.Predictions))
	for i, prediction := range resp.Predictions {
		values := prediction.GetStructValue().Fields["embeddings"].GetStructValue().Fields["values"].GetListValue().Values
		embeddings[i] = make([]float32, len(values))
		for j, value := range values {
			embeddings[i][j] = float32(value.GetNumberValue())
		}
	}
	return embeddings, nil
}

Java

Avant d'essayer cet exemple, suivez les instructions de configuration pour Java décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Java.

import static java.util.stream.Collectors.toList;

import com.google.cloud.aiplatform.v1.EndpointName;
import com.google.cloud.aiplatform.v1.PredictRequest;
import com.google.cloud.aiplatform.v1.PredictResponse;
import com.google.cloud.aiplatform.v1.PredictionServiceClient;
import com.google.cloud.aiplatform.v1.PredictionServiceSettings;
import com.google.protobuf.Struct;
import com.google.protobuf.Value;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.OptionalInt;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class PredictTextEmbeddingsSample {
  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // Details about text embedding request structure and supported models are available in:
    // https://cloud.google.com/vertex-ai/docs/generative-ai/embeddings/get-text-embeddings
    String endpoint = "us-central1-aiplatform.googleapis.com:443";
    String project = "YOUR_PROJECT_ID";
    String model = "text-embedding-004";
    predictTextEmbeddings(
        endpoint,
        project,
        model,
        List.of("banana bread?", "banana muffins?"),
        "QUESTION_ANSWERING",
        OptionalInt.of(256));
  }

  // Gets text embeddings from a pretrained, foundational model.
  public static List<List<Float>> predictTextEmbeddings(
      String endpoint,
      String project,
      String model,
      List<String> texts,
      String task,
      OptionalInt outputDimensionality)
      throws IOException {
    PredictionServiceSettings settings =
        PredictionServiceSettings.newBuilder().setEndpoint(endpoint).build();
    Matcher matcher = Pattern.compile("^(?<Location>\\w+-\\w+)").matcher(endpoint);
    String location = matcher.matches() ? matcher.group("Location") : "us-central1";
    EndpointName endpointName =
        EndpointName.ofProjectLocationPublisherModelName(project, location, "google", model);

    // You can use this prediction service client for multiple requests.
    try (PredictionServiceClient client = PredictionServiceClient.create(settings)) {
      PredictRequest.Builder request =
          PredictRequest.newBuilder().setEndpoint(endpointName.toString());
      if (outputDimensionality.isPresent()) {
        request.setParameters(
            Value.newBuilder()
                .setStructValue(
                    Struct.newBuilder()
                        .putFields("outputDimensionality", valueOf(outputDimensionality.getAsInt()))
                        .build()));
      }
      for (int i = 0; i < texts.size(); i++) {
        request.addInstances(
            Value.newBuilder()
                .setStructValue(
                    Struct.newBuilder()
                        .putFields("content", valueOf(texts.get(i)))
                        .putFields("taskType", valueOf(task))
                        .build()));
      }
      PredictResponse response = client.predict(request.build());
      List<List<Float>> floats = new ArrayList<>();
      for (Value prediction : response.getPredictionsList()) {
        Value embeddings = prediction.getStructValue().getFieldsOrThrow("embeddings");
        Value values = embeddings.getStructValue().getFieldsOrThrow("values");
        floats.add(
            values.getListValue().getValuesList().stream()
                .map(Value::getNumberValue)
                .map(Double::floatValue)
                .collect(toList()));
      }
      return floats;
    }
  }

  private static Value valueOf(String s) {
    return Value.newBuilder().setStringValue(s).build();
  }

  private static Value valueOf(int n) {
    return Value.newBuilder().setNumberValue(n).build();
  }
}

Node.js

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Node.js.

async function main(
  project,
  model = 'text-embedding-004',
  texts = 'banana bread?;banana muffins?',
  task = 'QUESTION_ANSWERING',
  outputDimensionality = 0,
  apiEndpoint = 'us-central1-aiplatform.googleapis.com'
) {
  const aiplatform = require('@google-cloud/aiplatform');
  const {PredictionServiceClient} = aiplatform.v1;
  const {helpers} = aiplatform; // helps construct protobuf.Value objects.
  const clientOptions = {apiEndpoint: apiEndpoint};
  const location = 'us-central1';
  const endpoint = `projects/${project}/locations/${location}/publishers/google/models/${model}`;
  const parameters =
    outputDimensionality > 0
      ? helpers.toValue(outputDimensionality)
      : helpers.toValue(256);

  async function callPredict() {
    const instances = texts
      .split(';')
      .map(e => helpers.toValue({content: e, taskType: task}));
    const request = {endpoint, instances, parameters};
    const client = new PredictionServiceClient(clientOptions);
    const [response] = await client.predict(request);
    console.log('Got predict response');
    const predictions = response.predictions;
    for (const prediction of predictions) {
      const embeddings = prediction.structValue.fields.embeddings;
      const values = embeddings.structValue.fields.values.listValue.values;
      console.log('Got prediction: ' + JSON.stringify(values));
    }
  }

  callPredict();
}

Ajouter un embedding à une base de données vectorielles

Une fois que vous avez généré votre embedding, vous pouvez l'ajouter à une base de données vectorielles, telle que Vector Search. Cela permet une récupération à faible latence, ce qui devient essentiel à mesure que la taille de vos données augmente.

Pour en savoir plus sur Vector Search, consultez la page Présentation de Vector Search.

Exemple de cas d'utilisation : développer un chatbot de recommandation de livres

Si vous souhaitez développer un chatbot de recommandation de livres, la première étape consiste à utiliser un réseau de neurones profond (DNN, Deep Neural Network) afin de convertir chaque livre en vecteur d'embedding, chaque vecteur d'embedding représentant un livre. Vous pouvez uniquement utiliser, comme entrée pour le DNN, le titre du livre ou le contenu textuel. Vous pouvez également utiliser les deux, ainsi que d'autres métadonnées décrivant le livre, telles que son genre.

Les représentations vectorielles continues de cet exemple peuvent être composées de milliers de titres de livre avec leur résumé et leur genre, et elles peuvent avoir des représentations de livres tels que Les hauts de Hurlevent d'Emily Brontë et Persuasion de Jane Austen qui s'avèrent très similaires (petite distance entre les représentations numériques). Alors que la représentation numérique du livre Gatsby le magnifique, de F. Scott Fitzgerald, serait plus éloignée, car la période, le genre et le résumé sont moins similaires.

Les entrées constituent la principale influence sur l'orientation de l'espace de représentation vectorielle. Par exemple, si nous n'avons que des entrées de titre de livre, deux livres ayant des titres similaires mais des résumés très différents peuvent être proches les uns des autres. Toutefois, si nous incluons le titre et le résumé, ces mêmes livres sont moins similaires (plus éloignés) dans l'espace d'embedding.

Grâce à l'IA générative, ce chatbot de suggestions de livres peut résumer, suggérer et afficher des livres susceptibles de vous intéresser (ou non) en fonction de votre requête.

Modifications d'API pour les modèles publiés à compter d'août 2023

Lorsque vous utilisez des versions de modèle publiées à partir d'août 2023, y compris text-embedding-004 et textembedding-gecko-multilingual@001, il existe un nouveau paramètre de type de tâche et un titre facultatif (valide uniquement avec task_type=RETRIEVAL_DOCUMENT).

Ces nouveaux paramètres s'appliquent à ces modèles en version preview publique et à tous les modèles stables à venir.

{
  "instances": [
    {
      "task_type": "RETRIEVAL_DOCUMENT",
      "title": "document title",
      "content": "I would like embeddings for this text!"
    },
  ]
}

Le paramètre task_type est défini comme l'application en aval prévue pour aider le modèle à produire des représentations vectorielles continues de meilleure qualité. Il s'agit d'une chaîne qui peut accepter l'une des valeurs suivantes :

`task_type`	Description
`RETRIEVAL_QUERY`	Spécifie que le texte donné est une requête dans un contexte de recherche ou de récupération.
`RETRIEVAL_DOCUMENT`	Spécifie que le texte donné est un document dans un contexte de recherche ou de récupération.
`SEMANTIC_SIMILARITY`	Indique que le texte donné est utilisé pour la similarité textuelle sémantique (STS).
`CLASSIFICATION`	Spécifie que l'embedding est utilisé pour la classification.
`CLUSTERING`	Spécifie que l'embedding est utilisé pour le clustering.
`QUESTION_ANSWERING`	Spécifie que l'embedding de la requête est utilisé pour répondre aux questions. Utilisez RETRIEVAL_DOCUMENT pour le côté du document.
`FACT_VERIFICATION`	Indique que l'embedding de la requête est utilisé pour la vérification des faits.

Étapes suivantes

Pour obtenir des prédictions par lot pour les embeddings, consultez Obtenir des prédictions d'embeddings de texte par lot.
Pour en savoir plus sur les embeddings multimodaux, consultez la page Obtenir des embeddings multimodaux.
Pour régler un embedding, consultez Régler les embeddings textuels.