Ajusta los modelos de texto con el ajuste supervisado

El ajuste supervisado usa ejemplos etiquetados para ajustar un modelo. En cada ejemplo, se muestra el resultado que deseas de tu modelo de texto durante la inferencia. El ajuste supervisado es una buena opción cuando el resultado de tu modelo no es muy complejo y es fácil de definir. Si el resultado de tu modelo es difícil de definir, considera ajustar tu modelo de texto con el aprendizaje por refuerzo de los comentarios de personas (RLHF).

Guía paso a paso para el ajuste de modelos de texto

En el siguiente instructivo guiado, aprenderás a usar el ajuste supervisado para ajustar un modelo de base de texto en la consola de Google Cloud.

Para seguir la guía paso a paso en esta tarea directamente en la consola de Google Cloud, haz clic en Guía:

GUIARME

Modelos compatibles

Los siguientes modelos de base admiten la optimización supervisada:

  • text-bison@002
  • chat-bison@002
  • text-bison-32k
  • chat-bison-32k

Casos de uso para usar ajustes supervisados en modelos de texto

Los modelos de texto base funcionan bien cuando el resultado o la tarea esperados se pueden definir de forma clara y concisa en un mensaje y el mensaje produce el resultado esperado de manera coherente. Si deseas que un modelo aprenda algo específico o que se desvíe de los patrones generales de lenguaje, deberías considerar ajustar ese modelo. Por ejemplo, puedes usar el ajuste de modelos para enseñarle al modelo lo siguiente:

  • Estructuras o formatos específicos para generar salidas.
  • Comportamientos específicos, como cuándo proporcionar una salida tersa o verbosa.
  • Salidas específicas personalizadas para tipos específicos de entradas.

Los siguientes ejemplos son casos prácticos que son difíciles de capturar solo con instrucciones rápidas:

  • Clasificación: La respuesta esperada es una palabra o frase específica.

    El ajuste del modelo puede ayudar a evitar que el modelo genere respuestas detalladas.

  • Resumen: El resumen sigue un formato específico. Por ejemplo, es posible que debas quitar la información de identificación personal (PII) de un resumen de chat.

    Este formato de reemplazo de los nombres de los interlocutores con #Person1 y #Person2 es difícil de describir y el modelo de base podría no producir esa respuesta de forma natural.

  • Respuestas extractivas: La pregunta se relaciona con un contexto, y la respuesta es una substring del contexto.

    La respuesta "Último máximo glacial" (Last Glacial Maximum) es una frase específica del contexto.

  • Chat: Necesitas personalizar la respuesta del modelo para seguir a una persona, un rol o un carácter.

También puedes ajustar un modelo en las siguientes situaciones:

  • Los mensajes no producen los resultados esperados de forma coherente.
  • La tarea es demasiado complicada para definirla en una instrucción. Por ejemplo, deseas que el modelo clone el comportamiento para un comportamiento que es difícil de articular en una instrucción.
  • Tienes intuiciones complejas sobre una tarea que son fáciles de obtener, pero difíciles de formalizar en una instrucción.
  • Quieres quitar la longitud de contexto para quitar los ejemplos de tomas.

Prepara un conjunto de datos de ajuste supervisado

El conjunto de datos que se usa para ajustar un modelo de base debe incluir ejemplos que se alineen con la tarea que deseas que realice el modelo. Estructura tu conjunto de datos de entrenamiento en un formato de texto a texto. Cada registro o fila en el conjunto de datos contiene el texto de entrada (también conocido como mensaje) que se sincroniza con la salida esperada del modelo. El ajuste supervisado usa el conjunto de datos para enseñarle al modelo a imitar un comportamiento o una tarea, ya que necesitas cientos de ejemplos que ilustran ese comportamiento.

Tu conjunto de datos debe incluir un mínimo de 10 ejemplos, pero recomendamos al menos de 100 a 500 ejemplos para obtener buenos resultados. Cuantos más ejemplos proporciones en tu conjunto de datos, mejores serán los resultados.

Para ver conjuntos de datos de muestra, consulta Conjuntos de datos de muestra en esta página.

Formato del conjunto de datos

El conjunto de datos de ajuste de modelos debe estar en formato líneas JSON (JSONL), en el que cada línea contiene un solo ejemplo de ajuste. El formato del conjunto de datos que se usa para ajustar un modelo de generación de texto es diferente al formato del conjunto de datos para ajustar un modelo de chat de texto. Antes de ajustar tu modelo, debes subir tu conjunto de datos a un bucket de Cloud Storage.

Texto

Cada ejemplo está compuesto por un campo input_text que contiene el mensaje al modelo y un campo output_text que contiene una respuesta de ejemplo que se espera que el modelo ajustado produzca. Se ignoran los campos adicionales de las instrucciones estructuradas, como context.

La longitud máxima del token para input_text es 8,192 y la longitud máxima del token para output_text es 1,024. Si alguno de los campos excede la longitud máxima del token, los tokens de exceso se truncan.

La cantidad máxima de ejemplos que puede contener un conjunto de datos para un modelo de generación de texto es 10,000.

Ejemplo de conjunto de datos

{"input_text": "question: How many people live in Beijing? context:
With over 21 million residents, Beijing is the world's most populous national
capital city and is China's second largest city after Shanghai. It is
located in Northern China, and is governed as a municipality under the direct
administration of the State Council with 16 urban, suburban, and rural
districts.[14] Beijing is mostly surrounded by Hebei Province with the exception
of neighboring Tianjin to the southeast; together, the three divisions form the
Jingjinji megalopolis and the national capital region of China.",
"output_text": "over 21 million people"}


