Régler les représentations vectorielles continues de texte

Cette page explique comment régler les modèles de représentation vectorielle continue de texte textembedding-gecko et textembedding-gecko-multilingual. Ces modèles de fondation ont été entraînés sur un grand nombre de données textuelles publiques. Si vous disposez d'un cas d'utilisation unique nécessitant vos propres données d'entraînement spécifiques, vous pouvez utiliser le réglage de modèle. Une fois que vous avez réglé un modèle de représentation vectorielle continue de base, celui-ci doit être adapté à votre cas d'utilisation. Le réglage est compatible avec les versions stables du modèle de représentation vectorielle continue de texte.

Les modèles de représentation vectorielle continue de texte sont compatibles avec le réglage supervisé. Le réglage supervisé utilise des exemples étiquetés qui illustrent le type de sortie que vous souhaitez obtenir de votre modèle de représentation vectorielle continue de texte lors de l'inférence. Les modèles de représentation vectorielle continue de texte ne sont pas compatibles avec l'apprentissage automatique par renforcement qui utilise le feedback humain (RLHF).

Pour en savoir plus sur le réglage des modèles, consultez la page Fonctionnement du réglage de modèles.

Amélioration de la qualité attendue

Vertex Generative AI utilise une méthode de réglage efficace des paramètres pour la personnalisation. Cette méthodologie montre des gains de qualité significatifs allant jusqu'à 41 % (12 % en moyenne) lors de tests effectués sur des ensembles de données comparatifs de récupération publique.

Cas d'utilisation pour le réglage d'un modèle de représentation vectorielle continue

Le réglage d'un modèle de représentation vectorielle continue de texte peut permettre à votre modèle de s'adapter aux représentations vectorielles continues d'un domaine ou d'une tâche spécifique. Cela peut être utile si le modèle de représentation vectorielle continue pré-entraînée n'est pas adapté à vos besoins spécifiques. Par exemple, vous pouvez affiner un modèle de représentation vectorielle continue sur un ensemble de données spécifique aux demandes d'assistance client de votre entreprise. Cela peut aider un chatbot à comprendre les différents types de problèmes que vos clients rencontrent généralement dans le service client, et à répondre à leurs questions plus efficacement. Sans réglage, le modèle ne peut pas connaître les spécificités de vos demandes d'assistance client ni les solutions aux problèmes spécifiques liés à votre produit.

Workflow de réglage

Le workflow de réglage de modèle pour textembedding-gecko et textembedding-gecko-multilingual sur Vertex Generative AI est le suivant :

  • Préparer l'ensemble de données de réglage du modèle
  • Importer l'ensemble de données de réglage du modèle dans un bucket Cloud Storage
  • Configurer votre projet pour Vertex AI Pipelines.
  • Créer un job de réglage pour un modèle
  • Déployez le modèle réglé sur un point de terminaison Vertex Generative AI du même nom. Contrairement aux jobs de réglage de modèle de texte ou Codey, un job de réglage de représentation vectorielle continue de texte ne déploie pas vos modèles réglés sur un point de terminaison Vertex Generative AI.

Préparer l'ensemble de données de représentations vectorielles continues

L'ensemble de données permettant de régler un modèle de représentations vectorielles continues inclut des données correspondant à la tâche que le modèle doit effectuer.

Format d'ensemble de données pour le réglage d'un modèle de représentations vectorielles continues

