Régler des modèles de texte PaLM à l'aide du réglage supervisé

Le réglage supervisé utilise des exemples étiquetés afin de régler un modèle. Chaque exemple illustre la sortie que vous désirez obtenir de votre modèle de texte lors de l'inférence. Le réglage supervisé est une bonne option lorsque la sortie de votre modèle n'est pas très complexe et est facile à définir.

Conseils détaillés sur le réglage supervisé de modèle de texte

Le tutoriel guidé suivant vous explique comment utiliser le réglage supervisé pour ajuster un modèle de fondation de texte dans la console Google Cloud.

Pour obtenir des instructions détaillées sur cette tâche directement dans la console Google Cloud, cliquez sur Visite guidée :

Visite guidée

Workflow de réglage des modèles supervisé

Le workflow de réglage de modèle supervisé sur Vertex AI comprend les étapes suivantes :

  1. Préparer l'ensemble de données de réglage du modèle
  2. Importer l'ensemble de données de réglage du modèle dans un bucket Cloud Storage
  3. Créer un job de réglage d'un modèle supervisé.

Une fois le réglage du modèle terminé, le modèle réglé est déployé sur un point de terminaison Vertex AI. Le nom du point de terminaison est identique à celui du modèle réglé. Les modèles réglés peuvent être sélectionnés dans Vertex AI Studio lorsque vous souhaitez créer une requête.

Modèles compatibles

Les modèles textuels de fondation suivants sont compatibles avec le réglage supervisé :

  • Génération de texte : text-bison@002 et text-bison-32k@002
  • Chat écrit – chat-bison@002 et chat-bison-32k@002
  • Génération de code – code-bison@002 et text-bison-32k@002
  • Chat de code – codechat-bison@002 et codechat-bison-32k@002
  • Embeddings textuels : textembedding-gecko@001 (preview)

Cas d'utilisation du réglage supervisé sur des modèles de texte

Les modèles de texte de fondation fonctionnent bien lorsque la sortie ou la tâche attendue peut être définie de manière claire et concise dans une requête et que celle-ci génère systématiquement le résultat attendu. Si vous souhaitez qu'un modèle apprenne quelque chose de spécifique ou de différent des modèles généraux de langage, vous pouvez envisager de régler ce modèle. Vous pouvez par exemple utiliser les réglages de modèles pour apprendre au modèle ce qui suit :

  • Structures ou formats spécifiques pour générer la sortie.
  • Comportements spécifiques, par exemple lorsqu'il s'agit de fournir une sortie sobre ou détaillée.
  • Sorties personnalisées spécifiques pour des types d'entrées spécifiques.

Les exemples suivants sont des cas d'utilisation difficiles à capturer seulement avec des instructions de requête :

  • Classification : la réponse attendue est un mot ou une expression spécifique.

     :

    Le réglage du modèle peut empêcher le modèle de générer des réponses détaillées.

  • Synthèse : le résumé respecte un format spécifique. Par exemple, vous devrez peut-être supprimer d'un résumé de chat les informations permettant d'identifier personnellement l'utilisateur.

     :

    Ce format de remplacement des noms des locuteurs par #Person1 et #Person2 est difficile à décrire, et le modèle de fondation peut ne pas produire naturellement une telle réponse.

  • Systèmes de questions-réponses extractifs : la question porte sur un contexte et la réponse est une sous-chaîne du contexte.

     :

    La réponse "Dernière période glaciaire la plus longue" est une expression spécifique du contexte.

  • Chat : vous devez personnaliser la réponse du modèle pour suivre un persona, un rôle ou un caractère.

Vous pouvez également régler un modèle dans les situations suivantes :

  • Les requêtes ne produisent pas suffisamment les résultats souhaités.
  • La tâche est trop compliquée à définir dans une requête. Par exemple, vous souhaitez que le modèle effectue un clonage de comportement pour un comportement difficile à expliquer dans une requête.
  • Vous avez des intuitions complexes sur une tâche facile à déclencher, mais difficile à formaliser dans une requête.
  • Vous souhaitez réduire la longueur du contexte en supprimant les exemples few-shot.

Préparer un ensemble de données pour le réglage supervisé

L'ensemble de données utilisé pour régler un modèle de fondation doit inclure des exemples correspondant à la tâche que vous souhaitez que le modèle effectue. Structurer l'ensemble de données d'entraînement au format texte-vers-texte. Chaque enregistrement, ou ligne, de l'ensemble de données contient le texte d'entrée (également nommé requête) qui est associé à la sortie attendue du modèle. Le réglage supervisé utilise l'ensemble de données pour apprendre au modèle à simuler un comportement ou une tâche dont vous avez besoin, en lui transmettant des centaines d'exemples illustrant ce comportement.