{"input_text": "question: How many parishes are there in Louisiana? context:
The U.S. state of Louisiana is divided into 64 parishes (French: paroisses) in
the same manner that 48 other states of the United States are divided into
counties, and Alaska is divided into boroughs.", "output_text": "64"}

Incluye instrucciones en los ejemplos

Para tareas como la clasificación, es posible crear un conjunto de datos de ejemplos que no contengan instrucciones. Sin embargo, excluir las instrucciones de los ejemplos en el conjunto de datos genera un peor rendimiento después del ajuste que las instrucciones, sobre todo para los conjuntos de datos más pequeños.

Excluye instrucciones:

{"input_text": "5 stocks to buy now",
"output_text": "business"}

Incluye instrucciones:

{"input_text": "Classify the following text into one of the following classes:
[business, entertainment] Text: 5 stocks to buy now",
"output_text": "business"}

Chat

Cada ejemplo de conversación en un conjunto de datos de ajuste de chat se compone de un campo messages (obligatorio) y un campo context (opcional).

El campo messages consta de un array de pares de autor-contenido. El campo author se refiere al autor del mensaje y se configura como user o assistant de forma alternada. El campo content es el contenido del mensaje. Cada ejemplo de conversación debe tener entre dos y tres pares de mensajes de asistente de usuario, que representan un mensaje del usuario y una respuesta del modelo.

El campo context te permite especificar un contexto para el chat. Si especificas un contexto para un ejemplo, se anulará el valor proporcionado en default_context.

En cada ejemplo de conversación, la longitud máxima del token para context y messages combinadas es de 8,192 tokens. Además, cada campo content para assistant no debe exceder los 1,024 tokens.

La cantidad máxima de campos author que pueden contener los ejemplos en el conjunto de datos para un modelo de chat de código es de 10,000. Este máximo es para la suma de todos los campos author en todos los messages de todos los ejemplos.

Ejemplo

{
  "context": "You are a pirate dog named Captain Barktholomew.",
  "messages": [
    {
      "author": "user",
      "content": "Hi"
    },
    {
      "author": "assistant",
      "content": "Argh! What brings ye to my ship?"
    },
    {
      "author": "user",
      "content": "What's your name?"
    },
    {
      "author": "assistant",
      "content": "I be Captain Barktholomew, the most feared pirate dog of the seven seas."
    }
  ]
}

Conjunto de datos de muestra

Puedes usar un conjunto de datos de muestra para comenzar a ajustar el modelo text-bison@002. El siguiente es un conjunto de datos de tareas de clasificación que contiene transcripciones médicas de muestra para varias especialidades médicas. Los datos son de mtsamples.com y están disponibles en Kaggle.

  • URI del conjunto de datos de ajuste de muestra:

    gs://cloud-samples-data/vertex-ai/model-evaluation/peft_train_sample.jsonl

  • URI del conjunto de datos de evaluación de muestra:

    gs://cloud-samples-data/vertex-ai/model-evaluation/peft_eval_sample.jsonl

Para usar estos conjuntos de datos, especifica los URI en los parámetros aplicables cuando crees un trabajo de ajuste supervisado del modelo de texto.

Por ejemplo:

...
"dataset_uri": "gs://cloud-samples-data/vertex-ai/model-evaluation/peft_train_sample.jsonl",
...
"evaluation_data_uri": "gs://cloud-samples-data/vertex-ai/model-evaluation/peft_eval_sample.jsonl",
...

Mantén la coherencia con los datos de producción

Los ejemplos en tu conjunto de datos deben coincidir con tu tráfico de producción esperado. Si tu conjunto de datos contiene formato, palabras clave, instrucciones o información específicas, los datos de producción deben tener el mismo formato y contener las mismas instrucciones.

Por ejemplo, si los ejemplos de tu conjunto de datos incluyen una "question:" y un "context:", el tráfico de producción también debe tener el formato de modo que incluya una "question:" y un "context:" en el mismo orden en que aparecen en ejemplos de conjuntos de datos. Si excluyes el contexto, el modelo no reconocerá el patrón, incluso si la pregunta exacta estaba en un ejemplo en el conjunto de datos.

Sube conjuntos de datos de ajuste a Cloud Storage

Para ejecutar un trabajo de ajuste, debes subir uno o más conjuntos de datos a un bucket de Cloud Storage. Puedes crear un depósito de Cloud Storage nuevo o usar uno existente para almacenar archivos de conjuntos de datos. La región del bucket no es importante, pero te recomendamos que uses un bucket que se encuentre en el mismo proyecto de Google Cloud en el que planeas ajustar tu modelo.

Una vez que tu bucket esté listo, sube tu archivo del conjunto de datos al bucket.

Configuración de la región de ajuste supervisado

Puedes especificar tres opciones de configuración de región de Google Cloud cuando configuras un trabajo de ajuste supervisado. Una región es donde se ejecuta la canalización que ajusta tu modelo. En la otra región, se ejecuta el trabajo de ajuste de modelos y se sube el modelo ajustado.

Región del trabajo de canalización

La región del trabajo de canalización es la región en la que se ejecuta el trabajo de canalización. Si no se especifica la región de carga del modelo opcional, el modelo se sube y se implementa en la región del trabajo de canalización. Los datos intermedios, como el conjunto de datos transformado, se almacenan en la región del trabajo de canalización. A fin de saber qué regiones puedes usar para la región del trabajo de canalización, consulta Regiones de trabajos de canalización compatibles y cargas de modelos. Debes especificar la región del trabajo de canalización mediante uno de los siguientes métodos:

  • Si usas el SDK de Vertex AI, puedes especificar la región en la que se ejecuta el trabajo de canalización contuning_job_location parámetro en eltune_model El método del objeto que representa el modelo que estás ajustando (por ejemplo, elTextGenerationModel.tune_modelmétodo).

  • Si creas un trabajo de ajuste supervisado mediante el envío de una solicitud POST con elpipelineJobs.create luego, usa la URL para especificar la región en la que se ejecuta el trabajo de canalización. En la siguiente URL, reemplaza ambas instancias de PIPELINE_JOB_REGION con la región donde se ejecuta la canalización:

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

  • Si usas la consola de Google Cloud para crear un trabajo de ajuste del modelo supervisado, especifica la región del trabajo de canalización en el control Región cuando crees tu trabajo de ajuste. En la consola de Google Cloud, el control de Región especifica la región del trabajo de canalización y la región de carga del modelo. Cuando usas la consola de Google Cloud para crear un trabajo de ajuste de modelo supervisado, ambas regiones siempre son iguales.

Región de carga de modelos

Usa el parámetro opcional tuned_model_location para especificar dónde se sube tu modelo ajustado. Si no se especifica la región de carga del modelo, el modelo ajustado se sube a la región del trabajo de canalización.Puedes usar uno de los trabajos de canalización admitidos y las regiones de carga de modelos para la región de carga de modelos. Puedes especificar la región de carga del modelo mediante uno de los siguientes métodos:

  • Si usas el SDK de Vertex AI, el parámetro tuned_model_location se especifica en el método tune_model del objeto que representa el modelo que estás ajustando (por ejemplo, el TextGenerationModel.tune_model).

  • Si creas un trabajo de ajuste de modelo supervisado mediante el envío de una solicitud POST mediante el uso depipelineJobs puede usar el métodolocation para especificar la región de carga del modelo.

  • Si usas la consola de Google Cloud para crear un trabajo de ajuste de modelo supervisado, especifica la región de carga del modelo en el control Región cuando crees tu trabajo de ajuste. En la consola de Google Cloud, el control de Región especifica la región de carga del modelo y la región del trabajo de canalización. Cuando usas la consola de Google Cloud para crear un trabajo de ajuste de modelos supervisados, ambas regiones siempre son las mismas.

Región de ajuste de modelos

La región de ajuste del modelo es donde se realiza el cálculo del ajuste del modelo. Esta región se determina según el tipo de acelerador que elijas. Si especificas TPU para el tipo de acelerador, el cálculo del ajuste del modelo se realiza en europe-west4. Si especificas GPU para el tipo de acelerador, el ajuste del modelo se realiza en us-central1.

Regiones de trabajo de canalización y carga de modelos compatibles

Puedes usar una de las siguientes regiones para especificar la región de carga del modelo y la región del trabajo de canalización:

  • us-central1
  • europe-west4
  • asia-southeast1
  • us-west1
  • europe-west3
  • europe-west2
  • asia-northeast1
  • us-east4
  • us-west4
  • northamerica-northeast1
  • europe-west9
  • europe-west1
  • asia-northeast3

Crea un trabajo de ajuste de modelos de texto

Puedes crear un trabajo de ajuste supervisado con la consola de Google Cloud, la API o el SDK de Vertex AI para Python. Para obtener orientación sobre las opciones de configuración del modelo, consulta Parámetro de configuración recomendadas.

REST

Para crear un trabajo de ajuste de modelos, envía una solicitud POST mediante el método pipelineJobs. Ten en cuenta que algunos de los parámetros no son compatibles con todos los modelos. Asegúrate de incluir solo los parámetros aplicables del modelo que estás ajustando.

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

  • PIPELINEJOB_DISPLAYNAME: Un nombre visible para el pipelineJob.
  • OUTPUT_DIR: El URI del bucket al que se envían los artefactos de canalización.
  • PROJECT_ID: El ID del proyecto.
  • MODEL_DISPLAYNAME*: Un nombre visible para el modelo subido (creado) por pipelineJob.
  • DATASET_URI: Es el URI del archivo de conjunto de datos.
  • PIPELINE_JOB_REGION: Es la región en la que se ejecuta el trabajo de ajuste de canalización. Esta es también la región predeterminada en la que se sube el modelo ajustado. Si deseas subir el modelo a una región diferente, usa el parámetro location para especificar la región de carga del modelo ajustada. Para obtener más información, consulta Región de carga de modelos.
  • MODEL_UPLOAD_REGION: (opcional) la región en la que se sube el modelo ajustado. Si no especificas una región de carga de modelos, el modelo ajustado se sube a la misma región en la que se ejecuta el trabajo de canalización. Para obtener más información, consulta Región de carga de modelos.
  • ACCELERATOR_TYPE (opcional, GPU predeterminado): Es el tipo de acelerador que se usará para el ajuste de modelos. Las opciones válidas son las siguientes:
    • GPU: Usa ocho GPU A100 de 80 GB para el ajuste. Asegúrate de tener cuota suficiente. Si eliges GPU, se admite VPC-SC. CMEK se admiten si la ubicación de ajuste y la ubicación de carga del modelo son us-centra1. Para obtener más información, consulta Configuración de la región de ajuste supervisado. Si eliges GPU, los cálculos de ajuste del modelo se realizarán en la región us-central1.
    • TPU: Usa 64 núcleos del pod de TPU v3 para ajustar. Asegúrate de tener cuota suficiente. CMEK no es compatible, pero se admite VPC‐SC. Si eliges TPU, los cálculos de ajuste del modelo se realizarán en la región europe-west4.
  • LARGE_MODEL_REFERENCE: El nombre del modelo de base para ajustar. Las opciones son las siguientes:
    • text-bison@002
    • chat-bison@002
  • DEFAULT_CONTEXT (chat only): Es el contexto que se aplica a todos los ejemplos de ajuste en el conjunto de datos de ajuste. Establecer el context campo “context” en un ejemplo anula el contexto predeterminado.
  • STEPS: La cantidad de pasos que se deben ejecutar para el ajuste del modelo. El valor predeterminado es 300. El tamaño del lote varía según el ajuste de la ubicación y el tamaño del modelo. Para modelos de 8,000, como text-bison@002, chat-bison@002, code-bison@002 y codechat-bison@002:
    • us-central1 tiene un tamaño de lote de 8.
    • europe-west4 tiene un tamaño de lote de 24.
    Para modelos de 32,000, como text-bison-32k, chat-bison-32k, code-bison-32k y codechat-bison-32k:
    • us-central1 tiene un tamaño de lote de 8.
    • europe-west4 tiene un tamaño de lote de 8.

    Por ejemplo, si entrenas text-bison@002 en europe-west4, hay 240 ejemplos en un conjunto de datos de entrenamiento y configuras steps como 20, entonces la cantidad de ejemplos de entrenamiento es el producto de 20 pasos y el tamaño del lote de 24 o 480 pasos de entrenamiento. En este caso, se generan dos ciclos de entrenamiento en el proceso, ya que pasa por los ejemplos dos veces. En us-central1, si hay 240 ejemplos en un conjunto de datos de entrenamiento y estableces steps en 15, la cantidad de ejemplos de entrenamiento es el producto de 15 pasos y el tamaño del lote de 8 o 120 pasos de entrenamiento. En este caso, hay 0.5 ciclos de entrenamiento porque los pasos de entrenamiento son la mitad de los ejemplos.

  • LEARNING_RATE_MULTIPLIER: Un multiplicador para aplicar a la tasa de aprendizaje recomendada. Para usar la tasa de aprendizaje recomendada, usa 1.0.
  • EVAL_DATASET_URI (text only): (opcional) El URI del archivo JSONL que contiene el conjunto de datos de evaluación para la predicción y evaluación por lotes. La evaluación no es compatible con chat-bison. Para obtener más información, consulta Formato del conjunto de datos para ajustar un modelo de código. El conjunto de datos de evaluación requiere entre diez y 250 ejemplos.
  • EVAL_INTERVAL (text only): (opcional, predeterminado 20) La cantidad de pasos de ajuste entre cada evaluación. Los intervalos de evaluación no son compatibles con los modelos de chat. Debido a que la evaluación se ejecuta en todo el conjunto de datos de evaluación, un intervalo de evaluación más pequeño da como resultado un tiempo de ajuste más largo. Por ejemplo, si steps es 200 y EVAL_INTERVAL es 100, solo obtendrás dos datos para las métricas de evaluación. Este parámetro requiere que se configure evaluation_data_uri.
  • ENABLE_EARLY_STOPPING (text only): (opcional, true predeterminado) Un boolean que, si se establece en true, deja de ajustar antes de completar todos los pasos de ajuste si el rendimiento del modelo se mide en función de lo siguiente: La precisión de los tokens previstos no mejora lo suficiente entre las ejecuciones de evaluaciones. Si es false, el ajuste continúa hasta que todos los pasos de ajuste estén completos. Este parámetro requiere que se configure evaluation_data_uri. La habilitación de la interrupción anticipada no es compatible con los modelos de chat.
  • TENSORBOARD_RESOURCE_ID: (Opcional) El ID de una instancia de TensorBoard de Vertex AI. La instancia de Vertex AI TensorBoard se usa para crear un experimento después de que se completa el trabajo de ajuste. La instancia de TensorBoard de Vertex AI debe estar en la misma región que la canalización de ajuste.
  • ENCRYPTION_KEY_NAME: (Opcional) Es el nombre completamente calificado de una clave de encriptación administrada por el cliente (CMEK) que deseas usar para la encriptación de datos. Una CMEK solo está disponible en us-central1. Si usas us-central1 y no especificas una CMEK, se usa una clave de encriptación administrada por Google. Las claves de encriptación administradas por Google se usan de forma predeterminada en todas las otras regiones disponibles. Para obtener más información, consulta la Descripción general de CMEK.
  • TEMPLATE_URI: La plantilla de ajuste que debes usar depende del modelo que estás ajustando:
    • Modelo de texto: https://us-kfp.pkg.dev/ml-pipeline/large-language-model-pipelines/tune-large-model/v2.0.0
    • Modelo de chat: https://us-kfp.pkg.dev/ml-pipeline/large-language-model-pipelines/tune-large-chat-model/v3.0.0
  • SERVICE_ACCOUNT: Es la cuenta de servicio que usa Vertex AI para ejecutar tu trabajo de canalización (opcional). De forma predeterminada, se usa la cuenta de servicio predeterminada de Compute Engine (PROJECT_NUMBER‑compute@developer.gserviceaccount.com) del proyecto. Obtén más información para vincular una cuenta de servicio personalizada.

Método HTTP y URL: 

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

Cuerpo JSON de la solicitud:

{
  "displayName": "PIPELINEJOB_DISPLAYNAME",
  "runtimeConfig": {
    "gcsOutputDirectory": "gs://OUTPUT_DIR",
    "parameterValues": {
      "project": "PROJECT_ID",
      "model_display_name": "MODEL_DISPLAYNAME",
      "dataset_uri": "gs://DATASET_URI",
      "location": "MODEL_UPLOAD_REGION",
      "accelerator_type": "ACCELERATOR_TYPE",
      "large_model_reference": "LARGE_MODEL_REFERENCE",
      "default_context": "DEFAULT_CONTEXT (chat only)",
      "train_steps": STEPS,
      "learning_rate_multiplier": LEARNING_RATE_MULTIPLIER,
      "evaluation_data_uri": "gs://EVAL_DATASET_URI (text only)",
      "evaluation_interval": EVAL_INTERVAL (text only),
      "enable_early_stopping": ENABLE_EARLY_STOPPING (text only),
      "enable_checkpoint_selection": "ENABLE_CHECKPOINT_SELECTION (text only)",
      "tensorboard_resource_id": "TENSORBOARD_ID",
      "encryption_spec_key_name": "ENCRYPTION_KEY_NAME"
    }
  },
  "encryptionSpec": {
    "kmsKeyName": "ENCRYPTION_KEY_NAME"
  },
  "serviceAccount": "SERVICE_ACCOUNT",
  "templateUri": "TEMPLATE_URI"
}

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://PIPELINE_JOB_REGION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/PIPELINE_JOB_REGION/pipelineJobs"

PowerShell

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://PIPELINE_JOB_REGION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/PIPELINE_JOB_REGION/pipelineJobs" | Select-Object -Expand Content

Deberías recibir una respuesta JSON similar a la que se muestra a continuación: Ten en cuenta que pipelineSpec se truncó para ahorrar espacio.

Python

Si deseas obtener información para instalar o actualizar el SDK de 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. 

from __future__ import annotations

from typing import Optional

from google.auth import default
from google.cloud import aiplatform
import pandas as pd
import vertexai
from vertexai.language_models import TextGenerationModel
from vertexai.preview.language_models import TuningEvaluationSpec

credentials, _ = default(scopes=["https://www.googleapis.com/auth/cloud-platform"])

def tuning(
    project_id: str,
    location: str,
    model_display_name: str,
    training_data: pd.DataFrame | str,
    train_steps: int = 10,
    evaluation_dataset: Optional[str] = None,
    tensorboard_instance_name: Optional[str] = None,
) -> TextGenerationModel:
    """Tune a new model, based on a prompt-response data.

    "training_data" can be either the GCS URI of a file formatted in JSONL format
    (for example: training_data=f'gs://{bucket}/{filename}.jsonl'), or a pandas
    DataFrame. Each training example should be JSONL record with two keys, for
    example:
      {
        "input_text": <input prompt>,
        "output_text": <associated output>
      },
    or the pandas DataFame should contain two columns:
      ['input_text', 'output_text']
    with rows for each training example.

    Args:
      project_id: GCP Project ID, used to initialize vertexai
      location: GCP Region, used to initialize vertexai
      model_display_name: Customized Tuned LLM model name.
      training_data: GCS URI of jsonl file or pandas dataframe of training data.
      train_steps: Number of training steps to use when tuning the model.
      evaluation_dataset: GCS URI of jsonl file of evaluation data.
      tensorboard_instance_name: The full name of the existing Vertex AI TensorBoard instance:
        projects/PROJECT_ID/locations/LOCATION_ID/tensorboards/TENSORBOARD_INSTANCE_ID
        Note that this instance must be in the same region as your tuning job.
    """
    vertexai.init(project=project_id, location=location, credentials=credentials)
    eval_spec = TuningEvaluationSpec(evaluation_data=evaluation_dataset)
    eval_spec.tensorboard = aiplatform.Tensorboard(
        tensorboard_name=tensorboard_instance_name
    )
    model = TextGenerationModel.from_pretrained("text-bison@002")

    model.tune_model(
        training_data=training_data,
        # Optional:
        model_display_name=model_display_name,
        train_steps=train_steps,
        tuning_job_location="europe-west4",
        tuned_model_location=location,
        tuning_evaluation_spec=eval_spec,
    )

    print(model._job.status)

    return model

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. 

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';
const aiplatform = require('@google-cloud/aiplatform');
const {PipelineServiceClient} = aiplatform.v1;

// Import the helper module for converting arbitrary protobuf.Value objects.
const {helpers} = aiplatform;

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'europe-west4-aiplatform.googleapis.com',
};
const model = 'text-bison@001';