L'ensemble de données d'entraînement comprend les fichiers suivants, qui doivent se trouver dans Cloud Storage. Le chemin d'accès aux fichiers est défini par des paramètres lors du lancement du pipeline de réglage. Les trois types de fichiers sont le fichier corpus, le fichier de requête et les étiquettes. Seules les étiquettes d'entraînement sont nécessaires, mais vous pouvez également fournir des étiquettes de validation et de test pour mieux contrôler.

  • Fichier Corpus : le chemin d'accès est défini par le paramètre corpus_path. Il s'agit d'un fichier JSONL dans lequel chaque ligne contient les champs _id, title et text avec des valeurs de chaîne. _id et text sont obligatoires, tandis que title est facultatif. Voici un exemple de fichier corpus.jsonl :

    {"_id": "doc1", "title": "Get an introduction to generative AI on Vertex AI", "text": "Vertex AI's Generative AI Studio offers a Google Cloud console tool for rapidly prototyping and testing generative AI models. Learn how you can use Generative AI Studio to test models using prompt samples, design and save prompts, tune a foundation model, and convert between speech and text."}
{"_id": "doc2", "title": "Use gen AI for summarization, classification, and extraction", "text": "Learn how to create text prompts for handling any number of tasks with Vertex AI's generative AI support. Some of the most common tasks are classification, summarization, and extraction. Vertex AI's PaLM API for text lets you design prompts with flexibility in terms of their structure and format."}
{"_id": "doc3", "title": "Custom ML training overview and documentation", "text": "Get an overview of the custom training workflow in Vertex AI, the benefits of custom training, and the various training options that are available. This page also details every step involved in the ML training workflow from preparing data to predictions."}
{"_id": "doc4", "text": "Text embeddings are useful for clustering, information retrieval, retrieval-augmented generation (RAG), and more."}
{"_id": "doc5", "title": "Text embedding tuning", "text": "Google's text embedding models can be tuned on Vertex AI."}

  • Fichier de requête : le fichier de requête contient vos exemples de requêtes. Le chemin d'accès est défini par le paramètre queries_path. Le fichier de requête est au format JSONL et contient les mêmes champs que le fichier Corpus. Voici un exemple de fichier queries.jsonl :

    {"_id": "query1", "text": "Does Vertex support generative AI?"}
{"_id": "query2", "text": "What can I do with Vertex GenAI offerings?"}
{"_id": "query3", "text": "How do I train my models using Vertex?"}
{"_id": "query4", "text": "What is a text embedding?"}
{"_id": "query5", "text": "Can text embedding models be tuned on Vertex?"}
{"_id": "query6", "text": "embeddings"}
{"_id": "query7", "text": "embeddings for rag"}
{"_id": "query8", "text": "custom model training"}
{"_id": "query9", "text": "Google Cloud PaLM API"}

  • Étiquettes d'entraînement : le chemin d'accès est défini par le paramètre train_label_path. Le paramètre train_label_path est l'URI Cloud Storage de l'emplacement des données des libellés d'entraînement. Il est spécifié lorsque vous créez la tâche de réglage. Les libellés doivent être un fichier TSV avec un en-tête. Un sous-ensemble des requêtes et du corpus doit être inclus dans votre fichier d'étiquettes d'entraînement. Le fichier doit contenir les colonnes query-id, corpus-id et score. query-id est une chaîne qui correspond à la clé _id du fichier de requête, corpus-id est une chaîne correspondant à _id dans le fichier Corpus. Score est une valeur entière non négative. Tout score supérieur à zéro indique que le document est lié à la requête. Plus le nombre est élevé, plus le niveau de pertinence est élevé. Si le score est omis, la valeur par défaut est 1. Voici un exemple de fichier train_labels.tsv :

    query-id  corpus-id   score
query1    doc1    1
query2    doc2    1
query3    doc3    2
query3    doc5  1
query4    doc4  1
query4    doc5  1
query5    doc5  2
query6    doc4  1
query6    doc5  1
query7    doc4  1
query8    doc3  1
query9    doc2  1

  • Étiquettes de test: facultatives. Les étiquettes de test ont le même format que les étiquettes d'entraînement et sont spécifiées par le paramètre test_label_path. Si aucun test_label_path n'est fourni, les étiquettes de test seront fractionnées automatiquement à partir des étiquettes d'entraînement.

  • Étiquettes de validation: facultatives. Les étiquettes de validation ont le même format que les étiquettes d'entraînement et sont spécifiées par le paramètre validation_label_path. Si aucun validation_label_path n'est fourni, les étiquettes de validation seront fractionnées automatiquement à partir des étiquettes d'entraînement.

Exigences concernant la taille de l'ensemble de données

