Ottimizzare gli incorporamenti di testo

Questa pagina mostra come ottimizzare i modelli di text embedding.

I foundation model di embedding vengono preaddestrati su un set di dati di testo di grandi dimensioni, fornendo una solida base di riferimento per molte attività. Per gli scenari che richiedono conoscenze specialistiche o prestazioni altamente personalizzate, l'ottimizzazione del modello consente di mettere a punto le rappresentazioni del modello utilizzando i tuoi dati pertinenti. L'ottimizzazione è supportata per i seguenti modelli di text embedding:

Fai clic per espandere i modelli supportati

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

I modelli di text embedding supportano l'ottimizzazione supervisionata. L'ottimizzazione supervisionata utilizza esempi etichettati che mostrano il tipo di output che vuoi ottenere dal modello di text embedding durante l'inferenza.

Per saperne di più sull'ottimizzazione del modello, consulta Come funziona l'ottimizzazione del modello.

Miglioramento della qualità previsto

Gemini Enterprise Agent Platform utilizza un metodo di ottimizzazione efficiente dei parametri per la personalizzazione. Questa metodologia mostra miglioramenti significativi della qualità, fino al 41% (in media il 12%), negli esperimenti eseguiti su set di dati di benchmark di recupero pubblici.

Caso d'uso per l'ottimizzazione di un modello di embedding

L'ottimizzazione di un modello di text embedding può consentire al modello di adattare gli embedding a un dominio o a un'attività specifici. Questa operazione può essere utile se il modello di embedding preaddestrato non è adatto alle tue esigenze specifiche. Ad esempio, puoi mettere a punto un modello di embedding su un set di dati specifico di ticket di assistenza clienti per la tua azienda. In questo modo, un chatbot può comprendere i diversi tipi di problemi di assistenza clienti che i tuoi clienti hanno in genere ed essere in grado di rispondere alle loro domande in modo più efficace. Senza l'ottimizzazione, il modello non conosce le specifiche dei ticket di assistenza clienti o le soluzioni a problemi specifici per il tuo prodotto.

Flusso di lavoro di ottimizzazione

Il flusso di lavoro di ottimizzazione del modello su Gemini Enterprise Agent Platform è il seguente:

  • Prepara il set di dati per l'ottimizzazione del modello.
  • Carica il set di dati di ottimizzazione del modello in un bucket Cloud Storage.
  • Configura il progetto per le pipeline di Gemini Enterprise Agent Platform.
  • Crea un job di ottimizzazione del modello.
  • Esegui il deployment del modello ottimizzato in un endpoint di Gemini Enterprise Agent Platform con lo stesso nome. A differenza dei job di ottimizzazione dei modelli di testo, un job di ottimizzazione di text embedding non esegue il deployment dei modelli ottimizzati in un endpoint di Gemini Enterprise Agent Platform.

Prepara il set di dati di embedding

Il set di dati utilizzato per ottimizzare un modello di embedding include dati in linea con l'attività che vuoi che venga eseguita dal modello.

Formato del set di dati per l'ottimizzazione di un modello di embedding

Il set di dati di addestramento è costituito dai seguenti file, che devono essere in Cloud Storage. Il percorso dei file viene definito dai parametri quando viene avviata la pipeline di ottimizzazione. I tre tipi di file sono file di corpus, file di query ed etichette. Sono necessarie solo le etichette di addestramento, ma puoi anche fornire etichette di convalida e di test per un maggiore controllo.

  • File di corpus: il percorso è definito dal parametro corpus_path. È un file JSONL in cui ogni riga ha i campi _id, title e text con valori stringa. _id e text sono obbligatori, mentre title è facoltativo. Ecco un esempio di file 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."}

  • File di query: il file di query contiene le query di esempio. Il percorso è definito dal parametro queries_path. Il file di query è in formato JSONL e ha gli stessi campi del file di corpus. Ecco un esempio di file 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"}

  • Etichette di addestramento: il percorso è definito dal parametro train_label_path. train_label_path è l'URI Cloud Storage della località dei dati delle etichette di addestramento e viene specificato quando crei il job di ottimizzazione. Le etichette devono essere un file TSV con un'intestazione. Nel file delle etichette di addestramento deve essere incluso un sottoinsieme delle query e del corpus. Il file deve avere le colonne query-id, corpus-id e score. query-id è una stringa che corrisponde alla chiave _id del file di query, mentre corpus-id è una stringa che corrisponde a _id nel file di corpus. Score è un valore intero non negativo. Se una coppia di query e documento non è correlata, puoi ometterla dal file delle etichette di addestramento o includerla con un punteggio pari a zero. Qualsiasi punteggio maggiore di zero indica che il documento è correlato alla query. I numeri più grandi indicano un livello di pertinenza maggiore. Se il punteggio viene omesso, il valore predefinito è 1. Ecco un esempio di file 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

  • Etichette di test: facoltative. Le etichette di test hanno lo stesso formato delle etichette di addestramento e vengono specificate dal parametro test_label_path. Se non viene fornito alcun test_label_path, le etichette di test verranno suddivise automaticamente dalle etichette di addestramento.

  • Etichette di convalida: facoltative. Le etichette di convalida hanno lo stesso formato delle etichette di addestramento e vengono specificate dal parametro validation_label_path. Se non viene fornito alcun validation_label_path, le etichette di convalida verranno suddivise automaticamente dalle etichette di addestramento.

