Ajustar embeddings de texto

En esta página se explica cómo ajustar los modelos de inserción de texto.

Los modelos de inserción fundacionales se preentrenan con un conjunto de datos de texto masivo, lo que proporciona una base sólida para muchas tareas. En los casos en los que se requieran conocimientos especializados o un rendimiento muy personalizado, el ajuste de modelos te permite perfeccionar las representaciones del modelo con tus propios datos relevantes. La optimización está disponible en las versiones estables de los modelos textembedding-gecko y textembedding-gecko-multilingual.

Los modelos de inserciones de texto admiten el ajuste supervisado. El ajuste supervisado usa ejemplos etiquetados que muestran el tipo de resultado que quieres obtener de tu modelo de inserciones de texto durante la inferencia.

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

Mejora de la calidad prevista

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

Caso práctico para ajustar un modelo de inserciones

Ajustar un modelo de inserciones de texto puede permitir que tu modelo adapte las inserciones a un dominio o una tarea específicos. Esto puede ser útil si el modelo de inserciones preentrenado no se adapta bien a tus necesidades específicas. Por ejemplo, puedes ajustar un modelo de inserciones en un conjunto de datos específico de incidencias de asistencia al cliente de tu empresa. Esto podría ayudar a un chatbot a entender los diferentes tipos de problemas de asistencia que suelen tener tus clientes y a responder a sus preguntas de forma más eficaz. Si no se ajusta, el modelo no conoce los detalles de sus tickets de asistencia ni las soluciones a problemas específicos de su 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 del modelo.
  • Sube el conjunto de datos de ajuste del modelo a un segmento de Cloud Storage.
  • Configura tu proyecto para usar Vertex AI Pipelines.
  • Crea una tarea de ajuste de modelo.
  • Despliega el modelo ajustado en un endpoint de Vertex AI con el mismo nombre. A diferencia de las tareas de ajuste de modelos de texto o Codey, las tareas de ajuste de modelos de inserciones de texto no despliegan los modelos ajustados en un endpoint de Vertex AI.

Preparar el conjunto de datos de inserciones

El conjunto de datos que se usa para ajustar un modelo de embeddings incluye datos que se ajustan a la tarea que quieres que realice el modelo.

Formato del conjunto de datos para ajustar un modelo de inserciones

El conjunto de datos de entrenamiento consta de los siguientes archivos, que deben estar en Cloud Storage. Las rutas de los archivos se definen mediante parámetros al iniciar el flujo de procesamiento de ajuste. Los tres tipos de archivos son el archivo de corpus, el archivo de consultas y las etiquetas. Solo se necesitan etiquetas de entrenamiento, pero también puedes proporcionar etiquetas de validación y de prueba para tener más control.

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

    {"_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: contiene las consultas de ejemplo. La ruta 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. Aquí tienes un ejemplo de archivo 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"}

  • Etiquetas de entrenamiento: la ruta se define mediante el parámetro train_label_path. train_label_path es el URI de Cloud Storage de la ubicación de los datos de etiquetas de entrenamiento y se especifica al crear el trabajo de ajuste. Las etiquetas deben ser un archivo TSV con un encabezado. En el archivo de etiquetas de entrenamiento debe incluirse un subconjunto de las consultas y el corpus. El archivo debe incluir las columnas query-id, corpus-id y score. query-id es una cadena que coincide con la clave _id del archivo de consulta, y corpus-id es una cadena que coincide con _id en el archivo de corpus. Score es un valor entero no negativo. Si una consulta y un documento no están relacionados, puedes omitirlos en el archivo de etiquetas de entrenamiento o incluirlos con una puntuación de cero. Cualquier puntuación superior a cero indica que el documento está relacionado con la consulta. Los números más altos indican un mayor nivel de relevancia. Si se omite la puntuación, el valor predeterminado es 1. A continuación, se muestra un ejemplo de archivo 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

  • 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 test_label_path, las etiquetas de prueba se dividirán automáticamente 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 ningún validation_label_path, las etiquetas de validación se dividirán automáticamente a partir de las etiquetas de entrenamiento.

Requisitos de tamaño de los conjuntos de datos

Los archivos del conjunto de datos proporcionado deben cumplir las siguientes restricciones:

  • El número de consultas debe estar entre 9 y 10.000.
  • El número de documentos del corpus debe estar entre 9 y 500.000.
  • Cada archivo de etiquetas de conjunto de datos debe incluir al menos 3 IDs de consulta y, en todas las divisiones del conjunto de datos, debe haber al menos 9 IDs de consulta.
  • El número total de etiquetas debe ser inferior a 500.000.

Configurar un proyecto para Vertex AI Pipelines

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

Configurar permisos

El flujo de trabajo ejecuta el código de entrenamiento con dos agentes de servicio. Estos agentes de servicio deben tener roles específicos para empezar a entrenar con tu proyecto y tu conjunto de datos.

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

Esta cuenta de servicio requiere lo siguiente:

  • Storage Object Viewer acceso a cada archivo del conjunto de datos que haya creado en Cloud Storage.

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

  • Vertex AI User acceso 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 Configurar 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:

  • Storage Object Viewer acceso a cada archivo del conjunto de datos que haya creado en Cloud Storage.

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