Les fichiers d'ensemble de données fournis doivent respecter les contraintes suivantes :

  • Le nombre de requêtes doit être compris entre 9 et 40 000.

  • Le nombre de documents du corpus doit être compris entre 9 et 500 000.

  • Chaque fichier d'étiquette d'ensemble de données doit inclure au moins trois ID de requête, et les divisions d'ensembles de données doivent inclure au moins neuf ID de requête.

  • Le nombre total d'étiquettes doit être inférieur à 500 000.

Configurer votre projet pour Vertex AI Pipelines

Le réglage est exécuté dans votre projet à l'aide de la plate-forme Vertex AI Pipelines.

Configurer des autorisations

Le pipeline exécute le code d'entraînement sous deux agents de service. Ces agents de service doivent disposer de rôles spécifiques pour commencer l'entraînement à l'aide de votre projet et de votre ensemble de données.

Compte de service Compute Engine par défaut
PROJECT_NUMBER-compute@developer.gserviceaccount.com

Ce compte de service nécessite:

  • Storage Object Viewer a accès à chaque fichier d'ensemble de données que vous avez créé dans Cloud Storage.

  • Storage Object User a accès au répertoire Cloud Storage de sortie de votre pipeline, PIPELINE_OUTPUT_DIRECTORY.

  • Vertex AI User a accès à votre projet.

Au lieu du compte de service Compute Engine par défaut, vous pouvez spécifier un compte de service personnalisé. Pour en savoir plus, consultez la page Configurer un compte de service avec des autorisations précises.

Agent de service de réglage de Vertex Generative AI
service-PROJECT_NUMBER@gcp-sa-aiplatform-ft.iam.gserviceaccount.com

Ce compte de service nécessite:

  • Storage Object Viewer a accès à chaque fichier d'ensemble de données que vous avez créé dans Cloud Storage.

  • Storage Object User a accès au répertoire Cloud Storage de sortie de votre pipeline, PIPELINE_OUTPUT_DIRECTORY.

Pour en savoir plus sur la configuration des autorisations de l'ensemble de données Cloud Storage, consultez la page Configurer un bucket Cloud Storage pour les artefacts de pipeline.

Utiliser des accélérateurs

Le réglage nécessite des accélérateurs de GPU. L'un des accélérateurs suivants peut être utilisé pour le pipeline de réglage de représentations vectorielles continues de texte :

  • NVIDIA_L4

  • NVIDIA_TESLA_A100

  • NVIDIA_TESLA_T4

  • NVIDIA_TESLA_V100

  • NVIDIA_TESLA_P100

Le lancement d'un job de réglage nécessite un quota Restricted image training GPUs suffisant pour le type d'accélérateur et la région que vous avez sélectionnés, par exemple Restricted image training Nvidia V100 GPUs per region. Pour augmenter le quota de votre projet, consultez la page Demander un quota supplémentaire.

Certains accélérateurs ne sont pas disponibles dans toutes les régions. Pour en savoir plus, consultez la page Utiliser des accélérateurs dans Vertex Generative AI.

Créer un job de réglage de modèle de représentation vectorielle continue

Vous pouvez créer un job de réglage d'un modèle de représentation vectorielle continue à l'aide de la console Google Cloud ou de l'API REST.

