Ajusta las incorporaciones de texto

En esta página, se muestra cómo ajustar los modelos de incorporación de texto, como textembedding-gecko y textembedding-gecko-multilingual.

Los modelos de incorporación de base se entrenan previamente con un conjunto de datos masivo de texto, lo que proporciona una base sólida para muchas tareas. En situaciones que requieren conocimientos especializados o un rendimiento altamente personalizado, el ajuste del modelo te permite ajustar las representaciones del modelo con tus propios datos relevantes. El ajuste es compatible con las versiones estables de los modelos textembedding-gecko y textembedding-gecko-multilingual.

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.

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 Studio offers a Google Cloud console tool for rapidly prototyping and testing generative AI models. Learn how you can use Vertex AI Studio to test models using prompt samples, design and save prompts, tune a foundation model, and convert between speech and text."}
{"_id": "doc2", "title": "Use gen AI for summarization, classification, and extraction", "text": "Learn how to create text prompts for handling any number of tasks with Vertex AI's generative AI support. Some of the most common tasks are classification, summarization, and extraction. Vertex AI's PaLM API for text lets you design prompts with flexibility in terms of their structure and format."}
{"_id": "doc3", "title": "Custom ML training overview and documentation", "text": "Get an overview of the custom training workflow in Vertex AI, the benefits of custom training, and the various training options that are available. This page also details every step involved in the ML training workflow from preparing data to predictions."}
{"_id": "doc4", "text": "Text embeddings are useful for clustering, information retrieval, retrieval-augmented generation (RAG), and more."}
{"_id": "doc5", "title": "Text embedding tuning", "text": "Google's text embedding models can be tuned on Vertex AI."}

  • 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. Si un par de consulta y documento no está relacionado, puedes dejarlo fuera del archivo de etiquetas de entrenamiento o incluirlo con una puntuación de cero. 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 10,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 agentes de servicio. A estos agentes de servicio se les deben otorgar roles específicos 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, la API de REST o las bibliotecas cliente.

REST

Para crear un trabajo de ajuste de modelos de incorporación, usa el método projects.locations.pipelineJobs.create.

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

  • PROJECT_ID es el ID del proyecto de Google Cloud.
  • PIPELINE_OUTPUT_DIRECTORY: Ruta de acceso para los artefactos de salida de la canalización, que comienza con “gs://”.

Método HTTP y URL: 

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

Cuerpo JSON de la solicitud:

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

Otras funciones compatibles

La optimización de la incorporación de texto admite los Controles del servicio de VPC y se puede configurar para que se ejecute en una nube privada virtual (VPC) pasando el parámetro network cuando se crea el PipelineJob.

Para usar CMEK (claves de encriptación administradas por el cliente), pasa la clave al parámetro de canalización parameterValues.encryption_spec_key_name, así como al parámetro encryptionSpec.kmsKeyName cuando crees el PipelineJob.

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?