Para obtener más información sobre cómo configurar los permisos del conjunto de datos de Cloud Storage, consulta Configurar un segmento de Cloud Storage para los artefactos de la canalización.

Usar aceleradores

Para ajustar los parámetros, se necesitan aceleradores de GPU. Se puede usar cualquiera de los siguientes aceleradores para la canalización de ajuste de la inserción de texto:

  • NVIDIA_L4
  • NVIDIA_TESLA_A100
  • NVIDIA_TESLA_T4
  • NVIDIA_TESLA_V100
  • NVIDIA_TESLA_P100

Para iniciar una tarea de ajuste, debes tener suficiente cuota de Restricted image training GPUs para el tipo de acelerador y la región que hayas seleccionado (por ejemplo, Restricted image training Nvidia V100 GPUs per region). Para aumentar la cuota de tu proyecto, consulta cómo solicitar otra.

No todos los aceleradores están disponibles en todas las regiones. Para obtener más información, consulta Usar aceleradores en Vertex AI.

Crear una tarea de ajuste de un modelo de incrustaciones

Puedes crear un trabajo de ajuste de un modelo de inserciones mediante la Google Cloud consola, la API REST o las bibliotecas de cliente.

REST

Para crear una tarea de ajuste de un modelo de inserciones, usa el método projects.locations.pipelineJobs.create.

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

  • PROJECT_ID: tu ID de proyecto Google Cloud .
  • PIPELINE_OUTPUT_DIRECTORY: ruta de los artefactos de salida de la canalización, que empieza por "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, despliega una de estas opciones:

Deberías recibir una respuesta JSON similar a la siguiente:

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

Ir a la Google Cloud consola

Python

Para saber cómo instalar o actualizar el SDK de Vertex AI para Python, consulta Instalar el SDK de Vertex AI para Python. Para obtener más información, consulta la documentación de referencia de la 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

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

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en 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 Node.js instrucciones de configuración de la guía de inicio rápido de Vertex AI con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Node.js de Vertex AI.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en 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();
}

Consola

Para ajustar un modelo de inserciones de texto mediante la consola Google Cloud , puedes iniciar una canalización de personalización siguiendo estos pasos:

  1. En la sección Vertex AI de la Google Cloud consola, 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 ejecución de canalización.
  3. Haga clic en Seleccionar entre las canalizaciones existentes e introduzca los siguientes detalles:
    1. Selecciona "ml-pipeline" en el menú desplegable seleccionar un recurso.
    2. Selecciona "llm-text-embedding" en el menú desplegable Repositorio.
    3. Selecciona "tune-text-embedding-model" en el menú desplegable Pipeline or component (Pipeline o componente).
    4. En el menú desplegable Versión, seleccione la versión "v1.1.3".
  4. Especifica un nombre de ejecución para identificar de forma única la ejecución de la canalización.
  5. En la lista desplegable Región, selecciona la región en la que se creará la ejecución de la canalización, que será la misma en la que se cree tu modelo ajustado.
  6. Haz clic en Continuar. Aparecerá el panel Configuración del tiempo de ejecución.
  7. En Ubicación de Cloud Storage, haga clic en Examinar para seleccionar el segmento de Cloud Storage en el que se almacenarán los artefactos de salida de la canalización y, a continuación, haga clic en Seleccionar.
  8. En Parámetros de la canalización, especifica los parámetros de la canalización de ajuste. Los tres parámetros obligatorios son corpus_path, queries_path y train_label_path, con los formatos que se describen en Preparar el conjunto de datos de inserciones. Para obtener información más detallada sobre cada parámetro, consulta la pestaña REST de esta sección.
  9. Haz clic en Enviar para crear la ejecución de la canalización.

Otras funciones compatibles

El ajuste de la inserción de texto admite Controles de Servicio de VPC y se puede configurar para que se ejecute en una nube privada virtual (VPC) pasando el parámetro network al crear PipelineJob.

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

Usar tu modelo ajustado

Ver modelos ajustados en Model Registry

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

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

Ir al registro de modelos de Vertex AI

Desplegar un modelo

Una vez que hayas ajustado el modelo de embeddings, tendrás que desplegar el recurso Model. Para desplegar tu modelo de inserciones ajustado, consulta Desplegar un modelo en un endpoint.

A diferencia de los modelos básicos, los modelos de inserción de texto ajustados los gestiona el usuario. Esto incluye la gestión de recursos de servicio, como el tipo de máquina y los aceleradores. Para evitar errores de falta de memoria durante la predicción, se recomienda que implementes el modelo 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 básico textembedding-gecko, tu modelo ajustado admite hasta 3072 tokens y puede truncar las entradas más largas.

Obtener predicciones de un modelo implementado

Una vez que hayas implementado el modelo ajustado, puedes usar uno de los siguientes comandos para enviar solicitudes al endpoint 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 que se muestra 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 dos entradas adicionales: task_type y title. Puede consultar 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"
    }
  ]
}'

Ejemplo

Esta salida se aplica tanto a los modelos textembedding-gecko como a los textembedding-gecko-multilingual, independientemente de la versión.

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

Siguientes pasos