Requisiti relativi alle dimensioni del set di dati

I file del set di dati forniti devono soddisfare i seguenti vincoli:

  • Il numero di query deve essere compreso tra 9 e 10.000.
  • Il numero di documenti nel corpus deve essere compreso tra 9 e 500.000.
  • Ogni file di etichette del set di dati deve includere almeno 3 ID query e in tutte le suddivisioni del set di dati devono essere presenti almeno 9 ID query.
  • Il numero totale di etichette deve essere inferiore a 500.000.

Configura il progetto per le pipeline di Gemini Enterprise Agent Platform

L'ottimizzazione viene eseguita all'interno del progetto utilizzando la piattaforma Gemini Enterprise Agent Platform Pipelines.

Configurazione delle autorizzazioni

La pipeline esegue il codice di addestramento in due agenti di servizio. A questi agenti di servizio devono essere concessi ruoli specifici per iniziare l'addestramento utilizzando il progetto e il set di dati.

Account di servizio Compute Engine predefinito
PROJECT_NUMBER-compute@developer.gserviceaccount.com

Questo account di servizio richiede:

  • Accesso Storage Object Viewer a ogni file del set di dati creato in Cloud Storage.
  • Accesso Storage Object User alla directory di output di Cloud Storage di your pipeline, PIPELINE_OUTPUT_DIRECTORY.
  • Accesso Agent Platform User al progetto.

Anziché il service account predefinito di Compute Engine, puoi specificare un account di servizio personalizzato. Per saperne di più, consulta Configurare un service account con autorizzazioni granulari.

Agente di servizio di ottimizzazione di Gemini Enterprise Agent Platform
service-PROJECT_NUMBER@gcp-sa-aiplatform-ft.iam.gserviceaccount.com

Questo account di servizio richiede:

  • Accesso Storage Object Viewer a ogni file del set di dati creato in Cloud Storage.
  • Accesso Storage Object User alla directory di output di Cloud Storage di your pipeline, PIPELINE_OUTPUT_DIRECTORY.

Per saperne di più sulla configurazione delle autorizzazioni del set di dati di Cloud Storage, consulta Configurare un bucket Cloud Storage per gli artef1atti della pipeline.

Utilizzo degli acceleratori

L'ottimizzazione richiede acceleratori GPU. Per la pipeline di ottimizzazione di text embedding è possibile utilizzare uno dei seguenti acceleratori:

  • NVIDIA_L4
  • NVIDIA_TESLA_A100
  • NVIDIA_TESLA_T4
  • NVIDIA_TESLA_V100
  • NVIDIA_TESLA_P100

Per avviare un job di ottimizzazione è necessaria una quota Restricted image training GPUs adeguata per il tipo di acceleratore e la regione selezionati, ad esempio Restricted image training Nvidia V100 GPUs per region. Per aumentare la quota del tuo progetto, consulta richiedere una quota aggiuntiva.

Non tutti gli acceleratori sono disponibili in tutte le regioni. Per saperne di più, consulta Utilizzare gli acceleratori in Gemini Enterprise Agent Platform per maggiori informazioni.

Crea un job di ottimizzazione del modello di embedding

Puoi creare un job di ottimizzazione del modello di embedding utilizzando la Google Cloud console, l' API REST o le librerie client.

REST

Per creare un job di ottimizzazione del modello di embedding, utilizza il projects.locations.pipelineJobs.create metodo.

Prima di utilizzare i dati della richiesta, apporta le sostituzioni seguenti:

  • PROJECT_ID: l' Google Cloud ID progetto.
  • PIPELINE_OUTPUT_DIRECTORY: percorso degli artefatti di output della pipeline, a partire da "gs://".

Metodo HTTP e URL: 

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

Corpo JSON della richiesta: 

{
  "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"
}

Per inviare la richiesta, espandi una di queste opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

Dopo aver avviato la pipeline, segui l'avanzamento del job di ottimizzazione tramite la Google Cloud console.

Vai alla Google Cloud console

Python

Per scoprire come installare o aggiornare l'SDK Vertex AI Python, consulta Installare l'SDK Vertex AI Python. Per saperne di più, consulta la documentazione di riferimento dell'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

Prima di provare questo esempio, segui le istruzioni di configurazione Java nella guida rapida di Agent Platform per l'utilizzo delle librerie client.

Per eseguire l'autenticazione in Agent Platform, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di Agent Platform per l'utilizzo delle librerie client.