const pipelineClient = new PipelineServiceClient(clientOptions);

async function tuneLLM() {
  // Configure the parent resource
  const parent = `projects/${project}/locations/${location}`;

  const parameters = {
    train_steps: helpers.toValue(trainSteps),
    project: helpers.toValue(project),
    location: helpers.toValue('us-central1'),
    dataset_uri: helpers.toValue(datasetUri),
    large_model_reference: helpers.toValue(model),
    model_display_name: helpers.toValue(modelDisplayName),
    accelerator_type: helpers.toValue('GPU'), // Optional: GPU or TPU
  };

  const runtimeConfig = {
    gcsOutputDirectory,
    parameterValues: parameters,
  };

  const pipelineJob = {
    templateUri:
      'https://us-kfp.pkg.dev/ml-pipeline/large-language-model-pipelines/tune-large-model/v2.0.0',
    displayName: 'my-tuning-job',
    runtimeConfig,
  };

  const createPipelineRequest = {
    parent,
    pipelineJob,
    pipelineJobId,
  };
  await new Promise((resolve, reject) => {
    pipelineClient.createPipelineJob(createPipelineRequest).then(
      response => resolve(response),
      e => reject(e)
    );
  }).then(response => {
    const [result] = response;
    console.log('Tuning pipeline job:');
    console.log(`\tName: ${result.name}`);
    console.log(
      `\tCreate time: ${new Date(1970, 0, 1)
        .setSeconds(result.createTime.seconds)
        .toLocaleString()}`
    );
    console.log(`\tStatus: ${result.status}`);
  });
}