Votre ensemble de données doit comporter au moins 10 exemples, mais nous vous recommandons d'utiliser au moins 100 à 500 exemples pour obtenir de bons résultats. Plus vous fournissez d'exemples dans votre ensemble de données et meilleurs seront les résultats.

Pour obtenir des exemples d'ensembles de données, consultez sur cette même page la section Exemples d'ensembles de données.

Format de l'ensemble de données

Votre ensemble de données de réglage de modèle doit être au format JSON Lines (JSONL), où chaque ligne contient un seul exemple de réglage. Le format de l'ensemble de données utilisé pour régler un modèle de génération de texte est différent de celui permettant de régler un modèle de chat textuel. Avant de régler le modèle, vous devez importer l'ensemble de données dans un bucket Cloud Storage.

Texte

Chaque exemple est composé d'un champ input_text contenant la requête vers le modèle, et d'un champ output_text contenant un exemple de réponse que le modèle réglé doit produire. Les champs supplémentaires des requêtes structurées, tels que context, sont ignorés.

La longueur maximale de jeton pour input_text est de 8 192, et la longueur maximale de jeton pour output_text de 1 024. Si l'un des champs dépasse la longueur maximale du jeton, les jetons excédentaires sont tronqués.

Un ensemble de données peut contenir 10 000 exemples au maximum pour un modèle de génération de texte.

Exemple d'ensemble de données

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

Inclure des instructions dans les exemples

Pour les tâches telles que la classification, il est possible de créer un ensemble de données d'exemples ne contenant pas d'instructions. Toutefois, exclure les instructions des exemples dans l'ensemble de données entraîne de mauvaises performances après le réglage, en particulier pour les ensembles de données plus petits.

Instructions relatives à l'exclusion :

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

Instructions incluses :

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

Chat

Chaque exemple de conversation d'un ensemble de données de réglage de chat se compose d'un champ messages (obligatoire) et d'un champ context (facultatif).

Le champ messages est constitué d'un tableau de paires auteur-contenu. Le champ author fait référence à l'auteur du message et est défini sur user ou assistant de manière alternative. Le champ content correspond au contenu du message. Chaque exemple de conversation doit comporter deux à trois paires message-assistant, représentant un message de l'utilisateur et une réponse du modèle.

Le champ context vous permet de spécifier un contexte pour le chat. Si vous spécifiez un contexte pour un exemple, il remplace la valeur fournie dans default_context.

Pour chaque exemple de conversation, la longueur maximale du jeton pour context et messages est de 8 192 jetons. De plus, chaque champ content de assistant ne doit pas dépasser 1 024 jetons.

Les exemples de l'ensemble de données d'un modèle de chat de texte peuvent contenir au maximum 10 000 champs author. Cette valeur maximale s'applique à la somme de tous les champs author de tous les messages de tous les exemples.

Exemple

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

Exemples d'ensembles de données

Vous pouvez utiliser un exemple d'ensemble de données pour commencer à régler le modèle text-bison@002. Voici un ensemble de données de tâches de classification qui contient des exemples de transcriptions médicales pour diverses spécialités médicales. Les données proviennent de la ressource mtsamples.com, telle qu'elle figure sur la plateforme Kaggle.

  • Exemple d'URI d'ensemble de données de réglage :

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

  • Exemple d'URI d'ensemble de données d'évaluation :

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

Pour utiliser ces ensembles de données, spécifiez les URI dans les paramètres applicables lors de la création d'un job de réglage supervisé d'un modèle de texte.

Exemple :

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

Assurer la cohérence des données de production

Les exemples de vos ensembles de données doivent correspondre au trafic de production attendu. Si votre ensemble de données contient une mise en forme, des mots clés, des instructions ou des informations spécifiques, les données de production doivent utiliser le même format et les mêmes instructions.

Par exemple, si les exemples de votre ensemble de données incluent "question:" et "context:", le trafic de production doit également être mis en forme de manière à inclure "question:" et "context:" dans le même ordre que les exemples de l'ensembles de données. Si vous excluez le contexte, le modèle ne reconnaît pas le modèle, même si la question exacte figurait dans un exemple de l'ensemble de données.

Importer les ensembles de données de réglage dans Cloud Storage

Pour exécuter un job de réglage, vous devez importer un ou plusieurs ensembles de données dans un bucket Cloud Storage. Vous pouvez créer un bucket Cloud Storage ou utiliser un bucket existant pour stocker les fichiers des ensembles de données. La région du bucket n'a pas d'importance, mais nous vous recommandons d'utiliser un bucket situé dans le même projet Google Cloud que celui où vous prévoyez de régler votre modèle.

