Ajustar embeddings de texto

Este guia mostra como ajustar modelos de embedding de texto para melhorar o desempenho em tarefas específicas. Neste guia, abordamos os seguintes tópicos:

Os modelos de embedding de fundação são pré-treinados em um grande conjunto de dados de texto, o que oferece uma linha de base forte para muitas tarefas. Para cenários que exigem conhecimento especializado ou desempenho altamente personalizado, é possível usar o ajuste de modelos para refinar as representações do modelo com seus próprios dados. O ajuste é compatível com as versões estáveis dos modelos textembedding-gecko e textembedding-gecko-multilingual.

Os modelos de embedding de texto são compatíveis com ajustes supervisionados. O ajuste supervisionado usa exemplos rotulados que demonstram o tipo de saída que você quer do modelo de embedding de texto durante a inferência.

Para saber mais sobre o ajuste de modelos, consulte Como o ajuste de modelos funciona.

Melhoria de qualidade esperada

A Vertex AI usa um método de ajuste com eficiência de parâmetros para personalização. Esse método mostra ganhos significativos de qualidade de até 41% (média de 12%) em experimentos realizados em conjuntos de dados de referência de recuperação pública.

Caso de uso para ajustar um modelo de embedding

O ajuste de um modelo de embeddings de texto ajuda a adaptá-lo a um domínio ou tarefa específica. Isso é útil quando o modelo pré-treinado não é adequado às suas necessidades. Por exemplo, ajustar um modelo de incorporação nos tíquetes de suporte ao cliente da sua empresa pode ajudar um chatbot a entender melhor os problemas comuns e responder às perguntas de forma mais eficaz. Sem o ajuste, o modelo não tem conhecimento específico sobre seus tíquetes de suporte e soluções de produtos.

Fluxo de trabalho de ajuste

O fluxo de trabalho de ajuste de modelos na Vertex AI para textembedding-gecko e textembedding-gecko-multilingual envolve as seguintes etapas:

  1. Prepare o conjunto de dados de ajuste do modelo
  2. Faça o upload do conjunto de dados de ajuste do modelo em um bucket do Cloud Storage.
  3. Configure seu projeto para o Vertex AI Pipelines.
  4. Crie um job de ajuste do modelo

Depois que o job de ajuste é concluído, o modelo ajustado é adicionado ao Model Registry. Ao contrário de outros jobs de ajuste de modelo, um job de ajuste de embedding de texto não implanta automaticamente o modelo em um endpoint. É preciso implantar manualmente o modelo ajustado.

Preparar o conjunto de dados de embeddings

O conjunto de dados usado para ajustar um modelo de embeddings inclui dados que se alinham à tarefa que você quer que o modelo execute.

Formato do conjunto de dados para ajustar um modelo de embeddings

O conjunto de dados de treinamento consiste nos arquivos a seguir, que precisam estar no Cloud Storage. Você define o caminho de cada arquivo com um parâmetro ao iniciar o pipeline de ajuste.

  • Arquivo de corpus: o caminho é definido pelo parâmetro corpus_path. É um arquivo JSONL em que cada linha tem os campos _id, title e text com valores de string. _id e text são obrigatórios, enquanto title é opcional. Confira abaixo um exemplo de arquivo corpus.jsonl:

    {"_id": "doc1", "title": "Get an introduction to generative AI on Vertex AI", "text": "Vertex AI Studio offers a Google Cloud console tool for rapidly prototyping and testing generative AI models. Learn how you can use Vertex 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."}

  • Arquivo de consulta: o caminho é definido pelo parâmetro queries_path. O arquivo de consulta contém suas consultas de exemplo, está no formato JSONL e tem os mesmos campos que o arquivo de corpus. Confira abaixo um exemplo de arquivo 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"}

  • Rótulos de treinamento: o caminho é definido pelo parâmetro train_label_path, que é o URI do Cloud Storage para os dados de rótulo de treinamento. Os rótulos precisam estar em um arquivo TSV com um cabeçalho. O arquivo de rótulos de treinamento precisa incluir um subconjunto das consultas e do corpus. O arquivo precisa ter as colunas query-id, corpus-id e score.

    • query-id: uma string que corresponde à chave _id do arquivo de consulta.
    • corpus-id: uma string que corresponde à chave _id no arquivo de corpus.
    • score: um número inteiro não negativo. Uma pontuação maior que zero indica que o documento está relacionado à consulta. Pontuações mais altas indicam maior relevância. Se a pontuação for emitida, o valor padrão será 1. Se um par de consulta e documento não estiver relacionado, deixe o par de fora do arquivo de rótulos ou o inclua com a pontuação zero.

    A seguir, um exemplo de arquivo 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

  • Rótulos de teste (opcional): os rótulos de teste têm o mesmo formato dos rótulos de treinamento. Especifique-os com o parâmetro test_label_path. Se você não fornecer um test_label_path, os rótulos de teste serão divididos automaticamente dos rótulos de treinamento.

  • Rótulos de validação (opcional): têm o mesmo formato dos rótulos de treinamento. Especifique-os com o parâmetro validation_label_path. Se você não fornecer um validation_label_path, os rótulos de validação serão divididos automaticamente dos rótulos de treinamento.