REST

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

  • DISPLAY_NAME : nom à afficher pour le pipelineJob.
  • PIPELINE_OUTPUT_DIRECTORY : chemin d'accès aux artefacts de sortie du pipeline, commençant par "gs://".
  • PROJECT_ID : ID de votre projet Google Cloud.
  • LOCATION : région du projet Google Cloud dans laquelle exécuter le pipeline. Le réglage est possible dans toutes les régions où votre projet dispose d'un quota de GPU suffisant. Pour en savoir plus, consultez la page Utiliser des accélérateurs. Étant donné que les ressources de diffusion peuvent être limitées dans d'autres régions, il est recommandé d'utiliser us-central1.
  • QUERIES_PATH : URI du bucket Cloud Storage stockant les données de requête, commençant par "gs://".
  • CORPUS_PATH : URI Cloud Storage pour les données du corpus, commençant par "gs://".
  • TRAIN_LABEL_PATH : URI Cloud Storage de l'emplacement des données des étiquettes d'entraînement, commençant par "gs://".
  • TEST_LABEL_PATH : facultatif. URI Cloud Storage de l'emplacement des données des étiquettes de test, commençant par "gs://". Si vous transmettez une chaîne vide, le pipeline va scinder automatiquement l'ensemble de données de test à partir de l'ensemble de données d'entraînement.
  • VALIDATION_LABEL_PATH : facultatif. URI Cloud Storage de l'emplacement des données de l'étiquette de validation, commençant par "gs://". Si vous transmettez une chaîne vide, le pipeline va scinder automatiquement l'ensemble de données de validation à partir de l'ensemble de données d'entraînement.
  • ACCELERATOR_TYPE : facultatif. Type d'accélérateur à utiliser pour l'entraînement. La valeur par défaut est NVIDIA_TESLA_V100. Pour connaître les valeurs possibles, consultez la page Utiliser des accélérateurs.
  • ACCELERATOR_COUNT : facultatif. Nombre d'accélérateurs à utiliser lors de l'entraînement. L'utilisation d'un plus grand nombre d'accélérateurs peut accélérer l'entraînement, mais n'a aucun effet sur la qualité. La valeur par défaut est 4.
  • MACHINE_TYPE : facultatif. Type de machine à utiliser pour l'entraînement. La valeur par défaut est n1-standard-16. Pour en savoir plus sur la sélection du type de machine correspondant au type d'accélérateur et au nombre sélectionné, consultez la page Plates-formes de GPU.
  • BASE_MODEL_VERSION_ID : facultatif. Utilisez cette option pour spécifier le modèle de représentation vectorielle continue de texte à régler. La valeur par défaut est textembedding-gecko@001. Pour connaître les valeurs possibles, consultez les versions stables.
  • MODEL_DISPLAY_NAME : facultatif. Nom à afficher du modèle réglé lorsqu'il apparaît dans Model Registry. La valeur par défaut est "tuned-text-embedding-model".
  • TASK_TYPE : facultatif. La définition de ce paramètre optimise le modèle réglé pour une tâche en aval spécifique. La valeur par défaut est DEFAULT. Pour en savoir plus, consultez l'article Obtenir des représentations vectorielles continues de texte.
  • BATCH_SIZE : facultatif. Taille du lot d'entraînement. La valeur par défaut est 128.
  • TRAIN_STEPS : facultatif. Nombre d'étapes du réglage du modèle. La valeur par défaut est 1 000 et doit être supérieure à 30.
  • OUTPUT_DIMENSIONALITY : facultatif. Entier compris entre 1 et 768. Cela détermine la dimensionnalité de sortie (taille du vecteur) du modèle réglé. Une valeur de -1 indique que la taille de représentation vectorielle continue du modèle de base sera utilisée. Compatible uniquement avec les modèles text-embedding-004 et text-multilingual-embedding-002.
  • LR_MULTIPLIER : facultatif. Multiplicateur à appliquer au taux d'apprentissage pendant l'entraînement. La valeur par défaut est 1.0, ce qui correspond au taux d'apprentissage recommandé.
  • CMEK_KEY_NAME : facultatif. Nom de la clé de chiffrement gérée par le client à utiliser pour écrire toutes les ressources de réglage, telles que le modèle réglé et les données de pipeline de sortie.

Méthode HTTP et URL : 

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/pipelineJobs

Corps JSON de la requête :