await tuneLLM();

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.v1beta1.CreatePipelineJobRequest;
import com.google.cloud.aiplatform.v1beta1.LocationName;
import com.google.cloud.aiplatform.v1beta1.PipelineJob;
import com.google.cloud.aiplatform.v1beta1.PipelineJob.RuntimeConfig;
import com.google.cloud.aiplatform.v1beta1.PipelineServiceClient;
import com.google.cloud.aiplatform.v1beta1.PipelineServiceSettings;
import com.google.protobuf.Value;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

public class CreatePipelineJobModelTuningSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "PROJECT";
    String location = "europe-west4"; // europe-west4 and us-central1 are the supported regions
    String pipelineJobDisplayName = "PIPELINE_JOB_DISPLAY_NAME";
    String modelDisplayName = "MODEL_DISPLAY_NAME";
    String outputDir = "OUTPUT_DIR";
    String datasetUri = "DATASET_URI";
    int trainingSteps = 300;

    createPipelineJobModelTuningSample(
        project,
        location,
        pipelineJobDisplayName,
        modelDisplayName,
        outputDir,
        datasetUri,
        trainingSteps);
  }

  // Create a model tuning job
  public static void createPipelineJobModelTuningSample(
      String project,
      String location,
      String pipelineJobDisplayName,
      String modelDisplayName,
      String outputDir,
      String datasetUri,
      int trainingSteps)
      throws IOException {
    final String endpoint = String.format("%s-aiplatform.googleapis.com:443", location);
    PipelineServiceSettings pipelineServiceSettings =
        PipelineServiceSettings.newBuilder().setEndpoint(endpoint).build();

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (PipelineServiceClient client = PipelineServiceClient.create(pipelineServiceSettings)) {
      Map<String, Value> parameterValues = new HashMap<>();
      parameterValues.put("project", stringToValue(project));
      parameterValues.put("model_display_name", stringToValue(modelDisplayName));
      parameterValues.put("dataset_uri", stringToValue(datasetUri));
      parameterValues.put(
          "location",
          stringToValue(
              "us-central1")); // Deployment is only supported in us-central1 for Public Preview
      parameterValues.put("large_model_reference", stringToValue("text-bison@001"));
      parameterValues.put("train_steps", numberToValue(trainingSteps));
      parameterValues.put("accelerator_type", stringToValue("GPU")); // Optional: GPU or TPU

      RuntimeConfig runtimeConfig =
          RuntimeConfig.newBuilder()
              .setGcsOutputDirectory(outputDir)
              .putAllParameterValues(parameterValues)
              .build();

      PipelineJob pipelineJob =
          PipelineJob.newBuilder()
              .setTemplateUri(
                  "https://us-kfp.pkg.dev/ml-pipeline/large-language-model-pipelines/tune-large-model/v2.0.0")
              .setDisplayName(pipelineJobDisplayName)
              .setRuntimeConfig(runtimeConfig)
              .build();

      LocationName parent = LocationName.of(project, location);
      CreatePipelineJobRequest request =
          CreatePipelineJobRequest.newBuilder()
              .setParent(parent.toString())
              .setPipelineJob(pipelineJob)
              .build();

      PipelineJob response = client.createPipelineJob(request);
      System.out.format("response: %s\n", response);
      System.out.format("Name: %s\n", response.getName());
    }
  }

  static Value stringToValue(String str) {
    return Value.newBuilder().setStringValue(str).build();
  }

  static Value numberToValue(int n) {
    return Value.newBuilder().setNumberValue(n).build();
  }
}