Requisitos de tamanho do conjunto de dados

Os arquivos de conjunto de dados fornecidos precisam atender às seguintes restrições:

  • O número de consultas está entre 9 e 10.000.
  • O número de documentos no corpus está entre 9 e 500.000.
  • Cada arquivo de rótulo do conjunto de dados inclui pelo menos três IDs de consulta e, em todas as divisões do conjunto de dados, há pelo menos nove IDs de consulta.
  • O número total de rótulos é menor que 500.000.

Configurar seu projeto para o Vertex AI Pipelines

Você executa jobs de ajuste no seu projeto usando a plataforma Vertex AI Pipelines.

Como configurar permissões

O pipeline executa o código de treinamento em dois agentes de serviço. Você precisa conceder papéis específicos a esses agentes de serviço para executar o treinamento usando seu projeto e conjunto de dados.

  • Conta de serviço padrão do Compute Engine PROJECT_NUMBER-compute@developer.gserviceaccount.com Essa conta de serviço requer as seguintes permissões:

    • acesso Storage Object Viewer a cada arquivo de conjunto de dados criado no Cloud Storage;
    • acesso Storage Object User ao diretório de saída do Cloud Storage do pipeline, PIPELINE_OUTPUT_DIRECTORY;
    • acesso de Vertex AI User ao seu projeto.

    Em vez da conta de serviço padrão do Compute Engine, é possível especificar uma conta de serviço personalizada. Para mais informações, consulte Configurar uma conta de serviço com permissões granulares.

  • Agente de serviço de ajuste da Vertex AI service-PROJECT_NUMBER@gcp-sa-aiplatform-ft.iam.gserviceaccount.com Essa conta de serviço exige as seguintes permissões:

    • acesso Storage Object Viewer a cada arquivo de conjunto de dados criado no Cloud Storage;
    • acesso Storage Object User ao diretório de saída do Cloud Storage do pipeline, PIPELINE_OUTPUT_DIRECTORY;
    .

Para mais informações sobre a configuração de permissões do conjunto de dados do Cloud Storage, consulte Configurar um bucket do Cloud Storage para artefatos de pipeline.

Como usar aceleradores

O ajuste requer aceleradores de GPU. Você pode usar qualquer um dos aceleradores a seguir para o pipeline de ajuste de embedding de texto:

  • NVIDIA_L4
  • NVIDIA_TESLA_A100
  • NVIDIA_TESLA_T4
  • NVIDIA_TESLA_V100
  • NVIDIA_TESLA_P100

Para iniciar um job de ajuste, é necessário ter uma cota de Restricted image training GPUs adequada para o tipo e a região de acelerador que você selecionou, por exemplo, Restricted image training Nvidia V100 GPUs per region. Para aumentar a cota do seu projeto, consulte Solicitar cota adicional.

Nem todos os aceleradores estão disponíveis em todas as regiões. Para mais informações, consulte Como usar aceleradores na Vertex AI.

