Ajusta las incorporaciones de texto

En esta página, se muestra cómo ajustar el modelo de incorporación de texto, textembedding-gecko y textembedding-gecko-multilingual. Estos modelos de base se entrenaron con un gran conjunto de datos de texto públicos. Si tienes un caso de uso único que requiere tus propios datos de entrenamiento específicos, puedes usar el ajuste de modelos. Después de ajustar un modelo de incorporación de base, el modelo se debe adaptar a tu caso práctico. El ajuste es compatible con las versiones estables del modelo de incorporación de texto.

Los modelos de incorporación de texto admiten el ajuste supervisado. El ajuste supervisado usa ejemplos etiquetados que demuestran el tipo de resultado que deseas en tu modelo de incorporación de texto durante la inferencia. Los modelos de incorporación de texto no admiten el ajuste mediante el aprendizaje por refuerzo con retroalimentación humana (RLHF).

Para obtener más información sobre el ajuste de modelos, consulta Cómo funciona el ajuste de modelos.

Mejora de calidad esperada

Vertex AI usa un método de ajuste eficiente de parámetros para la personalización. Esta metodología muestra mejoras significativas en calidad de hasta el 41% (promedio 12%) en experimentos realizados en conjuntos de datos comparativos de recuperación pública.

Caso de uso para ajustar un modelo de incorporación

Ajustar un modelo de incorporaciones de texto puede permitir que tu modelo se adapte a las incorporaciones a un dominio o una tarea específicos. Esto puede ser útil si el modelo de incorporaciones previamente entrenado no se adapta a tus necesidades específicas. Por ejemplo, puedes ajustar un modelo de incorporaciones en un conjunto de datos específico de tickets de asistencia al cliente para tu empresa. Esto podría ayudar a un chatbot a comprender los diferentes tipos de problemas de asistencia al cliente que suelen tener tus clientes y poder responder sus preguntas de manera más eficaz. Sin el ajuste, el modelo no conoce los detalles de los tickets de asistencia al cliente o las soluciones a problemas específicos del producto.

Flujo de trabajo de ajuste

El flujo de trabajo de ajuste de modelos en Vertex AI para textembedding-gecko y textembedding-gecko-multilingual es el siguiente:

  • Prepara tu conjunto de datos de ajuste de modelos.
  • Sube el conjunto de datos de ajuste de modelos a un bucket de Cloud Storage.
  • Configura tu proyecto para Vertex AI Pipelines.
  • Crea un trabajo de ajuste de modelos.
  • Implementa el modelo ajustado en un extremo de Vertex AI del mismo nombre. A diferencia de los trabajos de ajuste de modelos de texto o Codey, un trabajo de ajuste de incorporación de texto no implementa tus modelos ajustados en un extremo de Vertex AI.

Prepara tu conjunto de datos de incorporaciones

El conjunto de datos que se usa para ajustar un modelo de incorporaciones incluye datos que se alinean con la tarea que deseas que realice el modelo.

Formato del conjunto de datos para ajustar un modelo de incorporaciones

El conjunto de datos de entrenamiento consta de los siguientes archivos, que deben estar en Cloud Storage. La ruta de acceso de los archivos se define mediante parámetros cuando se inicia la canalización de ajuste. Los tres tipos de archivos son el archivo de corpus, el archivo de consulta y las etiquetas. Solo se necesitan etiquetas de entrenamiento, pero también puedes proporcionar etiquetas de validación y de prueba para un mayor control.

  • Archivo de corpus: La ruta de acceso se define mediante el parámetro corpus_path. Es un archivo JSONL en el que cada línea tiene los campos _id, title y text con valores de string. _id y text son obligatorios, mientras que title es opcional. A continuación, se muestra un archivo corpus.jsonl de ejemplo:

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

  • Archivo de consulta: El archivo de consulta contiene tus consultas de ejemplo. La ruta de acceso se define mediante el parámetro queries_path. El archivo de consulta está en formato JSONL y tiene los mismos campos que el archivo de corpus. A continuación, se muestra un archivo queries.jsonl de ejemplo:

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

  • Etiquetas de entrenamiento: La ruta de acceso se define con el parámetro train_label_path. El valor de training_label_path es el URI de Cloud Storage que dirige a la ubicación de los datos de la etiqueta de entrenamiento y se especifica cuando creas el trabajo de ajuste. Las etiquetas deben ser un archivo TSV con un encabezado. Se debe incluir un subconjunto de las consultas y el corpus en el archivo de etiquetas de entrenamiento. El archivo debe tener las columnas query-id, corpus-id y score. query-id es una string que coincide con la clave _id del archivo de consulta, corpus-id es una string que coincide con _id en el archivo de corpus. Score es un valor de número entero no negativo. Cualquier puntuación mayor que cero indica que el documento está relacionado con la consulta. Los números más grandes indican un nivel de relevancia mayor. Si se omite la puntuación, el valor predeterminado es 1. A continuación, se muestra un archivo train_labels.tsv de ejemplo:

    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

  • Etiquetas de prueba: Opcional. Las etiquetas de prueba tienen el mismo formato que las etiquetas de entrenamiento y se especifican mediante el parámetro test_label_path. Si no se proporciona un test_label_path, las etiquetas de prueba se dividirán de forma automática a partir de las etiquetas de entrenamiento.

  • Etiquetas de validación: Opcional. Las etiquetas de validación tienen el mismo formato que las etiquetas de entrenamiento y se especifican mediante el parámetro validation_label_path. Si no se proporciona un validation_label_path, las etiquetas de validación se dividirán de forma automática a partir de las etiquetas de entrenamiento.