Console

Para ajustar un modelo de texto con ajuste supervisado mediante la consola de Google Cloud, sigue estos pasos:

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

    Ir a Vertex AI Studio

  2. Haz clic en la pestaña Ajustar y sintetizar.
  3. Haz clic en Crear modelo ajustado.
  4. Haz clic en Ajuste supervisado.
  5. Configura los detalles del modelo:
    • Nombre del modelo ajustado: ingresa un nombre para el modelo ajustado.
    • Modelo base: selecciona el modelo base deseas ajustar.
    • Región: Selecciona la región en la que se ejecuta el trabajo de ajuste de canalización y en la que se implementa el modelo ajustado.
    • Directorio de salida: ingresa la ubicación de Cloud Storage en la que se almacenan los artefactos cuando se ajusta tu modelo.
  6. Expande Opciones avanzadas para establecer una configuración avanzada.
    • Pasos de entrenamiento: Ingresa la cantidad de pasos que se ejecutarán para el ajuste del modelo. El valor predeterminado es 300. El tamaño del lote varía según el ajuste de la ubicación y el tamaño del modelo. Para modelos de 8,000, como text-bison@002, chat-bison@002, code-bison@002 y codechat-bison@002:
      • us-central1 tiene un tamaño de lote de 8.
      • europe-west4 tiene un tamaño de lote de 24.
      Para modelos de 32,000, como text-bison-32k, chat-bison-32k, code-bison-32k y codechat-bison-32k:
      • us-central1 tiene un tamaño de lote de 8.
      • europe-west4 tiene un tamaño de lote de 8.

      Por ejemplo, si entrenas text-bison@002 en europe-west4, hay 240 ejemplos en un conjunto de datos de entrenamiento y configuras steps como 20, entonces la cantidad de ejemplos de entrenamiento es el producto de 20 pasos y el tamaño del lote de 24 o 480 pasos de entrenamiento. En este caso, se generan dos ciclos de entrenamiento en el proceso, ya que pasa por los ejemplos dos veces. En us-central1, si hay 240 ejemplos en un conjunto de datos de entrenamiento y estableces steps en 15, la cantidad de ejemplos de entrenamiento es el producto de 15 pasos y el tamaño del lote de 8 o 120 pasos de entrenamiento. En este caso, hay 0.5 ciclos de entrenamiento porque los pasos de entrenamiento son la mitad de los ejemplos.

    • Multiplicador de tasa de aprendizaje: Ingresa el tamaño del paso en cada iteración. El valor predeterminado es 1.
    • Tipo de acelerador: (opcional) Ingresa el tipo de acelerador que se usará para el ajuste de modelos. Las opciones válidas son las siguientes:
      • GPU: Usa ocho GPU A100 de 80 GB para el ajuste. Asegúrate de tener cuota suficiente. Si eliges GPU, se admite VPC-SC. CMEK se admiten si la ubicación de ajuste y la ubicación de carga del modelo son us-centra1. Para obtener más información, consulta Configuración de la región de ajuste supervisado. Si eliges GPU, los cálculos de ajuste del modelo se realizarán en la región us-central1.
      • TPU: Usa 64 núcleos del pod de TPU v3 para ajustar. Asegúrate de tener cuota suficiente. CMEK no es compatible, pero se admite VPC‐SC. Si eliges TPU, los cálculos de ajuste del modelo se realizarán en la región europe-west4.
    • Agrega una instancia de TensorBoard: (Opcional) El ID de una instancia de TensorBoard de Vertex AI. La instancia de Vertex AI TensorBoard se usa para crear un experimento después de que se completa el trabajo de ajuste. La instancia de TensorBoard de Vertex AI debe estar en la misma región que la canalización de ajuste.
    • Encriptación (opcional) elige usar una clave de encriptación administrada por Google o una clave de encriptación administrada por el cliente (CMEK). Una CMEK solo está disponible para la encriptación en la región us-central1. En las demás regiones disponibles, se usa una clave de encriptación administrada por Google. Para obtener más información, consulta la Descripción general de CMEK.
    • Cuenta de servicio (opcional): elige una cuenta de servicio administrada por el usuario. Una cuenta de servicio determina los recursos de Google Cloud a los que puede acceder tu código de servicio. Si no eliges una cuenta de servicio, se usa una cuenta de servicio administrada por Google que incluye los permisos adecuados para la mayoría de los modelos.
  7. Haga clic en Continue.
  8. Si deseas subir el archivo de conjunto de datos, selecciona  Subir archivo JSONL a Cloud Storage. Si tu archivo de conjunto de datos ya se encuentra en un bucket de Cloud Storage, selecciona  Archivo JSONL existente en Cloud Storage.

    Sube un archivo JSONL

    • En Seleccionar archivo JSONL, haz clic en Explorar y elige tu archivo de conjunto de datos.
    • En Ubicación del conjunto de datos, haz clic en Explorar y elige el bucket de Cloud Storage en el que deseas almacenar el archivo del conjunto de datos.

    Usa un archivo JSONL existente

    En Ruta del archivo de Cloud Storage, haz clic en Explorar y elige el bucket de Cloud Storage en el que se encuentra el archivo de conjunto de datos.
  9. Para evaluar tu modelo ajustado, selecciona Habilitar evaluación del modelo y configura la evaluación del modelo (opcional):
    • Conjunto de datos de evaluación: (opcional) El URI del archivo JSONL que contiene el conjunto de datos de evaluación para la predicción y evaluación por lotes. La evaluación no es compatible con chat-bison. Para obtener más información, consulta Formato del conjunto de datos para ajustar un modelo de código. El conjunto de datos de evaluación requiere entre diez y 250 ejemplos.
    • Intervalo de evaluación: (opcional, 20 predeterminado) La cantidad de pasos de ajuste entre cada evaluación. Los intervalos de evaluación no son compatibles con los modelos de chat. Debido a que la evaluación se ejecuta en todo el conjunto de datos de evaluación, un intervalo de evaluación más pequeño da como resultado un tiempo de ajuste más largo. Por ejemplo, si steps es 200 y EVAL_INTERVAL es 100, solo obtendrás dos datos para las métricas de evaluación. Este parámetro requiere que se configure evaluation_data_uri.
    • Habilitar la interrupción anticipada: (opcional, true predeterminado) Un boolean que, si se establece en true, detiene el ajuste antes de completar todos los pasos de ajuste si se cumplen las siguientes condiciones: El rendimiento del modelo, según lo que mide la precisión de los tokens previstos, no mejora lo suficiente entre las ejecuciones de evaluaciones. Si es false, el ajuste continúa hasta que todos los pasos de ajuste estén completos. Este parámetro requiere que se configure evaluation_data_uri. La habilitación de la interrupción anticipada no es compatible con los modelos de chat.
    • Habilitar la selección de puntos de control: cuando está habilitada, Vertex AI selecciona y muestra el punto de control con el mejor rendimiento de evaluación de modelos a partir de todos los puntos de control creados durante el trabajo de ajuste. Cuando se inhabilita, se muestra el punto de control final creado durante el trabajo de ajuste. Cada punto de control hace referencia a una instantánea del modelo durante un trabajo de ajuste.
    • Instancia de TensorBoard: el ID de una instancia de TensorBoard de Vertex AI (opcional). La instancia de Vertex AI TensorBoard se usa para crear un experimento después de que se completa el trabajo de ajuste. La instancia de TensorBoard de Vertex AI debe estar en la misma región que la canalización de ajuste.
  10. Haz clic en Iniciar ajuste.

