Ottimizza gli incorporamenti di testo

Questa pagina mostra come ottimizzare il modello di incorporamento del testo textembedding-gecko e textembedding-gecko-multilingual. Questi modelli di base sono stati addestrati su un grande set di dati di testo pubblici. Se hai un caso d'uso unico che richiede dati di addestramento specifici, puoi usare l'ottimizzazione del modello. Dopo aver ottimizzato un modello di incorporamento di base, questo dovrebbe essere adatto al tuo caso d'uso. L'ottimizzazione è supportata per le versioni stabili del modello di incorporamento del testo.

I modelli di incorporamento del testo supportano l'ottimizzazione supervisionata. L'ottimizzazione supervisionata utilizza esempi etichettati per dimostrare il tipo di output desiderato dal modello di incorporamento del testo durante l'inferenza. I modelli di incorporamento di testo non supportano l'ottimizzazione utilizzando l'apprendimento per rinforzo con feedback umano (RLHF).

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

Miglioramento della qualità previsto

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

Caso d'uso per ottimizzare un modello di incorporamento

L'ottimizzazione di un modello di rappresentazioni distribuite di testo consente al modello di adattarsi agli incorporamenti a un'attività o a un dominio specifico. Questo può essere utile se il modello di incorporamenti preaddestrato non è adatto alle tue esigenze specifiche. Ad esempio, potresti perfezionare un modello di incorporamento su un set di dati specifico di richieste di assistenza clienti per la tua azienda. Ciò può aiutare un chatbot a comprendere i diversi tipi di problemi di assistenza clienti che hanno in genere i tuoi clienti e a 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 del prodotto.

Flusso di lavoro dell'ottimizzazione

Il flusso di lavoro dell'ottimizzazione dei modelli su Vertex AI per textembedding-gecko e textembedding-gecko-multilingual è il seguente:

  • Prepara il set di dati di ottimizzazione del modello.
  • Carica il set di dati di ottimizzazione dei modelli in un bucket Cloud Storage.
  • Configura il tuo progetto per Vertex AI Pipelines.
  • Crea un job di ottimizzazione del modello.
  • Esegui il deployment del modello ottimizzato su un endpoint Vertex AI con lo stesso nome. A differenza dei job di ottimizzazione dei modelli di testo o Codey, un job di ottimizzazione di incorporamento di testo non esegue il deployment dei modelli ottimizzati su un endpoint Vertex AI.

Prepara il set di dati di incorporamenti

Il set di dati utilizzato per ottimizzare un modello di incorporamenti include dati in linea con l'attività che vuoi che il modello esegua.

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

Il set di dati di addestramento è composto dai seguenti file, che devono trovarsi in Cloud Storage. Il percorso dei file è definito dai parametri al momento dell'avvio della pipeline di ottimizzazione. I tre tipi di file sono file 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 corpus: il percorso è definito dal parametro corpus_path. È un file JSONL in cui ogni riga contiene 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 generative AI on Vertex AI", "text": "Vertex AI's Generative AI Studio offers a Google Cloud console tool for rapidly prototyping and testing generative AI models. Learn how you can use Generative AI Studio to test models using prompt samples, design and save prompts, tune a foundation model, and convert between speech and text."}
{"_id": "doc2", "title": "Use gen AI for summarization, classification, and extraction", "text": "Learn how to create text prompts for handling any number of tasks with Vertex AI's generative AI support. Some of the most common tasks are classification, summarization, and extraction. Vertex AI's PaLM API for text lets you design prompts with flexibility in terms of their structure and format."}
{"_id": "doc3", "title": "Custom ML training overview and documentation", "text": "Get an overview of the custom training workflow in Vertex AI, the benefits of custom training, and the various training options that are available. This page also details every step involved in the ML training workflow from preparing data to predictions."}
{"_id": "doc4", "text": "Text embeddings are useful for clustering, information retrieval, retrieval-augmented generation (RAG), and more."}
{"_id": "doc5", "title": "Text embedding tuning", "text": "Google's text embedding models can be tuned on Vertex AI."}

  • 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 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 posizione dei dati dell'etichetta di addestramento e viene specificato quando crei il job di ottimizzazione. Le etichette devono essere un file TSV con un'intestazione. È necessario includere un sottoinsieme delle query e del corpus nel file delle etichette di addestramento. Il file deve contenere 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 corpus. Score è un valore intero non negativo. Qualsiasi punteggio maggiore di zero indica che il documento è correlato alla query. 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 sono specificate dal parametro test_label_path. Se non viene fornito alcun valore 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 sono 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 per le dimensioni del set di dati

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

  • Il numero di query deve essere compreso tra 9 e 40.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 esserci almeno 9 ID query.

  • Il numero totale di etichette deve essere inferiore a 500.000.

Configura il tuo progetto per Vertex AI Pipelines