Une fois votre bucket prêt, importez-y le fichier de votre ensemble de données.

Paramètres de région des réglages supervisés

Vous pouvez spécifier trois paramètres de région Google Cloud lorsque vous configurez un job de réglage supervisé. Une région est l'emplacement du pipeline qui règle le modèle. L'autre région sert à exécuter le job de réglage du modèle et à importer le modèle réglé.

Région du job de pipeline

La région du job de pipeline est celle dans laquelle le job de pipeline est exécuté. Si la région d'importation du modèle n'est pas spécifiée, le modèle est importé et déployé dans la région du job de pipeline. Les données intermédiaires, telles que l'ensemble de données transformé, sont stockées dans la région du job de pipeline. Pour connaître les régions que vous pouvez utiliser pour les jobs de pipeline, consultez la page Régions de job et d'importation de modèles compatibles. Vous devez spécifier la région du job de pipeline à l'aide de l'une des méthodes suivantes :

  • Si vous utilisez le SDK Vertex AI, vous pouvez spécifier la région dans laquelle le job de pipeline est exécuté à l'aide du paramètre tuning_job_location de la méthode tune_model de l'objet représentant le modèle que vous réglez, par exemple, la méthode TextGenerationModel.tune_model.

  • Si vous créez un job de réglage supervisé en envoyant une requête POST à l'aide de pipelineJobs.create, vous utilisez l'URL pour spécifier la région dans laquelle le job de pipeline est exécuté. Dans l'URL suivante, remplacez les deux instances de PIPELINE_JOB_REGION par la région où le pipeline est exécuté :

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

  • Si vous utilisez la console Google Cloud pour créer un job de réglage de modèle supervisé, spécifiez la région du job de pipeline dans le contrôle Région lors de la création du job de réglage. Dans la console Google Cloud, le contrôle Région spécifie à la fois la région du job de pipeline et la région d'importation du modèle. Lorsque vous utilisez la console Google Cloud pour créer un job de réglage de modèle supervisé, les deux régions sont toujours les mêmes.

Région d'importation du modèle

Vous utilisez le paramètre facultatif tuned_model_location pour spécifier l'emplacement d'importation du modèle réglé. Si la région d'importation du modèle n'est pas spécifiée, le modèle réglé est importé dans la région du job de pipeline.Vous pouvez utiliser l'une des régions de jobs de pipeline et d'importation de modèles compatibles. Vous pouvez spécifier la région d'importation du modèle à l'aide de l'une des méthodes suivantes :

  • Si vous utilisez le SDK Vertex AI, le paramètre tuned_model_location est spécifié dans la méthode tune_model de l'objet qui représente le modèle que vous réglez, par exemple, la méthode TextGenerationModel.tune_model.

  • Si vous créez un job de réglage de modèle supervisé en envoyant une requête POST à l'aide de la méthodepipelineJobs, vous pouvez utiliser la méthode location pour spécifier la région d'importation du modèle.

  • Si vous utilisez la console Google Cloud pour créer un job de réglage de modèle supervisé, spécifiez la région d'importation du modèle dans le contrôle Région lors de la création du job de réglage. Dans la console Google Cloud, le contrôle Région spécifie à la fois la région d'importation du modèle et la région du job de pipeline. Lorsque vous utilisez la console Google Cloud pour créer un job de réglage de modèle supervisé, les deux régions sont toujours les mêmes.

Région de réglage des modèles

La région de réglage du modèle est l'emplacement où s'effectue le calcul de réglage du modèle. Cette région est déterminée par le type d'accélérateur que vous choisissez. Si vous spécifiez TPU pour le type d'accélérateur, le calcul de réglage du modèle s'effectue dans europe-west4. Si vous spécifiez GPU pour le type d'accélérateur, le réglage du modèle s'effectue dans us-central1.

Régions compatibles avec les jobs de pipeline et l'importation de modèles

Vous pouvez utiliser l'une des régions suivantes pour spécifier la région d'importation du modèle et la région du job de pipeline :

  • 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

Créer un job de réglage supervisé d'un modèle de texte

Vous pouvez créer un job de réglage d'un modèle de texte supervisé à l'aide de la console Google Cloud, de l'API ou du SDK Vertex AI pour Python. Pour obtenir des conseils sur les configurations de réglage, consultez la page Configurations recommandées.

REST