Ejemplo del comando curl

PROJECT_ID=myproject
DATASET_URI=gs://my-gcs-bucket-uri/dataset
OUTPUT_DIR=gs://my-gcs-bucket-uri/output
ACCELERATOR_TYPE=GPU
LOCATION=us-central1

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
"https://europe-west4-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/europe-west4/pipelineJobs?pipelineJobId=tune-large-model-$(date +%Y%m%d%H%M%S)" -d \
$'{
  "displayName": "tune-llm",
  "runtimeConfig": {
    "gcsOutputDirectory": "'${OUTPUT_DIR}'",
    "parameterValues": {
      "project": "'${PROJECT_ID}'",
      "model_display_name": "The display name for your model in the UI",
      "dataset_uri": "'${DATASET_URI}'",
      "location": "'${LOCATION}'",
      "accelerator_type:": "'${ACCELERATOR_TYPE}'",
      "large_model_reference": "text-bison@002",
      "train_steps": 300,
      "learning_rate_multiplier": 1,
      "encryption_spec_key_name": "projects/myproject/locations/us-central1/keyRings/sample-key/cryptoKeys/sample-key"
    }
  },
  "encryptionSpec": {
    "kmsKeyName": "projects/myproject/locations/us-central1/keyRings/sample-key/cryptoKeys/sample-key"
  },
  "templateUri": "https://us-kfp.pkg.dev/ml-pipeline/large-language-model-pipelines/tune-large-model/v2.0.0"
}'