Criar um job de ajuste de modelo de embedding

É possível criar um job de ajuste de modelo de incorporação usando o console Google Cloud , a API REST ou as bibliotecas de cliente.

REST

Para criar um job de ajuste de modelo de embedding, use o Método projects.locations.pipelineJobs.create.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • PROJECT_ID: o ID do projeto do Google Cloud .
  • PIPELINE_OUTPUT_DIRECTORY: caminho para os artefatos de saída do pipeline, começando com "gs://".

Método HTTP e URL: 

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

Corpo JSON da solicitação:

{
  "displayName": "tune_text_embeddings_model_sample",
  "runtimeConfig": {
    "gcsOutputDirectory": "PIPELINE_OUTPUT_DIRECTORY",
    "parameterValues": {
      "corpus_path": "gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/corpus.jsonl",
      "queries_path": "gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/queries.jsonl",
      "train_label_path": "gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/train.tsv",
      "test_label_path": "gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/test.tsv",
      "base_model_version_id":"text-embedding-004",
      "task_type": "DEFAULT",
      "batch_size": "128",
      "train_steps": "1000",
      "output_dimensionality": "768",
      "learning_rate_multiplier": "1.0"
    }
  },
  "templateUri": "https://us-kfp.pkg.dev/ml-pipeline/llm-text-embedding/tune-text-embedding-model/v1.1.3"
}

Para enviar a solicitação, expanda uma destas opções:

Você receberá uma resposta JSON semelhante a esta:

Depois de iniciar o pipeline, acompanhe o progresso do job de ajuste no console doGoogle Cloud .

Acessar o console do Google Cloud

Python

Para saber como instalar o SDK da Vertex AI para Python, consulte Instalar o SDK da Vertex AI para Python. Para mais informações, consulte a documentação de referência da API Python. 

import re

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


def tune_embedding_model(
    api_endpoint: str,
    base_model_name: str = "text-embedding-005",
    corpus_path: str = "gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/corpus.jsonl",
    queries_path: str = "gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/queries.jsonl",
    train_label_path: str = "gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/train.tsv",
    test_label_path: str = "gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/test.tsv",
):  # noqa: ANN201
    """Tune an embedding model using the specified parameters.
    Args:
        api_endpoint (str): The API endpoint for the Vertex AI service.
        base_model_name (str): The name of the base model to use for tuning.
        corpus_path (str): GCS URI of the JSONL file containing the corpus data.
        queries_path (str): GCS URI of the JSONL file containing the queries data.
        train_label_path (str): GCS URI of the TSV file containing the training labels.
        test_label_path (str): GCS URI of the TSV file containing the test labels.
    """
    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="DEFAULT",
        corpus_data=corpus_path,
        queries_data=queries_path,
        training_data=train_label_path,
        test_data=test_label_path,
        batch_size=128,  # The batch size to use for training.
        train_steps=1000,  # The number of training steps.
        tuned_model_location=location,
        output_dimensionality=768,  # The dimensionality of the output embeddings.
        learning_rate_multiplier=1.0,  # The multiplier for the learning rate.
    )
    return tuning_job

Java

Antes de testar esse exemplo, siga as instruções de configuração para Java no Guia de início rápido da Vertex AI sobre como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Java.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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.4";
    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

Antes de testar esse exemplo, siga as instruções de configuração para Node.js no Guia de início rápido da Vertex AI sobre como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Node.js.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