Pour créer un job de réglage de modèle, envoyez une requête POST à l'aide de la méthode pipelineJobs. Notez que certains paramètres ne sont pas compatibles avec tous les modèles. Veillez à n'inclure que les paramètres applicables au modèle que vous réglez.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PIPELINEJOB_DISPLAYNAME : nom à afficher pour la tâche pipelineJob.
  • OUTPUT_DIR : URI du bucket dans lequel générer les artefacts de pipeline.
  • PROJECT_ID : l'ID de votre projet.
  • MODEL_DISPLAYNAME : nom à afficher pour le modèle importé (créé) par le pipelineJob.
  • DATASET_URI : URI du fichier de votre ensemble de données.
  • PIPELINE_JOB_REGION : région dans laquelle le job de réglage de pipeline est exécuté. Il s'agit également de la région par défaut dans laquelle le modèle réglé est importé. Si vous souhaitez importer votre modèle dans une autre région, utilisez le paramètre location pour spécifier la région d'importation du modèle réglé. Pour en savoir plus, consultez la section Région d'importation du modèle.
  • MODEL_UPLOAD_REGION : (facultatif) région dans laquelle le modèle réglé est importé. Si vous ne spécifiez pas de région d'importation du modèle, le modèle réglé est importé dans la même région que la tâche de pipeline. Pour en savoir plus, consultez la section Région d'importation du modèle.
  • ACCELERATOR_TYPE : (facultatif, valeur par défaut GPU) type d'accélérateur à utiliser pour le réglage du modèle. Les options valides sont les suivantes :
    • GPU : utilise 8 GPU A100 de 80 Go pour le réglage. Assurez-vous de disposer d'un quota suffisant. Si vous choisissez GPU, VPC-SC est compatible. CMEK est compatible si l'emplacement de réglage et d'importation du modèle est us-centra1. Pour en savoir plus, consultez la section Paramètres de région des réglages supervisés. Si vous choisissez GPU, les calculs de réglage du modèle s'effectuent dans la région us-central1.
    • TPU : utilise 64 cœurs du pod TPU v3 pour le réglage. Assurez-vous de disposer d'un quota suffisant. Les clés CMEK ne sont pas acceptées, mais VPC-SC l'est. Si vous choisissez TPU, les calculs de réglage de votre modèle s'effectuent dans la région europe-west4.
  • LARGE_MODEL_REFERENCE : nom du modèle de fondation à régler. Vous disposez des options suivantes :
    • text-bison@002
    • chat-bison@002
  • DEFAULT_CONTEXT (chat only) : contexte qui s'applique à tous les exemples de réglages dans l'ensemble de données de réglage. La définition du champ context dans un exemple remplace le contexte par défaut.
  • STEPS : Nombre d'étapes à exécuter pour le réglage du modèle. La valeur par défaut est 300. La taille de lot varie en fonction de l'emplacement de réglage et de la taille du modèle. Pour les modèles à 8 000, tels que text-bison@002, chat-bison@002, code-bison@002 et codechat-bison@002 :
    • us-central1 a une taille de lot de 8.
    • europe-west4 a une taille de lot de 24.
    Pour les modèles à 32 000, tels que text-bison-32k, chat-bison-32k, code-bison-32k et codechat-bison-32k :
    • us-central1 a une taille de lot de 8.
    • europe-west4 a une taille de lot de 8.

    Par exemple, si vous entraînez le modèle text-bison@002 dans la région europe-west4, vous allez disposer de 240 exemples dans un ensemble de données d'entraînement, et si vous définissez le paramètre steps sur 20, alors le nombre d'exemples d'entraînement va correspondre au produit du nombre d'étapes par la taille de lot, soit 20 x 24 = 480 étapes d'entraînement. Dans ce cas, le processus d'entraînement comporte deux époques, car il parcourt les exemples deux fois. Dans la région us-central1, si un ensemble de données d'entraînement contient 240 exemples et si vous définissez le paramètre steps sur 15, alors le nombre d'exemples d'entraînement va correspondre au produit du nombre d'étapes par la taille de lot, soit 15 x8 = 120 étapes d'entraînement. Dans ce cas, le processus d'entraînement ne va comporter que 0,5 époque, car le nombre d'étapes d'entraînement est inférieur de moitié au nombre d'exemples.

  • LEARNING_RATE_MULTIPLIER : multiplicateur à appliquer au taux d'apprentissage recommandé. Pour utiliser le taux d'apprentissage recommandé, utilisez 1.0.
  • EVAL_DATASET_URI (text only) : (facultatif) URI du fichier JSONL contenant l'ensemble de données d'évaluation pour la prédiction par lot et l'évaluation. L'évaluation n'est pas compatible avec chat-bison. Pour plus d'informations, consultez la page Format d'ensemble de données pour le réglage d'un modèle de code. L'ensemble de données d'évaluation nécessite entre 10 et 250 exemples.
  • EVAL_INTERVAL (text only) : (facultatif, valeur par défaut 20) nombre d'étapes de réglage entre chaque évaluation. Un intervalle d'évaluation n'est pas disponible pour les modèles de chat. Étant donné que l'évaluation s'exécute sur l'ensemble de données d'évaluation complet, un intervalle d'évaluation plus petit entraîne un temps de réglage plus long. Par exemple, si steps est égal à 200 et la valeur de EVAL_INTERVAL égale à 100, vous n'obtenez que deux points de données pour les métriques d'évaluation. Ce paramètre nécessite que evaluation_data_uri soit défini.
  • ENABLE_EARLY_STOPPING (text only) : (facultatif, valeur par défaut true) boolean qui, si la valeur est définie sur true, arrête le réglage avant d'effectuer toutes les étapes de réglage si les performances du modèle (telles que mesurées par la précision des jetons prévus) ne s'améliorent pas suffisamment entre les exécutions d'évaluations. Si elle est définie sur false, le réglage se poursuit jusqu'à ce que toutes les étapes de réglage soient terminées. Ce paramètre nécessite que evaluation_data_uri soit défini. L'arrêt prématuré n'est pas disponible pour les modèles de chat.
  • TENSORBOARD_RESOURCE_ID : (facultatif) ID d'une instance Vertex AI TensorBoard. L'instance Vertex AI TensorBoard est utilisée pour créer un test une fois la tâche de réglage terminée. L'instance Vertex AI TensorBoard doit se trouver dans la même région que le pipeline de réglage.
  • ENCRYPTION_KEY_NAME : (facultatif) nom complet d'une clé de chiffrement gérée par le client (CMEK) que vous souhaitez utiliser pour le chiffrement des données. Une clé CMEK n'est disponible que dans us-central1. Si vous utilisez us-central1 et ne spécifiez pas de CMEK, une clé appartenant à Google et gérée par Google est utilisée. Une clé appartenant à Google et gérée par Google est utilisée par défaut dans toutes les autres régions disponibles. Pour en savoir plus, consultez la page Présentation du chiffrement CMEK.
  • TEMPLATE_URI : le modèle de réglage à utiliser dépend du modèle que vous ajustez :
    • Modèle de texte : https://us-kfp.pkg.dev/ml-pipeline/large-language-model-pipelines/tune-large-model/v2.0.0
    • Modèle de chat : https://us-kfp.pkg.dev/ml-pipeline/large-language-model-pipelines/tune-large-chat-model/v3.0.0
  • SERVICE_ACCOUNT (facultatif) : compte de service utilisé par Vertex AI pour exécuter la tâche de pipeline. Par défaut, le compte de service Compute Engine par défaut de votre projet (PROJECT_NUMBER‑compute@developer.gserviceaccount.com) est utilisé. Apprenez-en plus sur l'association d'un compte de service personnalisé.