{
  "displayName": "DISPLAY_NAME",
  "runtimeConfig": {
    "gcsOutputDirectory": "PIPELINE_OUTPUT_DIRECTORY",
    "parameterValues": {
      "queries_path": "QUERIES_PATH",
      "corpus_path": "CORPUS_PATH",
      "train_label_path": "TRAIN_LABEL_PATH",
      "test_label_path": "TEST_LABEL_PATH",
      "validation_label_path": "VALIDATION_LABEL_PATH",
      "accelerator_type": "ACCELERATOR_TYPE",
      "accelerator_count": "ACCELERATOR_COUNT",
      "machine_type": "MACHINE_TYPE",
      "base_model_version_id": "BASE_MODEL_VERSION_ID",
      "model_display_name": "MODEL_DISPLAY_NAME",
      "task_type": "TASK_TYPE",
      "batch_size": "BATCH_SIZE",
      "train_steps": "TRAIN_STEPS",
      "output_dimensionality": "OUTPUT_DIMENSIONALITY",
      "learning_rate_multiplier": "LR_MULTIPLIER",
      "encryption_spec_key_name": "CMEK_KEY_NAME"
    }
  },
  "templateUri": "https://us-kfp.pkg.dev/ml-pipeline/llm-text-embedding/tune-text-embedding-model/v1.1.3",
  "encryptionSpec": {
    "kmsKeyName": "CMEK_KEY_NAME"
  }
}

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

Après avoir lancé le pipeline, suivez la progression de votre tâche de réglage via la console Google Cloud.

Accéder à Google Cloud Console

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. 

import re

from google.cloud.aiplatform import initializer as aiplatform_init
from vertexai.preview.language_models import TextEmbeddingModel


