Ajustar embeddings de texto

Esta página mostra como ajustar modelos de embedding de texto.

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 com os seguintes modelos de embedding de texto:

Clique para expandir os modelos compatíveis

  • text-embedding-004
  • text-embedding-005
  • text-multilingual-embedding-002

Os modelos de embedding de texto são compatíveis com ajustes supervisionados tuning. 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 plataforma de agentes do Gemini Enterprise 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 plataforma de agentes do Gemini Enterprise é 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 os pipelines da plataforma de agentes do Gemini Enterprise.
  • Crie um job de ajuste do modelo
  • Implante o modelo ajustado em um endpoint da Gemini Enterprise Agent Platform com o mesmo nome. Ao contrário dos jobs de ajuste de modelo de texto, um job de ajuste de embedding de texto não implanta os modelos ajustados em um endpoint da Gemini Enterprise Agent Platform.

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, 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 Agent Platform", "text": "Agent Platform Studio offers a Google Cloud console tool for rapidly prototyping and testing generative AI models. Learn how you can use Agent Platform 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 Agent Platform's generative AI support. Some of the most common tasks are classification, summarization, and extraction. Agent Platform'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 Agent Platform, 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 inferences."}
{"_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 Agent Platform."}

  • 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 os pipelines da plataforma de agentes do Gemini Enterprise

O ajuste é executado no seu projeto usando a plataforma Pipelines do Gemini Enterprise Agent Platform.

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 de Storage Object Viewer a cada arquivo de conjunto de dados criado no Cloud Storage.
  • Storage Object User acesso ao diretório de saída do Cloud Storage de seu pipeline, PIPELINE_OUTPUT_DIRECTORY.
  • Acesso de Agent Platform 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, consulte Configurar uma conta de serviço com permissões granulares.

Agente de serviço para ajuste da Gemini Enterprise Agent Platform
service-PROJECT_NUMBER@gcp-sa-aiplatform-ft.iam.gserviceaccount.com

Essa conta de serviço requer:

  • Acesso de Storage Object Viewer a cada arquivo de conjunto de dados criado no Cloud Storage.
  • Storage Object User acesso ao diretório de saída do Cloud Storage de seu 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 quota.

Nem todos os aceleradores estão disponíveis em todas as regiões. Consulte Como usar aceleradores na plataforma de agentes do Gemini Enterprise 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 Google Cloud console, 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 Google Cloud console.

Acessar o Google Cloud console

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 Python documentação de referência da API. 

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 esta amostra, siga as instruções de configuração do Java no Guia de início rápido da Agent Platform: como usar bibliotecas de cliente.

Para autenticar no Agent Platform, configure o Application Default Credentials. Se quiser 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 esta amostra, siga as instruções de configuração Node.js no Guia de início rápido do Agent Platform: como usar bibliotecas de cliente.

Para autenticar no Agent Platform, configure o Application Default Credentials. Se quiser 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 embedding de texto usando o Google Cloud console, inicie um pipeline de personalização seguindo as etapas a seguir:

  1. Na seção "Plataforma de agentes" do Google Cloud console, acesse a página Pipelines da plataforma de agentes do Gemini Enterprise.

    Acessar os pipelines da plataforma de agentes do Gemini Enterprise

  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 a VPC Service Controls e pode ser configurado para execução em uma nuvem privada virtual (VPC) transmitindo o network parâmetro ao criar o PipelineJob.

Para usar as CMEK (chaves de criptografia gerenciadas pelo cliente), transmita a chave para o parameterValues.encryption_spec_key_name parâmetro de pipeline, e para o encryptionSpec.kmsKeyName parâmetro, 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 Google Cloud console.

Para visualizar seus modelos ajustados no Google Cloud console, acesse a página Model Registry do Gemini Enterprise Agent Platform.

Acessar o Registro de modelos da plataforma de agentes do Gemini Enterprise

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 inferência, é recomendável implantar usando o tipo de GPU NVIDIA_TESLA_A100, que aceita tamanhos de lote de até cinco para qualquer comprimento de entrada.

Seu modelo ajustado oferece suporte a até 3.072 tokens e pode truncar entradas mais longas.

Receber inferências 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 inferências de uma versão ajustada de textembedding-gecko@001, use o exemplo de comando curl a seguir.

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

A saída de uma solicitação de inferência para o modelo ajustado implantado não está no mesmo formato da saída de uma solicitação para a API de embedding de texto.

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

A seguir