Méthode HTTP et URL : 

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

Corps JSON de la requête : 

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

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

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

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$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

Vous devriez recevoir une réponse JSON semblable à la suivante. Notez que pipelineSpec a été tronqué pour économiser de l'espace.

Python

Pour savoir comment installer ou mettre à jour le SDK Vertex AI pour Python, consultez la section Installer le SDK Vertex AI pour Python. Pour en savoir plus, consultez la documentation de référence de l'API Python. 

from __future__ import annotations

import os

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")


def tuning() -> None:
    import vertexai
    from vertexai.language_models import TextGenerationModel

    # Initialize Vertex AI
    # TODO(developer): update project_id & location
    vertexai.init(project=PROJECT_ID, location="us-central1")

    model = TextGenerationModel.from_pretrained("text-bison@002")

    # TODO(developer): Update the training data path
    tuning_job = model.tune_model(
        training_data="gs://cloud-samples-data/ai-platform/generative_ai/headline_classification.jsonl",
        tuning_job_location="europe-west4",
        tuned_model_location="us-central1",
    )

    print(tuning_job._status)
    return model

Node.js

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Node.js.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement 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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Java décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Java.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement 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.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

Pour régler un modèle de texte avec des réglages supervisés à l'aide de la console Google Cloud, procédez comme suit :

  1. Dans la section "Vertex AI" de la console Google Cloud, accédez à la page Vertex AI Studio.

    Accéder à Vertex AI Studio

  2. Cliquez sur l'onglet Régler et distiller.
  3. Cliquez sur Créer un modèle réglé.
  4. Cliquez sur Réglage supervisé.
  5. Configurez les détails du modèle :
    • Nom du modèle réglé : saisissez un nom pour votre modèle réglé.
    • Modèle de base : sélectionnez le modèle que vous souhaitez régler.
    • Région : sélectionnez la région où le job de réglage de pipeline s'exécute et où le modèle réglé est déployé.
    • Répertoire de travail : saisissez l'emplacement Cloud Storage où sont stockés les artefacts lorsque votre modèle est réglé.
  6. Développez la section Options avancées pour configurer les paramètres avancés.
    • Étapes d'entraînement : saisissez le nombre d'étapes à exécuter pour le réglage du modèle. La valeur par défaut est 300. La taille de lot varie en fonction de l'emplacement de réglage et de la taille du modèle. Pour les modèles à 8 000, tels que text-bison@002, chat-bison@002, code-bison@002 et codechat-bison@002 :
      • us-central1 a une taille de lot de 8.
      • europe-west4 a une taille de lot de 24.
      Pour les modèles à 32 000, tels que text-bison-32k, chat-bison-32k, code-bison-32k et codechat-bison-32k :
      • us-central1 a une taille de lot de 8.
      • europe-west4 a une taille de lot de 8.

      Par exemple, si vous entraînez le modèle text-bison@002 dans la région europe-west4, vous allez disposer de 240 exemples dans un ensemble de données d'entraînement, et si vous définissez le paramètre steps sur 20, alors le nombre d'exemples d'entraînement va correspondre au produit du nombre d'étapes par la taille de lot, soit 20 x 24 = 480 étapes d'entraînement. Dans ce cas, le processus d'entraînement comporte deux époques, car il parcourt les exemples deux fois. Dans la région us-central1, si un ensemble de données d'entraînement contient 240 exemples et si vous définissez le paramètre steps sur 15, alors le nombre d'exemples d'entraînement va correspondre au produit du nombre d'étapes par la taille de lot, soit 15 x8 = 120 étapes d'entraînement. Dans ce cas, le processus d'entraînement ne va comporter que 0,5 époque, car le nombre d'étapes d'entraînement est inférieur de moitié au nombre d'exemples.

    • Multiplicateur du taux d'apprentissage : saisissez la taille de pas à chaque itération. La valeur par défaut est de 1.
    • Type d'accélérateur : (facultatif) saisissez le type d'accélérateur à utiliser pour le réglage du modèle. Les options valides sont les suivantes :
      • GPU : utilise 8 GPU A100 de 80 Go pour le réglage. Assurez-vous de disposer d'un quota suffisant. Si vous choisissez GPU, VPC-SC est compatible. CMEK est compatible si l'emplacement de réglage et d'importation du modèle est us-centra1. Pour en savoir plus, consultez la section Paramètres de région des réglages supervisés. Si vous choisissez GPU, les calculs de réglage du modèle s'effectuent dans la région us-central1.
      • TPU : utilise 64 cœurs du pod TPU v3 pour le réglage. Assurez-vous de disposer d'un quota suffisant. Les clés CMEK ne sont pas acceptées, mais VPC-SC l'est. Si vous choisissez TPU, les calculs de réglage de votre modèle s'effectuent dans la région europe-west4.
    • Ajouter une instance TensorBoard : (facultatif) ID d'une instance Vertex AI TensorBoard. L'instance Vertex AI TensorBoard est utilisée pour créer un test une fois le job de réglage terminé. L'instance Vertex AI TensorBoard doit se trouver dans la même région que le pipeline de réglage.
    • Chiffrement (facultatif) : choisissez d'utiliser une clé appartenant à Google et gérée par Google, ou une clé de chiffrement gérée par le client (CMEK). Les clés CMEK ne sont disponibles que pour le chiffrement dans la région us-central1. Dans toutes les autres régions disponibles, une clé appartenant à Google et gérée par Google est utilisée. Pour en savoir plus, consultez la page Présentation du chiffrement CMEK.
    • Compte de service (facultatif) Choisissez un compte de service géré par l'utilisateur. Un compte de service détermine les ressources Google Cloud auxquelles votre code de service peut accéder. Si vous ne choisissez pas de compte de service, un agent de service doté des autorisations appropriées pour la plupart des modèles est utilisé.
  7. Cliquez sur Continuer.
  8. Si vous souhaitez importer votre fichier d'ensemble de données, sélectionnez  Importer le fichier JSONL dans Cloud Storage. Si le fichier de votre ensemble de données se trouve déjà dans un bucket Cloud Storage, sélectionnez  Fichier JSONL existant dans Cloud Storage.

    Importer un fichier JSONL

    • Dans le champ Sélectionner un fichier JSONL, cliquez sur Parcourir et sélectionnez le fichier de votre ensemble de données.
    • Dans le champ Emplacement de l'ensemble de données, cliquez sur Parcourir et sélectionnez le bucket Cloud Storage dans lequel vous souhaitez stocker le fichier de votre ensemble de données.

    Utiliser un fichier JSONL existant

    Dans Chemin d'accès du fichier Cloud Storage, cliquez sur Parcourir et sélectionnez le bucket Cloud Storage où se trouve le fichier de votre ensemble de données.
  9. (Facultatif) Pour évaluer votre modèle réglé, sélectionnez Activer l'évaluation du modèle et configurez votre évaluation du modèle :
    • Ensemble de données d'évaluation : (facultatif) URI du fichier JSONL contenant l'ensemble de données d'évaluation pour la prédiction par lot et l'évaluation. L'évaluation n'est pas compatible avec chat-bison. Pour plus d'informations, consultez la page Format d'ensemble de données pour le réglage d'un modèle de code. L'ensemble de données d'évaluation nécessite entre 10 et 250 exemples.
    • Intervalle d'évaluation : (facultatif, valeur par défaut 20) nombre d'étapes de réglage entre chaque évaluation. Un intervalle d'évaluation n'est pas disponible pour les modèles de chat. Étant donné que l'évaluation s'exécute sur l'ensemble de données d'évaluation complet, un intervalle d'évaluation plus petit entraîne un temps de réglage plus long. Par exemple, si steps est égal à 200 et la valeur de EVAL_INTERVAL égale à 100, vous n'obtenez que deux points de données pour les métriques d'évaluation. Ce paramètre nécessite que evaluation_data_uri soit défini.
    • Activer l'arrêt prématuré : (facultatif, valeur par défaut true) Une valeur boolean qui, si elle est définie sur true, arrête le réglage avant d'effectuer toutes les étapes de réglage en cas de performances du modèle comme mesuré par la précision des jetons prévus, ne s'améliore pas suffisamment entre les exécutions d'évaluations. Si elle est définie sur false, le réglage se poursuit jusqu'à ce que toutes les étapes de réglage soient terminées. Ce paramètre nécessite que evaluation_data_uri soit défini. L'arrêt prématuré n'est pas disponible pour les modèles de chat.
    • Activer la sélection de points de contrôle : Lorsque cette option est activée, Vertex AI sélectionne et renvoie le point de contrôle avec les meilleures performances d'évaluation de modèle de tous les points de contrôle créés lors de la tâche de réglage. Lorsqu'elle est désactivée, le point de contrôle final créé lors de la tâche de réglage est renvoyé. Chaque point de contrôle fait référence à un instantané du modèle lors d'une tâche de réglage.
    • Instance TensorBoard : (facultatif) ID d'une instance Vertex AI TensorBoard. L'instance Vertex AI TensorBoard est utilisée pour créer un test une fois la tâche de réglage terminée. L'instance Vertex AI TensorBoard doit se trouver dans la même région que le pipeline de réglage.
  10. Cliquez sur Commencer le réglage.