Requisitos de tamaño del conjunto de datos

Los archivos de conjuntos de datos proporcionados deben cumplir con las siguientes restricciones:

  • La cantidad de consultas debe ser entre 9 y 40,000.

  • La cantidad de documentos del corpus debe ser entre 9 y 500,000.

  • Cada archivo de etiquetas de conjuntos de datos debe incluir al menos 3 IDs de consulta y, en todas las divisiones de conjuntos de datos, debe haber al menos 9 IDs de consulta.

  • La cantidad total de etiquetas debe ser inferior a 500,000.

Configura tu proyecto para Vertex AI Pipelines

El ajuste se ejecuta en tu proyecto con la plataforma Vertex AI Pipelines.

Configurar permisos

La canalización ejecuta el código de entrenamiento en dos cuentas de servicio administradas por Google. Estas cuentas deben configurarse con ciertos permisos para comenzar el entrenamiento con tu proyecto y conjunto de datos.

Cuenta de servicio predeterminada de Compute Engine
PROJECT_NUMBER-compute@developer.gserviceaccount.com

Esta cuenta de servicio requiere lo siguiente:

  • Acceso de Storage Object Viewer a cada archivo de conjunto de datos que creaste en Cloud Storage.

  • Acceso de Storage Object User al directorio de salida de Cloud Storage de tu canalización, PIPELINE_OUTPUT_DIRECTORY.

  • Acceso de Vertex AI User a tu proyecto.

En lugar de la cuenta de servicio predeterminada de Compute Engine, puedes especificar una cuenta de servicio personalizada. Para obtener más información, consulta Configura una cuenta de servicio con permisos detallados.

Agente de servicio de ajuste de Vertex AI
service-PROJECT_NUMBER@gcp-sa-aiplatform-ft.iam.gserviceaccount.com

Esta cuenta de servicio requiere lo siguiente:

  • Acceso de Storage Object Viewer a cada archivo de conjunto de datos que creaste en Cloud Storage.

  • Acceso de Storage Object User al directorio de salida de Cloud Storage de tu canalización, PIPELINE_OUTPUT_DIRECTORY.

Si deseas obtener más información para configurar los permisos del conjunto de datos de Cloud Storage, consulta Configura un bucket de Cloud Storage para artefactos de canalización.

Uso de aceleradores

El ajuste requiere aceleradores de GPU. Cualquiera de los siguientes aceleradores se puede usar para la canalización de ajuste de incorporación de texto:

  • NVIDIA_L4

  • NVIDIA_TESLA_A100

  • NVIDIA_TESLA_T4

  • NVIDIA_TESLA_V100

  • NVIDIA_TESLA_P100

Iniciar un trabajo de ajuste requiere una cuota de Restricted image training GPUs adecuada para el tipo de acelerador y la región que seleccionaste, por ejemplo, Restricted image training Nvidia V100 GPUs per region. Para aumentar la cuota de tu proyecto, consulta cómo solicitar una cuota adicional.

No todos los aceleradores están disponibles en todas las regiones. Consulta Usa aceleradores en Vertex AI para obtener más información.

Crea un trabajo de ajuste de modelos de incorporación

Puedes crear un trabajo de ajuste de modelos de incorporación con la consola de Google Cloud o la API de REST.