def tune_embedding_model(
    api_endpoint: str,
    base_model_name: str = "text-embedding-004",
    task_type: str = "DEFAULT",
    queries_path: str = "gs://embedding-customization-pipeline/dataset/queries.jsonl",
    corpus_path: str = "gs://embedding-customization-pipeline/dataset/corpus.jsonl",
    train_label_path: str = "gs://embedding-customization-pipeline/dataset/train.tsv",
    test_label_path: str = "gs://embedding-customization-pipeline/dataset/test.tsv",
    batch_size: int = 128,
    train_steps: int = 1000,
    output_dimensionality: int = 768,
    learning_rate_multiplier: float = 1.0
):  # noqa: ANN201
    match = re.search(r"^(\w+-\w+)", api_endpoint)
    location = match.group(1) if match else "us-central1"
    base_model = TextEmbeddingModel.from_pretrained(base_model_name)
    tuning_job = base_model.tune_model(
        task_type=task_type,
        corpus_data=corpus_path,
        queries_data=queries_path,
        training_data=train_label_path,
        test_data=test_label_path,
        batch_size=batch_size,
        train_steps=train_steps,
        tuned_model_location=location,
        output_dimensionality=output_dimensionality,
        learning_rate_multiplier=learning_rate_multiplier,
    )
    return tuning_job

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 com.google.cloud.aiplatform.v1.CreatePipelineJobRequest;
import com.google.cloud.aiplatform.v1.LocationName;
import com.google.cloud.aiplatform.v1.PipelineJob;
import com.google.cloud.aiplatform.v1.PipelineJob.RuntimeConfig;
import com.google.cloud.aiplatform.v1.PipelineServiceClient;
import com.google.cloud.aiplatform.v1.PipelineServiceSettings;
import com.google.protobuf.Value;
import java.io.IOException;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class EmbeddingModelTuningSample {
  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running this sample.
    String apiEndpoint = "us-central1-aiplatform.googleapis.com:443";
    String project = "PROJECT";
    String baseModelVersionId = "BASE_MODEL_VERSION_ID";
    String taskType = "DEFAULT";
    String pipelineJobDisplayName = "PIPELINE_JOB_DISPLAY_NAME";
    String outputDir = "OUTPUT_DIR";
    String queriesPath = "QUERIES_PATH";
    String corpusPath = "CORPUS_PATH";
    String trainLabelPath = "TRAIN_LABEL_PATH";
    String testLabelPath = "TEST_LABEL_PATH";
    double learningRateMultiplier = 1.0;
    int outputDimensionality = 768;
    int batchSize = 128;
    int trainSteps = 1000;

    createEmbeddingModelTuningPipelineJob(
        apiEndpoint,
        project,
        baseModelVersionId,
        taskType,
        pipelineJobDisplayName,
        outputDir,
        queriesPath,
        corpusPath,
        trainLabelPath,
        testLabelPath,
        learningRateMultiplier,
        outputDimensionality,
        batchSize,
        trainSteps);
  }

  public static PipelineJob createEmbeddingModelTuningPipelineJob(
      String apiEndpoint,
      String project,
      String baseModelVersionId,
      String taskType,
      String pipelineJobDisplayName,
      String outputDir,
      String queriesPath,
      String corpusPath,
      String trainLabelPath,
      String testLabelPath,
      double learningRateMultiplier,
      int outputDimensionality,
      int batchSize,
      int trainSteps)
      throws IOException {
    Matcher matcher = Pattern.compile("^(?<Location>\\w+-\\w+)").matcher(apiEndpoint);
    String location = matcher.matches() ? matcher.group("Location") : "us-central1";
    String templateUri =
        "https://us-kfp.pkg.dev/ml-pipeline/llm-text-embedding/tune-text-embedding-model/v1.1.3";
    PipelineServiceSettings settings =
        PipelineServiceSettings.newBuilder().setEndpoint(apiEndpoint).build();
    try (PipelineServiceClient client = PipelineServiceClient.create(settings)) {
      Map<String, Value> parameterValues =
          Map.of(
              "base_model_version_id", valueOf(baseModelVersionId),
              "task_type", valueOf(taskType),
              "queries_path", valueOf(queriesPath),
              "corpus_path", valueOf(corpusPath),
              "train_label_path", valueOf(trainLabelPath),
              "test_label_path", valueOf(testLabelPath),
              "learning_rate_multiplier", valueOf(learningRateMultiplier),
              "output_dimensionality", valueOf(outputDimensionality),
              "batch_size", valueOf(batchSize),
              "train_steps", valueOf(trainSteps));
      PipelineJob pipelineJob =
          PipelineJob.newBuilder()
              .setTemplateUri(templateUri)
              .setDisplayName(pipelineJobDisplayName)
              .setRuntimeConfig(
                  RuntimeConfig.newBuilder()
                      .setGcsOutputDirectory(outputDir)
                      .putAllParameterValues(parameterValues)
                      .build())
              .build();
      CreatePipelineJobRequest request =
          CreatePipelineJobRequest.newBuilder()
              .setParent(LocationName.of(project, location).toString())
              .setPipelineJob(pipelineJob)
              .build();
      return client.createPipelineJob(request);
    }
  }

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

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

  private static Value valueOf(double 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(
  apiEndpoint,
  project,
  outputDir,
  pipelineJobDisplayName = 'embedding-customization-pipeline-sample',
  baseModelVersionId = 'text-embedding-004',
  taskType = 'DEFAULT',
  queriesPath = 'gs://embedding-customization-pipeline/dataset/queries.jsonl',
  corpusPath = 'gs://embedding-customization-pipeline/dataset/corpus.jsonl',
  trainLabelPath = 'gs://embedding-customization-pipeline/dataset/train.tsv',
  testLabelPath = 'gs://embedding-customization-pipeline/dataset/test.tsv',
  outputDimensionality = 768,
  learningRateMultiplier = 1.0,
  batchSize = 128,
  trainSteps = 1000
) {
  const aiplatform = require('@google-cloud/aiplatform');
  const {PipelineServiceClient} = aiplatform.v1;
  const {helpers} = aiplatform; // helps construct protobuf.Value objects.

  const client = new PipelineServiceClient({apiEndpoint});
  const match = apiEndpoint.match(/(?<L>\w+-\w+)/);
  const location = match ? match.groups.L : 'us-central1';
  const parent = `projects/${project}/locations/${location}`;
  const params = {
    base_model_version_id: baseModelVersionId,
    task_type: taskType,
    queries_path: queriesPath,
    corpus_path: corpusPath,
    train_label_path: trainLabelPath,
    test_label_path: testLabelPath,
    batch_size: batchSize,
    train_steps: trainSteps,
    output_dimensionality: outputDimensionality,
    learning_rate_multiplier: learningRateMultiplier,
  };
  const runtimeConfig = {
    gcsOutputDirectory: outputDir,
    parameterValues: Object.fromEntries(
      Object.entries(params).map(([k, v]) => [k, helpers.toValue(v)])
    ),
  };
  const pipelineJob = {
    templateUri:
      'https://us-kfp.pkg.dev/ml-pipeline/llm-text-embedding/tune-text-embedding-model/v1.1.3',
    displayName: pipelineJobDisplayName,
    runtimeConfig,
  };
  async function createTuneJob() {
    const [response] = await client.createPipelineJob({parent, pipelineJob});
    console.log(`job_name: ${response.name}`);
    console.log(`job_state: ${response.state}`);
  }

  await createTuneJob();
}

Console

Pour régler un modèle de représentation vectorielle continue de texte à l'aide de la console Google Cloud, vous pouvez lancer un pipeline de personnalisation en procédant comme suit :

  1. Dans la section "Vertex AI" de la console Google Cloud, accédez à la page Vertex AI Pipelines.

    Accéder à Vertex AI Pipelines

  2. Cliquez sur Créer une exécution pour ouvrir le volet Créer une exécution de pipeline.
  3. Cliquez sur Sélectionner un pipeline existant et saisissez les informations suivantes :
    1. Sélectionnez "ml-pipeline" dans la liste déroulante Sélectionner une ressource.
    2. Sélectionnez "llm-text-embedding" dans la liste déroulante Dépôt.
    3. Sélectionnez "tune-text-embedding-model" dans la liste déroulante Pipeline ou composant.
    4. Sélectionnez la version "v1.1.3" dans le menu déroulant Version.
  4. Spécifiez un nom d'exécution pour identifier cette exécution de pipeline de manière unique.
  5. Dans la liste déroulante Région, sélectionnez la région dans laquelle créer l'exécution de pipeline. Il s'agit de la même région que celle dans laquelle votre modèle réglé est créé.
  6. Cliquez sur Continuer. Le volet Configuration de l'environnement d'exécution s'affiche.
  7. Sous Emplacement Cloud Storage, cliquez sur Parcourir pour sélectionner le bucket Cloud Storage où stocker les artefacts de sortie du pipeline, puis cliquez sur Sélectionner.
  8. Sous Paramètres du pipeline, spécifiez vos paramètres pour le pipeline de réglage. Les trois paramètres requis sont corpus_path, queries_path et train_label_path, et leurs formats sont décrits sur la page Préparer l'ensemble de données de représentations vectorielles continues. Pour en savoir plus sur chaque paramètre, reportez-vous à l'onglet REST de cette section.
  9. Cliquez sur Envoyer pour créer l'exécution de votre pipeline.

Exemple de commande curl

PROJECT_ID=PROJECT_ID
LOCATION=LOCATION
BASE_MODEL_VERSION_ID=BASE_MODEL_VERSION_ID
PIPELINE_OUTPUT_DIRECTORY=PIPELINE_OUTPUT_DIRECTORY
QUERIES_PATH=QUERIES_PATH
CORPUS_PATH=CORPUS_PATH
TRAIN_LABEL_PATH=TRAIN_LABEL_PATH


curl -X POST  \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json; charset=utf-8" \
"https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/pipelineJobs?pipelineJobId=tune-text-embedding-$(date +%Y%m%d%H%M%S)" \
-d '{
  "displayName": "tune-text-embedding-model",
  "runtimeConfig": {
    "gcsOutputDirectory": "'${PIPELINE_OUTPUT_DIRECTORY}'",
    "parameterValues": {
      "base_model_version_id":  "'${BASE_MODEL_VERSION_ID}'",
      "queries_path":  "'${QUERIES_PATH}'",
      "corpus_path":  "'${CORPUS_PATH}'",
      "train_label_path":  "'${TRAIN_LABEL_PATH}'"
    }
  },
  "templateUri": "https://us-kfp.pkg.dev/ml-pipeline/llm-text-embedding/tune-text-embedding-model/v1.1.3",
}'