Per eseguire l'autenticazione in Agent Platform, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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

Per ottimizzare un modello di text embedding utilizzando la Google Cloud console, puoi avviare una pipeline di personalizzazione seguendo questi passaggi:

  1. Nella sezione Agent Platform della Google Cloud console, vai a la pagina Pipeline di Gemini Enterprise Agent Platform.

    Vai a Pipeline di Gemini Enterprise Agent Platform

  2. Fai clic su Crea esecuzione per aprire il riquadro Crea esecuzione della pipeline.
  3. Fai clic su Seleziona dalle pipeline esistenti e inserisci i seguenti dettagli:
    1. Seleziona "ml-pipeline" dal menu a discesa Seleziona una risorsa.
    2. Seleziona "llm-text-embedding" dal menu a discesa Repository.
    3. Seleziona "tune-text-embedding-model" dal menu a discesa Pipeline o componente.
    4. Seleziona la versione con etichetta "v1.1.3" dal menu a discesa Versione.
  4. Specifica un nome di esecuzione per identificare in modo univoco l'esecuzione della pipeline.
  5. Nell'elenco a discesa Regione, seleziona la regione in cui creare l'esecuzione della pipeline, che sarà la stessa regione in cui viene creato il modello ottimizzato.
  6. Fai clic su Continua. Viene visualizzato il riquadro Configurazione di runtime.
  7. In Località di Cloud Storage, fai clic su Sfoglia per selezionare il bucket Cloud Storage in cui archiviare gli artefatti di output della pipeline, quindi fai clic su Seleziona.
  8. In Parametri pipeline, specifica i parametri per la pipeline di ottimizzazione. I tre parametri obbligatori sono corpus_path, queries_path e train_label_path, con i formati descritti in Preparare il set di dati di embedding. Per informazioni più dettagliate su ogni parametro, consulta la scheda REST di questa sezione.
  9. Fai clic su Invia per creare l'esecuzione della pipeline.

Altre funzionalità supportate

L'ottimizzazione di text embedding supporta i Controlli di servizio VPC e può essere configurata per l'esecuzione all'interno di una rete Virtual Private Cloud (VPC) passando il network parametro durante la creazione di PipelineJob.

Per utilizzare chiavi di crittografia gestite dal cliente (CMEK), passa la chiave al parameterValues.encryption_spec_key_name parametro della pipeline, nonché al encryptionSpec.kmsKeyName parametro durante la creazione di PipelineJob.

Usa il modello ottimizzato

Visualizza i modelli ottimizzati in Model Registry

Al termine del job di ottimizzazione, il modello ottimizzato non viene sottoposto automaticamente a deployment in un endpoint. Sarà disponibile come risorsa Model in Model Registry. Puoi visualizzare un elenco di modelli in nel progetto corrente, inclusi i modelli ottimizzati, utilizzando la Google Cloud console.

Per visualizzare i modelli ottimizzati nella Google Cloud console, vai alla pagina Model Registry di Gemini Enterprise Agent Platform.

Vai a Model Registry di Gemini Enterprise Agent Platform

Esegui il deployment del modello

Dopo aver ottimizzato il modello di embedding, devi eseguire il deployment della risorsa Model. Per eseguire il deployment del modello di embedding ottimizzato, consulta Eseguire il deployment di un modello in un endpoint.

A differenza dei foundation model, i modelli di text embedding ottimizzati sono gestiti dall'utente. Ciò include la gestione delle risorse di pubblicazione, come il tipo di macchina e gli acceleratori. Per evitare errori di memoria insufficiente durante l'inferenza, ti consigliamo di eseguire il deployment utilizzando il tipo di GPU NVIDIA_TESLA_A100, che può supportare dimensioni batch fino a 5 per qualsiasi lunghezza di input.

Il modello ottimizzato supporta fino a 3072 token e può troncare gli input più lunghi.

Ottieni inferenze su un modello di cui è stato eseguito il deployment

Una volta eseguito il deployment del modello ottimizzato, puoi utilizzare uno dei seguenti comandi per inviare richieste all'endpoint del modello ottimizzato.

Comandi curl di esempio per i modelli textembedding-gecko@001 ottimizzati

Per ottenere inferenze da una versione ottimizzata di textembedding-gecko@001, utilizza il seguente comando curl di esempio.

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

Comandi curl di esempio per i modelli non textembedding-gecko@001

Le versioni ottimizzate di altri modelli (ad esempio textembedding-gecko@003 e textembedding-gecko-multilingual@001) richiedono 2 input aggiuntivi: task_type e title. Ulteriori informazioni su questi parametri sono disponibili in 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"
    }
  ]
}'

Output di esempio

L'output di una richiesta di inferenza al modello ottimizzato di cui è stato eseguito il deployment non ha lo stesso formato dell'output di una richiesta all'API Text Embedding.

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

Passaggi successivi