Obtenir des représentations vectorielles continues de texte

L'API de représentation vectorielle continue de texte Vertex AI vous permet de créer une représentation vectorielle continue de texte à l'aide de l'IA générative de Vertex AI. Les représentations vectorielles continues 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 représentations vectorielles continues en identifiant des modèles dans des ensembles de données textuels volumineux. Votre application peut utiliser des représentations vectorielles continues de texte pour traiter et produire du langage, en reconnaissant des significations complexes et des relations sémantiques spécifiques à votre contenu. Vous interagissez avec les représentations vectorielles continues de texte chaque fois que vous effectuez une recherche Google ou consultez des recommandations de streaming de musique.

Voici quelques cas d'utilisation courants de représentations vectorielles continues 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 de représentation vectorielle continue au niveau de la conversation.

Les représentations vectorielles continues 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 de représentations vectorielles continues 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 de représentation vectorielle continue de vecteur dense utilisent des méthodes de deep learning semblables à celles utilisées par les 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.

Prérequis

Il existe des conditions préalables spécifiques pour créer une représentation vectorielle continue. Pour commencer, consultez le guide de démarrage rapide : Essayer les représentations vectorielles continues de texte.

Utilisez ce Colab pour appeler les nouveaux modèles de représentation vectorielle continue de texte (textembedding-gecko et textembedding-gecko-multilingual).

Notebook Jupyter: appelez les modèles de représentation vectorielle continue de texte à l'aide de Colab ou d'un notebook Jupyter.
Exécuter dans Colab

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 de représentation vectorielle continue, chaque vecteur de représentation vectorielle continue 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 de représentation vectorielle.

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.

Modèles compatibles

Pour savoir quelles versions de modèles stables de représentation vectorielle continue de texte sont disponibles, consultez la page Versions de modèles stables disponibles. Pour connaître les dernières versions de modèles de représentation vectorielle continue de texte disponibles, consultez la section Derniers modèles.

Il est fortement recommandé de spécifier une version de modèle stable (par exemple, text-embedding-004). La dernière version d'un modèle est en version preview et n'est pas en disponibilité générale (DG). Étant donné que la dernière version est en version preview, il n'est pas garanti qu'elle soit prête pour la production.

Il est particulièrement important d'utiliser une version de modèle stable, par exemple text-embedding-004, pour les applications nécessitant des représentations vectorielles continues rétrocompatibles. Si la rétrocompatibilité n'est pas un problème et que vous souhaitez utiliser la dernière version de modèle, vous devez spécifier explicitement @latest. Spécifiez toujours le nom complet du modèle, y compris le numéro de version.

Obtenir des représentations vectorielles continues 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 est limité à 2 000. 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 3 072 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

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

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.

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.

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.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.

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 = '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 une représentation vectorielle continue à une base de données vectorielles

Une fois que vous avez généré votre représentation vectorielle continue, 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.

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 la représentation vectorielle continue est utilisée pour la classification.
CLUSTERING Spécifie que la représentation vectorielle continue est utilisée pour le clustering.
QUESTION_ANSWERING Spécifie que la représentation vectorielle continue de la requête est utilisée pour répondre aux questions. Utilisez RETRIEVAL_DOCUMENT pour le côté du document.
FACT_VERIFICATION Spécifie que la représentation vectorielle continue de la requête est utilisée pour la vérification des faits.

Couverture linguistique des modèles textembedding-gecko-multilingual

Le modèle textembedding-gecko-multilingual@001 a été évalué dans les langues suivantes : Arabic (ar), Bengali (bn), English (en), Spanish (es), German (de), Persian (fa), Finnish (fi), French (fr), Hindi (hi), Indonesian (id), Japanese (ja), Korean (ko), Russian (ru), Swahili (sw), Telugu (te), Thai (th), Yoruba (yo), Chinese (zh).

Voici la liste complète des langues prises en charge : Afrikaans, Albanian, Amharic, Arabic, Armenian, Azerbaijani, Basque, Belarusian, Bengali, Bulgarian, Burmese, Catalan, Cebuano, Chichewa, Chinese, Corsican, Czech, Danish, Dutch, English, Esperanto, Estonian, Filipino, Finnish, French, Galician, Georgian, German, Greek, Gujarati, Haitian Creole, Hausa, Hawaiian, Hebrew, Hindi, Hmong, Hungarian, Icelandic, Igbo, Indonesian, Irish, Italian, Japanese, Javanese, Kannada, Kazakh, Khmer, Korean, Kurdish, Kyrgyz, Lao, Latin, Latvian, Lithuanian, Luxembourgish, Macedonian, Malagasy, Malay, Malayalam, Maltese, Maori, Marathi, Mongolian, Nepali, Norwegian, Pashto, Persian, Polish, Portuguese, Punjabi, Romanian, Russian, Samoan, Scottish Gaelic, Serbian, Shona, Sindhi, Sinhala, Slovak, Slovenian, Somali, Sotho, Spanish, Sundanese, Swahili, Swedish, Tajik, Tamil, Telugu, Thai, Turkish, Ukrainian, Urdu, Uzbek, Vietnamese, Welsh, West Frisian, Xhosa, Yiddish, Yoruba, Zulu.

Étapes suivantes