Utiliser votre modèle réglé

Afficher les modèles réglés dans Model Registry

Une fois le job de réglage terminé, le modèle réglé n'est pas automatiquement déployé sur un point de terminaison. Il sera disponible en tant que ressource de modèle dans Model Registry. Vous pouvez afficher la liste des modèles de votre projet actuel, y compris de vos modèles réglés, à l'aide de la console Google Cloud.

Pour afficher vos modèles réglés dans la console Google Cloud, accédez à la page Registre de modèles de Vertex AI.

Accéder à Vertex AI Model Registry

Déployer le modèle

Une fois que vous avez réglé le modèle de représentation vectorielle continue, vous devez déployer la ressource de modèle. Pour déployer votre modèle de représentation vectorielle continue ajusté, consultez la section Déployer un modèle sur un point de terminaison.

Contrairement aux modèles de fondation, les modèles de représentation vectorielle continue de texte réglés sont gérés par l'utilisateur. Cela inclut la gestion des ressources de diffusion, telles que le type de machine et les accélérateurs. Pour éviter les erreurs liées à une mémoire insuffisante lors de la prédiction, il est recommandé d'utiliser pour le déploiement le type de GPU NVIDIA_TESLA_A100, qui peut accepter des tailles de lot allant jusqu'à 5, quelle que soit la longueur de l'entrée.