Exemple de commande 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"
}'

Le tableau suivant présente les configurations recommandées pour le réglage d'un modèle de fondation par tâche :

Tâche Nombre d'exemples dans l'ensemble de données Étapes d'entraînement
Classification Plus de 100 100-500
Synthèse 100-500+ 200-1000
Questions-réponses extractives Plus de 100 100-500
Chat Plus de 200 1 000

Pour les étapes d'entraînement, vous pouvez essayer plusieurs valeurs pour obtenir les meilleures performances sur un ensemble de données particulier (par exemple, 100, 200, 500).

Afficher la liste des modèles réglés

Vous pouvez afficher la liste des modèles de votre projet actuel, y compris de vos modèles réglés, à l'aide de la console Google Cloud ou du SDK Vertex AI pour Python.

Python

Avant d'essayer cet exemple, suivez les instructions de configuration pour Python décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Python.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

import vertexai

from vertexai.language_models import TextGenerationModel

# TODO(developer): Update project_id
# PROJECT_ID = "your-project-id"
vertexai.init(project=PROJECT_ID, location="us-central1")
model = TextGenerationModel.from_pretrained("text-bison@002")
tuned_model_names = model.list_tuned_model_names()
print(tuned_model_names)

Console

Pour afficher vos modèles réglés dans la console Google Cloud, accédez à la page Registre de modèles de Vertex AI.