REST

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • DISPLAY_NAME: Un nombre visible para el pipelineJob.
  • PIPELINE_OUTPUT_DIRECTORY: Ruta de acceso para los artefactos de salida de la canalización, que comienza con “gs://”.
  • PROJECT_ID es el ID del proyecto de Google Cloud.
  • LOCATION: la región del proyecto de Google Cloud para ejecutar la canalización. El ajuste se admite en cualquier región en la que tu proyecto tenga una cuota de GPU adecuada. Consulta Usa aceleradores para obtener más información. Debido a que los recursos de entrega pueden estar limitados en otras regiones, se recomienda us-central1.
  • QUERIES_PATH: El URI del bucket de Cloud Storage que almacena datos de consulta, que comienza con “gs://”.
  • CORPUS_PATH: Es el URI de Cloud Storage para los datos del corpus, que comienza con “gs://”.
  • TRAIN_LABEL_PATH: Es el URI de Cloud Storage de la ubicación de los datos de la etiqueta de entrenamiento, que comienza con “gs://”.
  • TEST_LABEL_PATH: Opcional El URI de Cloud Storage de la ubicación de los datos de la etiqueta de prueba, que comienza con “gs://”. Si pasas una cadena vacía, la canalización dividirá automáticamente el conjunto de datos de prueba del conjunto de datos de entrenamiento.
  • VALIDATION_LABEL_PATH: Opcional El URI de Cloud Storage de la ubicación de los datos de la etiqueta de validación, que comienza con “gs://”. Si pasas una cadena vacía, la canalización dividirá automáticamente el conjunto de datos de validación del conjunto de datos de entrenamiento.
  • ACCELERATOR_TYPE: Opcional El tipo de acelerador de datos que se usará para el entrenamiento. La configuración predeterminada es NVIDIA_TESLA_V100. Para obtener valores posibles, consulta Usa aceleradores.
  • ACCELERATOR_COUNT: Opcional La cantidad de aceleradores que se usarán en el entrenamiento. Usar una cantidad mayor de aceleradores puede hacer que el entrenamiento sea más rápido, pero no afecta la calidad. La configuración predeterminada es 4.
  • MACHINE_TYPE: Opcional El tipo de máquina que se usará para el entrenamiento. La configuración predeterminada es n1-standard-16. Para obtener información sobre cómo seleccionar el tipo de máquina que coincide con el tipo de acelerador y el recuento que seleccionaste, consulta Plataformas de GPU.
  • BASE_MODEL_VERSION_ID: Opcional Usa esto para especificar qué modelo de incorporación de texto se va a ajustar. La configuración predeterminada es textembedding-gecko@001. Para obtener valores posibles, consulta Versiones estables.
  • MODEL_DISPLAY_NAME: Opcional El nombre visible del modelo ajustado cuando aparece en Model Registry. La configuración predeterminada es “tuned-text-embedding-model”.
  • TASK_TYPE: Opcional Establecer este parámetro optimiza el modelo ajustado para una tarea descendente específica. La configuración predeterminada es DEFAULT. Para obtener más información, consulta Obtén incorporaciones de texto.
  • BATCH_SIZE: Opcional El tamaño del lote de entrenamiento. La configuración predeterminada es 128.
  • TRAIN_STEPS: Opcional La cantidad de pasos para realizar el ajuste del modelo. La configuración predeterminada es 1, 000 y debe ser mayor que 30.
  • OUTPUT_DIMENSIONALITY: Opcional Un número entero entre 1 y 768. Esto determina la dimensionalidad de salida (tamaño del vector) del modelo ajustado. Un valor de -1 indica que se usará el tamaño de incorporación completo del modelo base. Solo es compatible con los modelos text-embedding-004 y text-multilingual-embedding-002.
  • LR_MULTIPLIER: Opcional Un multiplicador para aplicar a la tasa de aprendizaje durante el entrenamiento. La configuración predeterminada es 1.0, que se entrena con una tasa de aprendizaje recomendada.
  • CMEK_KEY_NAME: Opcional El nombre de la CMEK Clave de encriptación administrada por el cliente que se usará para escribir todos los recursos de ajuste, como el modelo ajustado y los datos de la canalización de salida.

Método HTTP y URL: 

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

Cuerpo JSON de la solicitud:

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

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

Después de iniciar la canalización, sigue el progreso del trabajo de ajuste a través de la consola de Google Cloud.

Ir a la consola de Google Cloud

Python

