Ajustar embeddings de texto

Nesta página, mostramos como ajustar os modelos de embedding de texto como textembedding-gecko e textembedding-gecko-multilingual.

Os modelos de embedding de fundação são pré-treinados em um enorme conjunto de dados de texto, oferecendo uma linha de base forte para muitas tarefas. Para cenários que exigem conhecimento especializado ou desempenho altamente personalizado, o ajuste de modelos permite ajustar a representações de vetor usando seus próprios dados relevantes. O ajuste é compatível Para 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. Essa metodologia mostra ganhos significativos na 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 pode permitir que seu modelo se adapte aos embeddings para um domínio ou tarefa específico. Isso pode ser útil se o modelo de embeddings pré-treinados não for adequado às suas necessidades específicas. Por exemplo, é possível ajustar um modelo de embeddings em um conjunto de dados específico de tíquetes de suporte ao cliente da sua empresa. Isso pode ajudar um bot de chat a entender os diferentes tipos de problemas de suporte que seus clientes costumam ter e a responder às perguntas deles de maneira mais eficaz. Sem o ajuste, o modelo não sabe as especificidades dos tíquetes de suporte ao cliente ou as soluções para problemas específicos do produto.

Fluxo de trabalho de ajuste

O fluxo de trabalho de ajuste de modelos na Vertex AI para textembedding-gecko e textembedding-gecko-multilingual é o seguinte:

  • Prepare o conjunto de dados de ajuste do modelo
  • Faça o upload do conjunto de dados de ajuste do modelo em um bucket do Cloud Storage.
  • Configure seu projeto para o Vertex AI Pipelines.
  • Crie um job de ajuste do modelo
  • Implantar o modelo ajustado em um endpoint da Vertex AI com o mesmo nome Ao contrário dos jobs de ajuste de modelo de texto ou codey, um job de ajuste de embedding de texto não implanta os modelos ajustados em um endpoint da Vertex AI.

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. O caminho dos arquivos é definido por parâmetros ao iniciar o pipeline de ajuste. Os três tipos de arquivo são o arquivo de corpus, o arquivo de consulta e os rótulos. Somente os rótulos de treinamento são necessários, mas também é possível fornecer rótulos de validação e teste para maior controle.

  • Arquivo corp: 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. Veja 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 arquivo de consulta contém suas consultas de exemplo. O caminho é definido pelo parâmetro queries_path. O arquivo de consulta está no formato JSONL e tem os mesmos campos que o arquivo de corpus. Veja 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. Train_label_path é o URI do Cloud Storage para o local dos dados do rótulo de treinamento, especificado na criação do job de ajuste. Os rótulos precisam ser um arquivo TSV com cabeçalho. Um subconjunto das consultas e o corpus precisam ser incluídos no arquivo de rótulos de treinamento. O arquivo precisa ter as colunas query-id, corpus-id e score. O query-id é uma string que corresponde à chave _id do arquivo de consulta, e corpus-id é uma string que corresponde a _id no arquivo de corpus. Score é um valor inteiro não negativo. Se um par de consulta e documento não estiver relacionado, deixe o par de fora do arquivo de rótulos de treinamento ou o inclua com a pontuação zero. Qualquer pontuação maior que zero indica que o documento está relacionado à consulta. Números maiores indicam um nível maior de relevância. Se a pontuação for emitida, o valor padrão será 1. Veja 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: opcionais. Os rótulos de teste têm o mesmo formato dos rótulos de treinamento e são especificados pelo parâmetro test_label_path. Se nenhum test_label_path for fornecido, os rótulos de teste serão divididos automaticamente dos rótulos de treinamento.

  • Rótulos de validação: opcionais. Os rótulos de validação têm o mesmo formato dos rótulos de treinamento e são especificados pelo parâmetro validation_label_path. Se nenhum validation_label_path for fornecido, 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 precisa estar entre 9 e 10.000.
  • O número de documentos no corpus deve estar entre 9 e 500.000.
  • Cada arquivo de rótulo do conjunto de dados precisa incluir pelo menos três IDs de consulta e, em todas as divisões do conjunto de dados, precisa haver pelo menos nove IDs de consulta.
  • O número total de rótulos precisa ser menor que 500.000.

Configurar seu projeto para o Vertex AI Pipelines

O ajuste é executado dentro do 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. Esses agentes de serviço precisam receber papéis específicos para começar o treinamento usando o projeto e o conjunto de dados.

Conta de serviço padrão do Compute Engine
PROJECT_NUMBER-compute@developer.gserviceaccount.com

Essa conta de serviço requer:

  • 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 de usar a conta de serviço padrão do Compute Engine, é possível especificar uma conta de serviço personalizada. Para mais informações, acesse 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 requer:

  • 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. Qualquer um dos aceleradores a seguir pode ser usado 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. Consulte Como usar aceleradores na Vertex AI para mais informações.

Criar um job de ajuste de modelo de embedding

É possível criar um job de ajuste de modelo de incorporação usando o console do 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 pelo 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 do Google 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-004",
    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 essa amostra, siga as instruções de configuração para Java Guia de início rápido da Vertex AI: 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.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

Antes de testar essa amostra, siga as instruções de configuração para Node.js Guia de início rápido da Vertex AI: 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-004',
  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.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

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

  1. Na seção "Vertex AI" do console do Google Cloud, acesse a página do 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 oferece suporte ao VPC Service Controls e pode ser configurado para execução em uma nuvem privada virtual (VPC) transmitindo 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 para 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. Ele estará disponível como um recurso Model no Model Registry. É possível visualizar uma lista de modelos no projeto atual, incluindo os modelos ajustados, usando o console do Google Cloud.

Para visualizar seus modelos ajustados no console do Google Cloud, acesse a página Registro de modelos da Vertex AI.

Acessar o Vertex AI Model Registry

Implantar seu modelo

Depois de ajustar o modelo de embeddings, é 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, os modelos de embedding de texto ajustado são gerenciados pelo usuário. 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, é recomendável 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 emitir solicitações ao endpoint do modelo ajustado.

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

Para receber previsões de uma versão ajustada de textembedding-gecko@001, use o exemplo de comando curl abaixo.

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"
    }
  ]
}'

Exemplos de comandos curl para modelos que não são textembedding-gecko@001

Versões ajustadas de outros modelos (por exemplo, textembedding-gecko@003 e textembedding-gecko-multilingual@001) exigem duas entradas adicionais: task_type e title. Encontre mais documentação sobre esses parâmetros em 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