En la siguiente tabla, se muestran los parámetros de configuración recomendados para ajustar un modelo de base por tarea:

Tarea Cantidad de ejemplos en el conjunto de datos Pasos de entrenamiento
Clasificación Más de 100 100-500
Creación de resúmenes 100-500 200-1000
QA de extracción Más de 100 100-500
Chat Más de 200 1,000

En los pasos de entrenamiento, puedes probar más de un valor para obtener el mejor rendimiento en un conjunto de datos en particular, por ejemplo, 100, 200 o 500.

Visualiza una lista de modelos ajustados

Puedes ver una lista de modelos en tu proyecto actual, incluidos los modelos ajustados con la consola de Google Cloud o el SDK de Vertex AI para Python.

Python

Antes de probar este ejemplo, sigue las instrucciones de configuración para Python 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 Python.

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 vertexai
from vertexai.language_models import TextGenerationModel

def list_tuned_models(
    project_id: str,
    location: str,
) -> None:
    """List tuned models."""

    vertexai.init(project=project_id, location=location)
    model = TextGenerationModel.from_pretrained("text-bison@002")
    tuned_model_names = model.list_tuned_model_names()
    print(tuned_model_names)

    return tuned_model_names

Console

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

Ir a Vertex AI Model Registry

Carga un modelo de texto ajustado