Accéder à Vertex AI Model Registry

Charger un modèle de texte réglé

L'exemple de code suivant utilise le SDK Vertex AI pour Python pour charger un modèle de génération de texte réglé avec le réglage supervisé :

import vertexai
from vertexai.preview.language_models import TextGenerationModel

model = TextGenerationModel.get_tuned_model(TUNED_MODEL_NAME)

Remplacez TUNED_MODEL_NAME par le nom de ressource qualifié de votre modèle réglé. Ce nom est au format projects/PROJECT_ID/locations/LOCATION/models/MODEL_ID. Vous pouvez trouver l'ID de votre modèle réglé dans Vertex AI Model Registry.

Métriques de réglage et d'évaluation

Vous pouvez configurer une tâche de réglage de modèle pour collecter et signaler les métriques de réglage de modèle et d'évaluation du modèle, qui peuvent ensuite être visualisées à l'aide de Vertex AI TensorBoard.

Métriques de réglage du modèle

Vous pouvez configurer une tâche de réglage de modèle afin de collecter les métriques de réglage suivantes pour chat-bison, code-bison, codechat-bison et text-bison :
  • /train_total_loss : perte de l'ensemble de données de réglage à une étape d'entraînement.
  • /train_fraction_of_correct_next_step_preds : justesse du jeton à un pas d'entraînement. Une prédiction unique consiste en une séquence de jetons. Cette métrique mesure la précision des jetons prévus par rapport à la vérité terrain dans l'ensemble de données de réglage.
  • /train_num_predictions: Nombre de jetons prévus à une étape d'évaluation.