Si deseas obtener información para instalar o actualizar el SDK de Vertex AI para Python, consulta Instala el SDK de Vertex AI para Python. Si deseas obtener más información, consulta la documentación de referencia de la API de 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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Java incluidas en la guía de inicio rápido de Vertex AI sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Vertex AI Java.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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 probar este ejemplo, sigue las instrucciones de configuración para Node.js incluidas en la guía de inicio rápido de Vertex AI sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Vertex AI Node.js.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

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

Para ajustar un modelo de incorporación de texto con la consola de Google Cloud, puedes iniciar una canalización de personalización a través de los siguientes pasos:

  1. En la sección Vertex AI de la consola de Google Cloud, ve a la página Vertex AI Pipelines.

    Ir a Vertex AI Pipelines

  2. Haz clic en Crear ejecución para abrir el panel Crear una ejecución de canalización.
  3. Haz clic en Seleccionar de canalizaciones existentes y, a continuación, ingresa los siguientes detalles:
    1. Selecciona "ml-pipeline" en el menú desplegable Select a resource.
    2. Selecciona "llm-text-embedding" en el menú desplegable Repositorio.
    3. Selecciona "tune-text-embedding-model" en el menú desplegable Canalización o componente.
    4. Selecciona la versión con la etiqueta "v1.1.3" en el menú desplegable Versión.
  4. Especifica un nombre de ejecución para identificar de manera única la ejecución de la canalización.
  5. En la lista desplegable Región, selecciona la región para crear la ejecución de la canalización, que será la misma región en la que se crea el modelo ajustado.
  6. Haz clic en Continuar. Aparecerá el panel Configuración del entorno de ejecución.
  7. En Ubicación de Cloud Storage, haz clic en Explorar para seleccionar el bucket de Cloud Storage para almacenar los artefactos de salida de la canalización y, luego, haz clic en Seleccionar.
  8. En Parámetros de canalización, especifica los parámetros para la canalización de ajuste. Los tres parámetros necesarios son corpus_path, queries_path y train_label_path, con los formatos que se describen en Prepara el conjunto de datos de incorporaciones. Para obtener información más detallada sobre cada parámetro, consulta la pestaña REST de esta sección.
  9. Haz clic en Submit para crear la ejecución de la canalización.

Ejemplo del comando curl

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

Usa tu modelo ajustado

Visualiza modelos ajustados en Model Registry

Cuando se completa el trabajo de ajuste, el modelo ajustado no se implementa en un extremo. Estará disponible como un recurso del modelo en Model Registry. Puedes ver una lista de modelos en tu proyecto actual, incluidos los modelos ajustados con la consola de Google Cloud.

Para ver tus modelos ajustados en la consola de Google Cloud, ve a la página Registro de modelos de Vertex AI.

Ir a Registro de modelos de Vertex AI

Implementa tu modelo

Luego de ajustar el modelo de incorporaciones, debes implementar el recurso Modelo. Para implementar tu modelo de incorporaciones ajustadas, consulta Implementa un modelo en un extremo.

A diferencia de los modelos base, el usuario administra los modelos de incorporación de texto ajustados. Esto incluye la administración de recursos de entrega, como el tipo de máquina y los aceleradores. A fin de evitar errores de memoria insuficiente durante la predicción, se recomienda que realices la implementación con el tipo de GPU NVIDIA_TESLA_A100, que puede admitir tamaños de lote de hasta 5 para cualquier longitud de entrada.

Al igual que el modelo de base textembedding-gecko, el modelo ajustado admite hasta 3,072 tokens y puede truncar las entradas más largas.

Obtén predicciones en un modelo implementado

Una vez que se implementa el modelo ajustado, puedes usar uno de los siguientes comandos para emitir solicitudes al extremo del modelo ajustado.

Comandos curl de ejemplo para modelos textembedding-gecko@001 ajustados

Para obtener predicciones de una versión ajustada de textembedding-gecko@001, usa el comando curl de ejemplo a continuación.

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

Comandos curl de ejemplo para modelos no textembedding-gecko@001

Las versiones ajustadas de otros modelos (por ejemplo, textembedding-gecko@003 y textembedding-gecko-multilingual@001) requieren 2 entradas adicionales: task_type y title. Puedes encontrar más documentación sobre estos parámetros en el 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"
    }
  ]
}'

Resultado de ejemplo

Este resultado se aplica a los modelos textembedding-gecko y textembedding-gecko-multilingual, sin importar la versión.

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

¿Qué sigue?