L'ottimizzazione viene eseguita all'interno del progetto utilizzando la piattaforma Vertex AI Pipelines.

Configurazione delle autorizzazioni

La pipeline esegue il codice di addestramento in due account di servizio gestiti da Google. Questi account devono essere configurati con determinate autorizzazioni per iniziare l'addestramento utilizzando il progetto e il set di dati.

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

Questo account di servizio richiede:

  • Accesso Storage Object Viewer a ogni file di set di dati che hai creato in Cloud Storage.

  • Accesso Storage Object User alla directory Cloud Storage di output della tua pipeline, PIPELINE_OUTPUT_DIRECTORY.

  • Accesso di Vertex AI User al progetto.

Anziché l'account di servizio predefinito di Compute Engine, puoi specificare un account di servizio personalizzato. Per ulteriori informazioni, consulta Configurare un account di servizio con autorizzazioni granulari.

Agente di servizio ottimizzazione Vertex AI
service-PROJECT_NUMBER@gcp-sa-aiplatform-ft.iam.gserviceaccount.com

Questo account di servizio richiede:

  • Accesso Storage Object Viewer a ogni file di set di dati che hai creato in Cloud Storage.

  • Accesso Storage Object User alla directory Cloud Storage di output della tua pipeline, PIPELINE_OUTPUT_DIRECTORY.

Per ulteriori informazioni sulla configurazione delle autorizzazioni per i set di dati Cloud Storage, consulta Configurare un bucket Cloud Storage per gli artefatti della pipeline.

Utilizzo degli acceleratori

L'ottimizzazione richiede acceleratori GPU. Puoi utilizzare uno qualsiasi dei seguenti acceleratori per la pipeline di ottimizzazione dell'incorporamento del testo:

  • NVIDIA_L4

  • NVIDIA_TESLA_A100

  • NVIDIA_TESLA_T4

  • NVIDIA_TESLA_V100

  • NVIDIA_TESLA_P100

L'avvio di un job di ottimizzazione richiede 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 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 Vertex AI.

Crea un job di ottimizzazione del modello di incorporamento

Puoi creare un job di ottimizzazione del modello di incorporamento utilizzando la console Google Cloud o l'API REST.

REST

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

  • DISPLAY_NAME: un nome visualizzato per pipelineJob.
  • PIPELINE_OUTPUT_DIRECTORY: percorso per gli artefatti di output della pipeline, che inizia con "gs://".
  • PROJECT_ID: l'ID del tuo progetto Google Cloud.
  • LOCATION: regione del progetto Google Cloud per eseguire la pipeline. L'ottimizzazione è supportata in qualsiasi regione in cui il progetto dispone di una quota GPU adeguata. Per saperne di più, consulta la sezione Utilizzo degli acceleratori. Poiché le risorse di pubblicazione potrebbero essere limitate in altre regioni, l'opzione us-central1 è consigliata.
  • QUERIES_PATH: l'URI del bucket Cloud Storage in cui sono memorizzati i dati delle query, che inizia con "gs://".
  • CORPUS_PATH: l'URI Cloud Storage dei dati del corpus, che inizia con "gs://".
  • TRAIN_LABEL_PATH: l'URI Cloud Storage della località dei dati dell'etichetta del treno, che inizia con "gs://".
  • TEST_LABEL_PATH: facoltativo. L'URI Cloud Storage della posizione dei dati dell'etichetta di test, che inizia con "gs://". Se passi una stringa vuota, la pipeline separa automaticamente il set di dati di test dal set di dati di addestramento.
  • VALIDATION_LABEL_PATH: facoltativo. L'URI Cloud Storage della posizione dei dati dell'etichetta di convalida, che inizia con "gs://". Se passi una stringa vuota, la pipeline separa automaticamente il set di dati di convalida dal set di dati di addestramento.
  • ACCELERATOR_TYPE: facoltativo. Il tipo di acceleratore da utilizzare per l'addestramento. Il valore predefinito è NVIDIA_TESLA_V100. Per i valori possibili, consulta la sezione Utilizzo degli acceleratori.
  • ACCELERATOR_COUNT: facoltativo. Il numero di acceleratori da utilizzare durante l'addestramento. L'utilizzo di un numero maggiore di acceleratori può rendere l'addestramento più rapido, ma non ha alcun effetto sulla qualità. Il valore predefinito è 4.
  • MACHINE_TYPE: facoltativo. Il tipo di macchina da utilizzare per l'addestramento. Il valore predefinito è n1-standard-16. Per informazioni sulla selezione del tipo di macchina che corrisponda al tipo di acceleratore e al conteggio selezionato, consulta la pagina Piattaforme GPU.
  • BASE_MODEL_VERSION_ID: facoltativo. Utilizza questo strumento per specificare quale modello di incorporamento del testo ottimizzare. Il valore predefinito è textembedding-gecko@001. Per i valori possibili, consulta le versioni stabili.
  • MODEL_DISPLAY_NAME: facoltativo. Il nome visualizzato del modello ottimizzato quando viene visualizzato nel registro dei modelli. Il valore predefinito è "tuned-text-embedding-model".
  • TASK_TYPE: facoltativo. L'impostazione di questo parametro consente di ottimizzare il modello ottimizzato per un'attività downstream specifica. Il valore predefinito è DEFAULT. Per saperne di più, consulta Ottenere incorporamenti di testo.
  • BATCH_SIZE: facoltativo. Le dimensioni del batch di addestramento. Il valore predefinito è 128.
  • TRAIN_STEPS: facoltativo. Il numero di passaggi per eseguire l'ottimizzazione del modello. Il valore predefinito è 1000 e deve essere maggiore di 30.
  • OUTPUT_DIMENSIONALITY: facoltativo. Un numero intero compreso tra 1 e 768. Questo determina la dimensionalità di output (dimensione vettoriale) del modello ottimizzato. Un valore pari a -1 indica la dimensione di incorporamento completa del modello di base. Funzionalità supportata solo per i modelli text-embedding-004 e text-multilingual-embedding-002.
  • LR_MULTIPLIER: facoltativo. Un moltiplicatore da applicare al tasso di apprendimento durante l'addestramento. Il valore predefinito è 1,0, che addestra con un tasso di apprendimento consigliato.
  • CMEK_KEY_NAME: facoltativo. Il nome della chiave di crittografia gestita dal cliente CMEK da utilizzare per scrivere tutte le risorse di ottimizzazione, come il modello ottimizzato e i dati della pipeline di output.