De la même manière que pour le modèle de base textembedding-gecko, le modèle réglé accepte jusqu'à 3 072 jetons et peut tronquer les entrées plus longues.

Obtenir des prédictions à partir d'un modèle déployé

Une fois votre modèle réglé déployé, vous pouvez utiliser l'une des commandes suivantes pour envoyer des requêtes au point de terminaison du modèle réglé.

Exemples de commandes curl pour les modèles textembedding-gecko@001 réglés

Pour obtenir des prédictions à partir d'une version réglée de textembedding-gecko@001, utilisez l'exemple de commande curl ci-dessous.

PROJECT_ID=PROJECT_ID
LOCATION=LOCATION
ENDPOINT_URI=https://${LOCATION}-aiplatform.googleapis.com
MODEL_ENDPOINT=TUNED_MODEL_ENDPOINT_ID

curl -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json"  \
    ${ENDPOINT_URI}/v1/projects/${PROJECT_ID}/locations/${LOCATION}/endpoints/${MODEL_ENDPOINT}:predict \
    -d '{
  "instances": [
    {
      "content": "Dining in New York City"
    },
    {
      "content": "Best resorts on the east coast"
    }
  ]
}'

Exemples de commandes curl pour les modèles non textembedding-gecko@001

Les versions réglées d'autres modèles (par exemple, textembedding-gecko@003 et textembedding-gecko-multilingual@001) nécessitent deux entrées supplémentaires : task_type et title. Vous trouverez plus de documentation sur ces paramètres dans la commande curl.

PROJECT_ID=PROJECT_ID
LOCATION=LOCATION
ENDPOINT_URI=https://${LOCATION}-aiplatform.googleapis.com
MODEL_ENDPOINT=TUNED_MODEL_ENDPOINT_ID

curl -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json"  \
    ${ENDPOINT_URI}/v1/projects/${PROJECT_ID}/locations/${LOCATION}/endpoints/${MODEL_ENDPOINT}:predict \
    -d '{
  "instances": [
    {
      "content": "Dining in New York City",
      "task_type": "DEFAULT",
      "title": ""
    },
    {
      "content": "There are many resorts to choose from on the East coast...",
      "task_type": "RETRIEVAL_DOCUMENT",
      "title": "East Coast Resorts"
    }
  ]
}'

Exemple de résultat :

Ce résultat s'applique aux modèles textembedding-gecko et textembedding-gecko-multilingual, quelle que soit la version.

{
 "predictions": [
   [ ... ],
   [ ... ],
   ...
 ],
 "deployedModelId": "...",
 "model": "projects/.../locations/.../models/...",
 "modelDisplayName": "tuned-text-embedding-model",
 "modelVersionId": "1"
}

Étapes suivantes