Métriques d'évaluation du modèle

Vous pouvez configurer une tâche de réglage de modèle pour collecter les métriques d'évaluation suivantes pour code-bison et text-bison :

  • /eval_total_loss : perte de l'ensemble de données d'évaluation à une étape d'évaluation.
  • /eval_fraction_of_correct_next_step_preds : justesse du jeton à une étape d'évaluation. Une prédiction unique consiste en une séquence de jetons. Cette métrique mesure la précision des jetons prévus par rapport à la vérité terrain dans l'ensemble de données d'évaluation.
  • /eval_num_predictions : nombre de jetons prédits à une étape d'évaluation.

Les visualisations des métriques sont disponibles une fois le job de réglage du modèle terminé. Si vous ne spécifiez qu'un ID d'instance Vertex AI TensorBoard et non un ensemble de données d'évaluation lorsque vous créez la tâche de réglage, seules les visualisations des métriques de réglage sont disponibles.

Dépannage

Les rubriques suivantes peuvent vous aider à résoudre les problèmes de réglage d'un modèle de texte de fondation à l'aide du réglage supervisé.

Toute tentative de réglage d'un modèle renvoie une erreur 500 ou Internal error encountered.

Si vous rencontrez cette erreur 500 lorsque vous essayez d'ajuster un modèle, essayez cette solution :

Exécutez la commande curl suivante pour créer un ensemble de données Vertex AI vide. Assurez-vous de configurer votre ID de projet dans la commande.

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

Une fois la commande terminée, attendez cinq minutes et relancez le réglage du modèle.

Erreur : Permission 'aiplatform.metadataStores.get' denied on resource '...europe-west4/metadataStores/default'.

Assurez-vous que l'API Compute Engine est activée et que le compte de service Compute Engine par défaut (PROJECT_NUM‑compute@developer.gserviceaccount.com) dispose des rôles aiplatform.admin et storage.objectAdmin.

Procédez comme suit pour attribuer les rôles aiplatform.admin et storage.objectAdmin au compte de service Compute Engine :

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

    Si vous préférez utiliser un terminal sur votre ordinateur, installez et configurez la Google Cloud CLI.

  2. Associez le rôle aiplatform.admin à votre compte de service Compute Engine à l'aide de la commande gcloud projects add-iam-policy-binding :

    Remplacez les éléments suivants :

    • PROJECT_ID par l'ID de votre projet Google Cloud
    • PROJECT_NUM par le numéro de votre projet Google Cloud
    gcloud projects add-iam-policy-binding PROJECT_ID --member serviceAccount:PROJECT_NUM-compute@developer.gserviceaccount.com --role roles/aiplatform.admin

  3. Associez le rôle storage.objectAdmin à votre compte de service Compute Engine à l'aide de la commande gcloud projects add-iam-policy-binding :

    • PROJECT_ID par l'ID de votre projet Google Cloud
    • PROJECT_NUM par le numéro de votre projet Google Cloud
    gcloud projects add-iam-policy-binding PROJECT_ID --member serviceAccount:PROJECT_NUM-compute@developer.gserviceaccount.com  --role roles/storage.objectAdmin

Erreur : Vertex AI Service Agent service-{project-number}@gcp-sa-aiplatform.iam.gserviceaccount.com does not have permission to access Artifact Registry repository projects/vertex-ai-restricted/locations/us/repositories/llm.

Cette erreur d'autorisation est due à un délai de propagation. Une nouvelle tentative devrait résoudre cette erreur.

Étapes suivantes