Metodo HTTP e URL: 

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

Corpo JSON della richiesta: 

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

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 console Google Cloud.

Vai alla console Google Cloud

Python

Per scoprire come installare o aggiornare l'SDK Vertex AI per Python, consulta Installare l'SDK Vertex AI per 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.preview.language_models import TextEmbeddingModel


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

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java riportate nella guida rapida di Vertex AI sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Java Vertex AI.

Per eseguire l'autenticazione in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, 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.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

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js riportate nella guida rapida di Vertex AI sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Node.js Vertex AI.

Per eseguire l'autenticazione in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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

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

  await createTuneJob();
}

Console

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

  1. Nella sezione Vertex AI della console Google Cloud, vai alla pagina Vertex AI Pipelines.

    Vai a Vertex AI Pipelines

  2. Fai clic su Crea esecuzione per aprire il riquadro Crea esecuzione pipeline.
  3. Fai clic su Seleziona da 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 l'etichetta "v1.1.3" dall'elenco a discesa Versione.
  4. Specifica un Nome esecuzione per identificare in modo univoco l'esecuzione della pipeline.
  5. Nell'elenco a discesa Regione, seleziona la regione per creare l'esecuzione della pipeline, che sarà la stessa in cui è stato creato il modello ottimizzato.
  6. Fai clic su Continua. Viene visualizzato il riquadro Configurazione runtime.
  7. In Località 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 della 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 incorporamenti. Per informazioni più dettagliate su ciascun parametro, fai riferimento alla scheda REST di questa sezione.
  9. Fai clic su Invia per creare l'esecuzione della pipeline.

Comando curl di esempio

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


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

Utilizza il modello ottimizzato

Visualizza i modelli ottimizzati in Model Registry

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

Per visualizzare i modelli ottimizzati nella console Google Cloud, vai alla pagina Vertex AI Model Registry.

Vai a Vertex AI Model Registry

Esegui il deployment del modello

Dopo aver ottimizzato il modello di incorporamenti, devi eseguire il deployment della risorsa Modello. Per eseguire il deployment del tuo modello di incorporamenti ottimizzati, consulta Eseguire il deployment di un modello in un endpoint.

A differenza dei modelli di base, i modelli ottimizzati di incorporamento del testo sono gestiti dall'utente. Ciò include la gestione delle risorse di gestione, come il tipo di macchina e gli acceleratori. Per evitare errori di esaurimento della memoria durante la previsione, 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.

Analogamente al modello di base textembedding-gecko, il modello ottimizzato supporta fino a 3072 token e può troncare input più lunghi.

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

Dopo 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 previsioni da una versione ottimizzata di textembedding-gecko@001, utilizza il comando curl di esempio riportato di seguito.

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

Esempi di comandi curl per i modelli non textembedding-gecko@001

Le versioni ottimizzate di altri modelli (ad esempio, textembedding-gecko@003 e textembedding-gecko-multilingual@001) richiedono due input aggiuntivi: task_type e title. Ulteriore documentazione su questi parametri è disponibile all'indirizzo curl command

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

Questo output si applica ai modelli textembedding-gecko e textembedding-gecko-multilingual, indipendentemente dalla versione.

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

Passaggi successivi