El siguiente código de muestra usa el SDK de Vertex AI para Python a fin de cargar un modelo de generación de texto que se ajustó mediante el ajuste supervisado:

import vertexai
from vertexai.preview.language_models import TextGenerationModel

model = TextGenerationModel.get_tuned_model(TUNED_MODEL_NAME)

Reemplaza TUNED_MODEL_NAME por el nombre de recurso calificado del modelo ajustado. Este nombre tiene el formato projects/PROJECT_ID/locations/LOCATION/models/MODEL_ID. Puedes encontrar el ID del modelo de tu modelo ajustado en Vertex AI Model Registry.

Ajustes y métricas de evaluación

Puedes configurar un trabajo de ajuste de modelos para recopilar y, luego, informar el ajuste de modelos y las métricas de evaluación de modelos, que luego se pueden visualizar mediante Vertex AI TensorBoard.

Métricas de ajuste de modelos

Puedes configurar un trabajo de ajuste de modelos para recopilar las siguientes métricas de ajuste de chat-bison, code-bison, codechat-bison y text-bison:
  • /train_total_loss: Pérdida del conjunto de datos de ajuste en un paso de entrenamiento
  • /train_fraction_of_correct_next_step_preds: La precisión del token en un paso de entrenamiento. Una predicción individual consiste en una secuencia de tokens. Esta métrica mide la exactitud de los tokens previstos en comparación con la verdad fundamental del conjunto de datos de ajuste.
  • /train_num_predictions: Cantidad de tokens previstos en un paso de entrenamiento

Métricas de validación de modelos

Métricas de evaluación de modelos

Puedes configurar un trabajo de ajuste de modelos a fin de recopilar las siguientes métricas de evaluación para code-bison y text-bison:

  • /eval_total_loss: La pérdida del conjunto de datos de evaluación en un paso de evaluación.
  • /eval_fraction_of_correct_next_step_preds: La precisión del token en un paso de evaluación. Una predicción individual consiste en una secuencia de tokens. Esta métrica mide la exactitud de los tokens previstos en comparación con la verdad fundamental del conjunto de datos de evaluación.
  • /eval_num_predictions: Cantidad de tokens previstos en un paso de evaluación.

Las visualizaciones de métricas están disponibles después de que se completa el trabajo de ajuste del modelo. Si especificas solo un ID de instancia de Vertex AI TensorBoard y no un conjunto de datos de evaluación cuando creas el trabajo de ajuste, solo las visualizaciones para las métricas de ajuste están disponibles.

Soluciona problemas

Los siguientes temas pueden ayudarte a resolver problemas con el ajuste de un modelo de texto de base mediante el ajuste supervisado.

Si intentas ajustar un modelo, se muestra un error 500 o Internal error encountered.

Si encuentras este error 500 cuando intentas ajustar un modelo, prueba esta solución alternativa:

Ejecuta el siguiente comando de cURL para crear un conjunto de datos vacío de Vertex AI. Asegúrate de configurar el ID del proyecto en el comando.

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://europe-west4-aiplatform.googleapis.com/ui/projects/$PROJECT_ID/locations/europe-west4/datasets \
-d '{
    "display_name": "test-name1",
    "metadata_schema_uri": "gs://google-cloud-aiplatform/schema/dataset/metadata/image_1.0.0.yaml",
    "saved_queries": [{"display_name": "saved_query_name", "problem_type": "IMAGE_CLASSIFICATION_MULTI_LABEL"}]
}'

Una vez que se complete el comando, espera cinco minutos y vuelve a ajustar el modelo.

Error: Permiso “aiplatform.metadataStores.get” denegado en el recurso “…europe-west4/metadataStores/default”.

Asegúrate de que la API de Compute Engine esté habilitada y de que se otorguen a la cuenta de servicio de Compute Engine predeterminada (PROJECT_NUM‑compute@developer.gserviceaccount.com) los roles aiplatform.admin y storage.objectAdmin.

Para otorgar los roles aiplatform.admin y storage.objectAdmin a la cuenta de servicio de Compute Engine, haz lo siguiente:

  1. En la consola de Google Cloud, activa Cloud Shell.

    Activar Cloud Shell

    En la parte inferior de la consola de Google Cloud, se inicia una sesión de Cloud Shell en la que se muestra una ventana de línea de comandos. Cloud Shell es un entorno de shell con Google Cloud CLI ya instalada y con valores ya establecidos para el proyecto actual. La sesión puede tardar unos segundos en inicializarse.

    Si prefieres usar una terminal en tu máquina, instala y configura Google Cloud CLI.

  2. Adjunta el rol aiplatform.admin a tu cuenta de servicio de Compute Engine mediante el comando gcloud projects add-iam-policy-binding:

    Reemplaza lo siguiente:

    • PROJECT_ID por el ID del proyecto de Google Cloud
    • PROJECT_NUM por tu número de proyecto de Google Cloud
    gcloud projects add-iam-policy-binding PROJECT_ID --member serviceAccount:PROJECT_NUM-compute@developer.gserviceaccount.com --role roles/aiplatform.admin

  3. Adjunta el rol storage.objectAdmin a tu cuenta de servicio de Compute Engine mediante el comando gcloud projects add-iam-policy-binding:

    • PROJECT_ID por el ID del proyecto de Google Cloud
    • PROJECT_NUM por tu número de proyecto de Google Cloud
    gcloud projects add-iam-policy-binding PROJECT_ID --member serviceAccount:PROJECT_NUM-compute@developer.gserviceaccount.com  --role roles/storage.objectAdmin

Error: Vertex AI Service Agent service-{project-number}@gcp-sa-aiplatform.iam.gserviceaccount.com no tiene permiso para acceder a los proyectos del repositorio de Artifact Registry/vertex-ai-restricted/locations/us/repositories/llm.

Este error de permiso se debe a una demora de propagación. Un reintento posterior debería resolver este error.

¿Qué sigue?