async function main(
  apiEndpoint,
  project,
  outputDir,
  pipelineJobDisplayName = 'embedding-customization-pipeline-sample',
  baseModelVersionId = 'text-embedding-005',
  taskType = 'DEFAULT',
  corpusPath = 'gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/corpus.jsonl',
  queriesPath = 'gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/queries.jsonl',
  trainLabelPath = 'gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/train.tsv',
  testLabelPath = 'gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/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.4',
    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

Para ajustar um modelo de incorporação de texto usando o Google Cloud console, inicie um pipeline de personalização seguindo as etapas abaixo:

  1. Na seção "Vertex AI" do console Google Cloud , acesse a página Vertex AI Pipelines.

    Acessar o Vertex AI Pipelines

  2. Clique em Criar execução para abrir o painel Criar execução do pipeline.
  3. Clique em Selecionar pipelines atuais e informe os seguintes detalhes:
    1. Selecione "ml-pipeline" no menu suspenso Selecionar um recurso.
    2. Selecione "llm-text-embedding" no menu suspenso Repository.
    3. Selecione "tune-text-embedding-model" no menu suspenso Pipeline ou componente.
    4. Selecione a versão "v1.1.3" no menu suspenso Versão.
  4. Especifique um Nome de execução para identificar exclusivamente essa execução de pipeline.
  5. Na lista suspensa Região, selecione a região para criar a execução do pipeline, que será a mesma em que o modelo ajustado foi criado.
  6. Clique em Continuar. O painel Configuração do ambiente de execução é exibido.
  7. Em Local do Cloud Storage, clique em Procurar para selecionar o bucket do Cloud Storage para armazenar os artefatos de saída do pipeline e, em seguida, clique em Selecionar.
  8. Em Parâmetros do pipeline, especifique os parâmetros para o pipeline de ajuste. Os três parâmetros obrigatórios são corpus_path, queries_path e train_label_path, com os formatos descritos em Preparar seu conjunto de dados de embeddings. Para informações mais detalhadas sobre cada parâmetro, consulte a guia REST desta seção.
  9. Clique em Enviar para criar a execução do pipeline.

Outros recursos compatíveis

O ajuste de embedding de texto é compatível com o VPC Service Controls. Para executar o job de ajuste em uma nuvem privada virtual (VPC), transmita o parâmetro network ao criar o PipelineJob.

Para usar as CMEK (chaves de criptografia gerenciadas pelo cliente), transmita a chave para o parâmetro de pipeline parameterValues.encryption_spec_key_name e o parâmetro encryptionSpec.kmsKeyName ao criar o PipelineJob.

Usar seu modelo ajustado

Ver modelos ajustados no Model Registry

Quando o job de ajuste é concluído, o modelo ajustado não é implantado automaticamente em um endpoint. O modelo ajustado pode ser encontrado como um recurso "Modelo" no Model Registry. É possível conferir uma lista de modelos no projeto atual, incluindo os modelos ajustados, usando o console Google Cloud .

Para ver seus modelos ajustados no console Google Cloud , acesse a página Vertex AI Model Registry.

Acessar o Vertex AI Model Registry

Implantar seu modelo

Depois de ajustar o modelo de embedding, é preciso implantar o recurso Model. Para implantar o modelo de embeddings ajustado, consulte Implantar um modelo em um endpoint.

Ao contrário dos modelos de fundação, você gerencia os modelos de embedding de texto ajustados. Isso inclui o gerenciamento de recursos de veiculação, como tipo de máquina e aceleradores. Para evitar erros de falta de memória durante a previsão, recomendamos implantar usando o tipo de GPU NVIDIA_TESLA_A100, que aceita tamanhos de lote de até cinco para qualquer comprimento de entrada.

Semelhante ao modelo de base textembedding-gecko, seu modelo ajustado oferece suporte a até 3.072 tokens e pode truncar entradas mais longas.

Receber previsões em um modelo implantado

Depois que o modelo ajustado for implantado, use um dos comandos a seguir para enviar solicitações ao endpoint do modelo ajustado.

Exemplo de comando curl para modelos textembedding-gecko@001 ajustados

Para receber previsões de uma versão ajustada de textembedding-gecko@001, use o seguinte comando 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"
    },
    {
      "content": "Best resorts on the east coast"
    }
  ]
}'

Exemplo de comando curl para outros modelos

Versões ajustadas de outros modelos (por exemplo, textembedding-gecko@003 e textembedding-gecko-multilingual@001) exigem duas entradas adicionais: task_type e title. Para mais informações sobre esses parâmetros, consulte Comando 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"
    }
  ]
}'

Exemplo de saída

Essa saída se aplica aos modelos textembedding-gecko e textembedding-gecko-multilingual, independentemente da versão.

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

A seguir