Représentations vectorielles continues

Les représentations vectorielles continues de texte (textembedding-gecko) sont le nom du modèle qui accepte les représentations vectorielles continues de texte. Les représentations vectorielles continues de texte sont des techniques de TLN qui convertit des données textuelles en vecteurs numériques pouvant être traités par des algorithmes de machine learning, en particulier des modèles volumineux. Ces représentations vectorielles sont conçues pour capturer la signification sémantique et le contexte des mots qu'elles représentent.

Plusieurs versions sont disponibles pour les représentations vectorielles continues. textembedding-gecko@003 est le dernier modèle stable de représentation vectorielle continue avec la qualité d'IA améliorée, et textembedding-gecko-multilingual@001 est un modèle optimisé pour un large éventail de langues autres que l'anglais.

Pour explorer ce modèle dans la console, consultez la fiche de modèle Représentations vectorielles continues de texte dans Model Garden.
Accéder à Model Garden

Cas d'utilisation

Recherche sémantique : des représentations vectorielles continues de texte peuvent être utilisées pour représenter à la fois la requête de l'utilisateur et l'univers des documents dans un espace vectoriel de grande dimension. Les documents qui sont plus sémantiquement similaires à la requête de l'utilisateur ont une distance plus courte dans l'espace vectoriel et peuvent être classés plus haut dans les résultats de recherche.

Classification de texte : entraînement d'un modèle qui mappe les représentations vectorielles continues de texte aux étiquettes de catégorie appropriées (par exemple, chat ou chien, spam ou non spam). Une fois le modèle entraîné, il peut être utilisé pour classer les nouvelles entrées de texte en une ou plusieurs catégories en fonction de leurs représentations vectorielles continues.

Requête HTTP

POST https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/textembedding-gecko:predict

Versions de modèle

Pour utiliser la dernière version de modèle, spécifiez la valeur en spécifiant le suffixe @latest, par exemple textembedding-gecko@latest.

Pour utiliser une version de modèle stable, indiquez le numéro de version du modèle, par exemple textembedding-gecko@003. Chaque version stable est disponible pendant six mois après la date de disponibilité de la version stable suivante.

Le tableau suivant contient les versions de modèle stable disponibles :

Modèle textembedding-gecko Date de disponibilité Date d'arrêt
textembedding-gecko@003 12 décembre 2021 9 octobre 2024
textembedding-gecko@002 2 novembre 2023 9 octobre 2024
textembedding-gecko-multilingual@001 2 novembre 2023 9 octobre 2024
textembedding-gecko@001 7 juin 2023 9 octobre 2024
text-embedding-preview-0409 09 avril 2024 Être mis à jour vers une version stable.
text-multilingual-embedding-preview-0409 09 avril 2024 Être mis à jour vers une version stable.

Pour en savoir plus, consultez la page Versions et cycle de vie des modèles.

Corps de la requête

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

L'API Embedding PaLM Vertex AI effectue des prédictions en ligne (en temps réel) pour obtenir des représentations vectorielles continues à partir de texte d'entrée.

L'API accepte un maximum de 3 072 jetons d'entrée et génère des représentations vectorielles continues de 768 dimensions. Utilisez les paramètres suivants pour le modèle de représentations vectorielles continues de texte textembedding-gecko. Pour en savoir plus, consultez l'article Présentation des représentations vectorielles continues de texte.

Paramètre Description Valeurs acceptables

content

Texte pour lequel vous souhaitez générer des représentations vectorielles continues. Texte

task_type

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. RETRIEVAL_QUERY, RETRIEVAL_DOCUMENT, SEMANTIC_SIMILARITY, CLASSIFICATION, CLUSTERING, QUESTION_ANSWERING, FACT_VERIFICATION.

title

Titre de la représentation vectorielle continue. Texte

Exemple de requête

REST

Pour tester une invite de texte à l'aide de l'API Vertex AI, envoyez une requête POST au point de terminaison du modèle de l'éditeur.

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.

Méthode HTTP et URL : 

POST https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/textembedding-gecko@003:predict

Corps JSON de la requête : 

{
  "instances": [
    { "content": "TEXT"}
  ],
}

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

curl

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/textembedding-gecko@003:predict"

PowerShell

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/textembedding-gecko@003:predict" | Select-Object -Expand Content

Vous devriez recevoir une réponse JSON semblable à l'exemple de réponse.

Python

Pour savoir comment installer ou mettre à jour le SDK pour Python, consultez la page 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

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 = "textembedding-gecko@003",
) -> 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]
    embeddings = model.get_embeddings(inputs)
    return [embedding.values for embedding in embeddings]

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.

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. 

async function main(
  project,
  model = 'textembedding-gecko@003',
  texts = 'banana bread?;banana muffins?',
  task = 'RETRIEVAL_DOCUMENT',
  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 match = apiEndpoint.match(/(?<Location>\w+-\w+)/);
  const location = match ? match.groups.Location : 'us-centra11';
  const endpoint = `projects/${project}/locations/${location}/publishers/google/models/${model}`;

  async function callPredict() {
    const instances = texts
      .split(';')
      .map(e => helpers.toValue({content: e, taskType: task}));
    const request = {endpoint, instances};
    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();
}

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.

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 static java.util.stream.Collectors.toList;

import com.google.cloud.aiplatform.v1beta1.EndpointName;
import com.google.cloud.aiplatform.v1beta1.PredictRequest;
import com.google.cloud.aiplatform.v1beta1.PredictResponse;
import com.google.cloud.aiplatform.v1beta1.PredictionServiceClient;
import com.google.cloud.aiplatform.v1beta1.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.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 = "textembedding-gecko@003";
    predictTextEmbeddings(
        endpoint,
        project,
        model,
        List.of("banana bread?", "banana muffins?"),
        "RETRIEVAL_DOCUMENT");
  }

  // 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)
      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());
      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();
  }
}

Corps de la réponse

{
  "predictions": [
    {
      "embeddings": {
        "statistics": {
          "truncated": boolean,
          "token_count": integer
        },
        "values": [ number ]
      }
    }
  ]
}
Élément de réponse Description
embeddings Résultat généré à partir du texte d'entrée.
statistics Statistiques calculées à partir du texte d'entrée.
truncated Indique si le texte d'entrée était plus long que le nombre maximal de jetons autorisés et tronqué.
tokenCount Nombre de jetons du texte d'entrée.
values Le champ values contient les vecteurs de représentation vectorielle continue correspondant aux mots du texte d'entrée.

Exemple de réponse

{
  "predictions": [
    {
      "embeddings": {
        "values": [
          0.0058424929156899452,
          0.011848051100969315,
          0.032247550785541534,
          -0.031829461455345154,
          -0.055369812995195389,
          ...
        ],
        "statistics": {
          "token_count": 4,
          "truncated": false
        }
      }
    }
  ]
}