Ottimizza i modelli di testo PaLM utilizzando l'ottimizzazione supervisionata

L'ottimizzazione supervisionata utilizza esempi etichettati per ottimizzare un modello. Ogni esempio dimostra l'output desiderato dal modello di testo durante l'inferenza. L'ottimizzazione supervisionata è una buona opzione quando l'output del modello non è molto complesso ed è facile da definire.

Linee guida passo passo per l'ottimizzazione supervisionata del modello di testo

Il seguente tutorial ti aiuta a imparare a utilizzare l'ottimizzazione supervisionata per: ottimizzare un modello di base del testo nella console Google Cloud.

Per seguire le indicazioni dettagliate per questa attività direttamente nella console Google Cloud, fai clic su Procedura guidata:

Procedura guidata

Flusso di lavoro per l'ottimizzazione dei modelli supervisionati

Il flusso di lavoro di ottimizzazione del modello supervisionato su Vertex AI include i seguenti passaggi:

  1. Prepara il set di dati di ottimizzazione del modello.
  2. Caricare il set di dati di ottimizzazione del modello in un bucket Cloud Storage.
  3. Crea un job di ottimizzazione del modello supervisionato.

Al termine dell'ottimizzazione, viene eseguito il deployment del modello ottimizzato in Vertex AI endpoint. Il nome dell'endpoint corrisponde al nome del modello ottimizzato. I modelli ottimizzati sono disponibili per essere selezionati in Vertex AI Studio quando vuoi per creare un nuovo prompt.

Modelli supportati

I seguenti modelli di base di testo supportano l'ottimizzazione supervisionata:

  • Generazione di testo: text-bison@002 e text-bison-32k@002
  • Chat di testo - chat-bison@002 e chat-bison-32k@002
  • Generazione del codice - code-bison@002 e text-bison-32k@002
  • Chat di codice - codechat-bison@002 e codechat-bison-32k@002
  • Incorporamenti di testo - textembedding-gecko@001 (anteprima)

Casi d'uso per l'utilizzo dell'ottimizzazione supervisionata sui modelli di testo

I modelli di testo di base funzionano bene quando l'output o l'attività previsti possono essere chiaramente e concisamente definito in un prompt, che produce costantemente l'output previsto. Se vuoi che un modello impari qualcosa di di nicchia o di specifico si discosta dai modelli linguistici generali, per ottimizzare il modello. Ad esempio, puoi utilizzare l'ottimizzazione per insegnare al modello seguenti:

  • Strutture o formati specifici per la generazione di output.
  • Comportamenti specifici, ad esempio quando fornire un output conciso o dettagliato.
  • Output personalizzati specifici per tipi di input specifici.

I seguenti esempi sono casi d'uso difficili da acquisire solo con le istruzioni prompt:

  • Classificazione: la risposta prevista è una parola o una frase specifica.

    La regolazione del modello può contribuire a evitare che generi risposte verbose.

  • Riassunto: il riassunto segue un formato specifico. Ad esempio, potrebbe essere necessario rimuovere le informazioni che consentono l'identificazione personale (PII) in una chat riassunto.

    Questa formattazione riguarda la sostituzione dei nomi degli altoparlanti con #Person1 e #Person2 è difficile da descrivere e il modello di base potrebbe non essere produrre una risposta simile.

  • Question answering estrattivo: la domanda riguarda un contesto e la risposta è una sottostringa del contesto.

    La risposta "Last Glacial Maximum" è una frase specifica del contesto.

  • Chat: devi personalizzare la risposta del modello in modo che segua un utente tipo, un ruolo o carattere.

Puoi ottimizzare un modello anche nelle seguenti situazioni:

  • I prompt non producono i risultati previsti in modo sufficientemente coerente.
  • L'attività è troppo complicata da definire in un prompt. Ad esempio, vuoi che il modello esegua la clonazione del comportamento per un comportamento difficile da esprimere in un prompt.
  • Hai intuizioni complesse su un'attività che sono facili da suscitare, ma difficili da formalizzare in un prompt.
  • Vuoi ridurre la lunghezza del contesto rimuovendo gli esempi di few-shot.

Prepara un set di dati di ottimizzazione supervisionata

Il set di dati utilizzato per ottimizzare un modello di base deve includere esempi in linea con l'attività che vuoi che venga eseguita dal modello. Struttura la formazione in formato da testo a testo. Ogni record o riga nel set di dati contiene il testo di input (chiamato anche prompt), abbinato al suo previsto dal modello. L'ottimizzazione supervisionata utilizza il set di dati per insegnare al modello a imitare un comportamento o un'attività di cui hai bisogno fornendo centinaia di esempi che illustrano questo comportamento.

Il set di dati deve includere almeno 10 esempi, ma consigliamo almeno da 100 a 500 esempi per ottenere buoni risultati. Più esempi fornisci nel tuo set di dati, migliori saranno i risultati.

Per set di dati di esempio, consulta Set di dati di esempio in questa pagina.

Formato del set di dati

Il set di dati di ottimizzazione del modello deve essere in formato JSON Lines (JSONL), in cui ogni riga contiene un singolo esempio di ottimizzazione. La il formato del set di dati utilizzato per ottimizzare un modello di generazione di testo è diverso formato del set di dati per ottimizzare un modello di chat di testo. Prima di ottimizzare il modello, devi caricare il tuo set di dati in un bucket Cloud Storage.

Testo

Ogni esempio è composto da un campo input_text che contiene il prompt il modello e un campo output_text contenente una risposta di esempio che che il modello ottimizzato dovrebbe produrre. Campi aggiuntivi da come context, vengono ignorati.

La lunghezza massima del token per input_text è 8192 e il token massimo la lunghezza di output_text è 1024. Se uno dei campi supera la lunghezza massima del token, i token in eccesso vengono troncati.

Il numero massimo di esempi che un set di dati per un modello di generazione di testo può che contiene è 10.000.

Esempio di set di dati

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

Includi istruzioni negli esempi

Per attività come la classificazione, è possibile creare un set di dati di esempi che non contengono istruzioni. Tuttavia, ad eccezione delle istruzioni fornite nelle di esempio nel set di dati determina prestazioni peggiori dopo l'ottimizzazione rispetto all'inclusione istruzioni, in particolare per set di dati più piccoli.

Istruzioni non incluse:

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

Istruzioni incluse:

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

Chat

Ogni esempio di conversazione in un set di dati di ottimizzazione della chat è composto da un messages (obbligatorio) e un campo context (facoltativo).

Il campo messages è costituito da un array di coppie autore-contenuto. Il campo author fa riferimento all'autore del messaggio ed è impostato su user o assistant in modo alternato. Il campo content è il contenuto del messaggio. Ogni esempio di conversazione deve avere da due a tre coppie di messaggi utente-assistente, che rappresentano un messaggio dell'utente e una risposta del modello.

Il campo context consente di specificare un contesto per la chat. Se specifichi un contesto per un esempio, sostituirà il valore fornito in default_context.

Per ogni esempio di conversazione, la lunghezza massima del token per context e messages combinati è 8192 token. Inoltre, ogni campo content per assistant non deve superare i 1024 token.

Il numero massimo di campi author che gli esempi nel set di dati per un modello di chat di testo possono contenere è 10.000. Questo valore massimo si riferisce alla somma di tutti i campi author in tutti i messages in tutti gli esempi.

Esempio

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

Set di dati di esempio

Puoi utilizzare un set di dati di esempio per iniziare a ottimizzare il text-bison@002 modello. Di seguito è riportato un set di dati delle attività di classificazione che contiene trascrizioni mediche campione per diverse specialità mediche. I dati provengono da mtsamples.com come resi disponibili su Kaggle.

  • URI del set di dati di ottimizzazione di esempio:

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

  • URI del set di dati di valutazione di esempio:

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

Per utilizzare questi set di dati, specifica gli URI nei parametri applicabili quando creazione di un job di ottimizzazione supervisionato di un modello di testo.

Ad esempio:

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

Mantieni la coerenza con i dati di produzione

Gli esempi nei set di dati devono corrispondere al traffico di produzione previsto. Se il set di dati contiene formattazioni, parole chiave, istruzioni o informazioni specifiche, i dati di produzione devono essere formattati allo stesso modo e contenere le stesse istruzioni.

Ad esempio, se gli esempi nel tuo set di dati includono "question:" e una proprietà "context:", anche il traffico di produzione deve essere formattato per includere un "question:" e "context:" nello stesso ordine in cui vengono visualizzati nel set di dati esempi. Se escludi il contesto, il modello non riconoscerà il pattern, anche se la domanda esatta fosse presente in un esempio del set di dati.

Carica set di dati di ottimizzazione in Cloud Storage

Per eseguire un job di ottimizzazione, devi caricare uno o più set di dati in un nel bucket Cloud Storage. Puoi crea un nuovo bucket Cloud Storage o utilizzarne uno esistente per archiviare i file dei set di dati. La regione del bucket non corrisponde importante, ma consigliamo di utilizzare un bucket che si trova nella stessa posizione il progetto Google Cloud in cui prevedi di ottimizzare il modello.

Una volta creato il bucket, carica il file del set di dati nel bucket.

Impostazioni della regione di ottimizzazione supervisionata

Quando configuri un job di ottimizzazione supervisionata, puoi specificare tre impostazioni della regione Google Cloud. Una regione è quella in cui viene eseguita la pipeline che ottimizza il modello. La in un'altra regione è quella in cui viene eseguito il job di ottimizzazione del modello e il modello ottimizzato viene caricato.

Regione del job della pipeline

La regione del job della pipeline è la regione in cui viene eseguito il job della pipeline. Se la regione caricamento modello facoltativa non è specificata, allora il modello viene caricato e sottoposto a deployment nella regione del job della pipeline. Dati intermedi, trasformato, viene archiviato nella regione del job della pipeline. Per sapere quali regioni utilizzabili per la regione del job della pipeline, vedi Regioni supportate per il caricamento di job e modelli di pipeline. Devi specificare la regione del job della pipeline utilizzando uno dei seguenti metodi:

  • Se utilizzi l'SDK Vertex AI, puoi specificare la regione in cui il job della pipeline viene eseguito utilizzando il parametro tuning_job_location nella Metodo tune_model dell'oggetto che rappresenta il modello che stai ottimizzando (ad esempio, TextGenerationModel.tune_model ).

  • Se crei un job di ottimizzazione supervisionato tramite l'invio di una richiesta POST utilizzando il pipelineJobs.create , utilizzerai l'URL per specificare la regione in cui si trova il job della pipeline viene eseguito. Nell'URL seguente, sostituisci entrambe le istanze di PIPELINE_JOB_REGION con la regione in cui viene eseguita la pipeline:

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

  • Se utilizzi la console Google Cloud per creare un job supervisionato di ottimizzazione del modello, devi specificare la regione del job di pipeline nel controllo Regione quando e creare il tuo job di ottimizzazione. Nella console Google Cloud, la regione che specifica sia la regione del job della pipeline sia la regione di caricamento del modello. Quando utilizzi la console Google Cloud per creare un job di ottimizzazione del modello supervisionato, entrambe le regioni sono sempre le stesse.

Regione di caricamento modello

Utilizza il parametro facoltativo tuned_model_location per specificare dove viene caricato il modello ottimizzato. Se la regione di caricamento del modello non è specificata, il modello ottimizzato viene caricato nella regione del job della pipeline. Puoi utilizzare una delle regioni supportate per il caricamento dei job della pipeline e dei modelli per la regione di caricamento del modello. Puoi specificare la regione di caricamento del modello utilizzando uno di questi metodi:

  • Se utilizzi l'SDK Vertex AI, il parametro tuned_model_location viene specificato nel metodo tune_model dell'oggetto che rappresenta il modello in fase di ottimizzazione (ad esempio il metodo TextGenerationModel.tune_model).

  • Se crei un job di ottimizzazione del modello supervisionato inviando una richiesta POST utilizzando il metodo pipelineJobs, puoi utilizzare il parametro location per specificare la regione di caricamento del modello.

  • Se utilizzi la console Google Cloud per creare un job supervisionato di ottimizzazione del modello, devi specificare la regione di caricamento del modello nel controllo Regione quando crei il tuo job di ottimizzazione. Nella console Google Cloud, il controllo Regione specifica sia la regione di caricamento del modello sia la regione del job della pipeline. Quando utilizzi la console Google Cloud per creare un job di ottimizzazione del modello supervisionato, entrambe le regioni sono sempre le stesse.

Regione di ottimizzazione del modello

La regione di ottimizzazione del modello è il luogo in cui avviene il calcolo dell'ottimizzazione del modello. Questa regione è determinata dal tipo di acceleratore scelto. Se specifichi TPU per il tipo di acceleratore, il calcolo dell'ottimizzazione del modello avviene in europe-west4. Se specifichi GPU per il tipo di acceleratore, l'ottimizzazione del modello avviene in us-central1.

Regioni supportate per il caricamento di modelli e job di pipeline

Puoi utilizzare una delle seguenti regioni per specificare la regione di caricamento del modello e per specificare la regione del job della 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

Crea un job di ottimizzazione supervisionato per modello di testo

Puoi creare un job di ottimizzazione di un modello di testo supervisionato utilizzando la console Google Cloud, o l'SDK Vertex AI per Python. Per indicazioni sulle configurazioni di ottimizzazione dei modelli, consulta la sezione Configurazioni consigliate.

REST

Per creare un job di ottimizzazione del modello, invia una richiesta POST utilizzando pipelineJobs. Tieni presente che alcuni parametri non sono supportati da tutti i modelli. Assicurati di includere solo i parametri applicabili per il modello che stai ottimizzando.

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

  • PIPELINEJOB_DISPLAYNAME: un display del job della pipeline.
  • OUTPUT_DIR: l'URI del bucket di cui eseguire l'output gli artefatti della pipeline.
  • PROJECT_ID: il tuo ID progetto.
  • MODEL_DISPLAYNAME: un nome visualizzato per il modello caricato (creato) dal job pipeline.
  • DATASET_URI: l'URI del file del set di dati.
  • PIPELINE_JOB_REGION: la regione in cui viene eseguito il job di ottimizzazione della pipeline. Si tratta anche della regione predefinita in cui viene caricato il modello ottimizzato. Se vuoi caricare il modello in una regione diversa, utilizza il metodo Parametro location per specificare la regione di caricamento del modello ottimizzato. Per ulteriori informazioni, vedi Regione di caricamento modello:
  • MODEL_UPLOAD_REGION: (facoltativo) La regione in cui viene caricato il modello ottimizzato. Se non specifichi una regione per il caricamento del modello, il modello ottimizzato viene caricato nella stessa regione in cui viene eseguito il job della pipeline. Per ulteriori informazioni, vedi Regione di caricamento modello:
  • ACCELERATOR_TYPE: (facoltativo, predefinito GPU) il tipo di acceleratore da utilizzare per ottimizzare il modello. Le opzioni valide sono:
    • GPU: utilizza otto GPU A100 da 80 GB per l'ottimizzazione. Assicurati di disporre di quota sufficiente. Se scegli GPU, VPC-SC è supportato. CMEK è supportata se l'ottimizzazione la località e la località di caricamento del modello sono us-centra1. Per ulteriori informazioni, vedi Impostazioni della regione di ottimizzazione supervisionata. Se scegli GPU, i calcoli di ottimizzazione del modello vengono eseguiti nella regione us-central1.
    • TPU: utilizza 64 core del pod TPU v3 per l'ottimizzazione. Assicurati di disporre di quota sufficiente. CMEK non è supportata, ma VPC‑SC è supportato. Se scegli TPU, i calcoli di ottimizzazione del modello vengono eseguiti Regione europe-west4.
  • LARGE_MODEL_REFERENCE: nome del di base da ottimizzare. Le opzioni sono:
    • text-bison@002
    • chat-bison@002
  • DEFAULT_CONTEXT (chat only): il contesto che si applica a tutti gli esempi di ottimizzazione nel set di dati di ottimizzazione. L'impostazione del campo context in un esempio sostituisce il contesto predefinito.
  • STEPS: La di passaggi da eseguire per l'ottimizzazione del modello. Il valore predefinito è 300. La dimensione del batch varia in base alla posizione di ottimizzazione e alle dimensioni del modello. Per i modelli 8K, come text-bison@002, chat-bison@002, code-bison@002 e codechat-bison@002:
    • us-central1 ha una dimensione del batch pari a 8.
    • europe-west4 ha una dimensione del batch pari a 24.
    Per i modelli 32.000, come text-bison-32k, chat-bison-32k, code-bison-32k e codechat-bison-32k:
    • us-central1 ha una dimensione del batch pari a 8.
    • europe-west4 ha una dimensione del batch pari a 8.

    Ad esempio, se stai addestrando text-bison@002 in europe-west4, ci sono 240 esempi in un set di dati di addestramento e imposti steps su 20, il numero di esempi di addestramento è il prodotto di 20 passaggi e la dimensione del batch di 24, ovvero 480 passaggi di addestramento. In questo caso, il processo di addestramento prevede due epoche, perché passa attraverso esempi due volte. In us-central1, se un set di dati di addestramento contiene 240 esempi e imposti steps su 15, il numero di esempi di addestramento è il prodotto di 15 passaggi e la dimensione del batch di 8, ovvero 120 passaggi di addestramento. In questo caso, ci sono 0,5 epoche perché ci sono metà delle fasi di addestramento rispetto agli esempi.

  • LEARNING_RATE_MULTIPLIER: A da applicare al tasso di apprendimento suggerito. Per usare il tasso di apprendimento suggerito, usa 1.0.
  • EVAL_DATASET_URI (text only): (Facoltativo) L'URI del file JSONL che contiene il set di dati di valutazione per la previsione batch e la valutazione delle prestazioni. La valutazione non è supportata per chat-bison. Per ulteriori informazioni, consulta Formato del set di dati per l'ottimizzazione di un modello di codice. Il set di dati di valutazione richiede tra 10 e 250 esempi.
  • EVAL_INTERVAL (text only): (facoltativo, valore predefinito 20) il numero di passaggi di ottimizzazione tra ogni valutazione. L'intervallo di valutazione non è supportato per i modelli di chat. Poiché la valutazione viene eseguita sull'intero set di dati di valutazione, un intervallo di valutazione inferiore determina tempi di ottimizzazione più lunghi. Ad esempio, se steps è 200 e EVAL_INTERVAL è 100, otterrai solo due punti dati per le metriche di valutazione. Questo parametro richiede l'impostazione di evaluation_data_uri.
  • ENABLE_EARLY_STOPPING (text only): (facoltativo, valore predefinito per true) Un boolean che, se impostato su true, interrompe l'ottimizzazione prima di completare tutti i passaggi se le prestazioni del modello, misurate la precisione dei token previsti, non migliora abbastanza tra le esecuzioni delle valutazioni. Se è false, l'ottimizzazione continua fino al completamento di tutti i relativi passaggi. Questo parametro richiede l'impostazione di evaluation_data_uri. L'opzione Abilita l'interruzione anticipata non è supportata per i modelli di chat.
  • TENSORBOARD_RESOURCE_ID: (Facoltativo) L'ID di un'istanza Vertex AI TensorBoard. L'istanza Vertex AI TensorBoard viene utilizzata per creare un esperimento al termine del job di ottimizzazione. L'istanza TensorBoard di Vertex AI deve trovarsi nella stessa regione della pipeline di ottimizzazione.
  • ENCRYPTION_KEY_NAME: (facoltativo) Il nome completo di una chiave di crittografia gestita dal cliente (CMEK) che vuoi utilizzare per la crittografia dei dati. Una chiave CMEK è disponibile solo in us-central1. Se utilizzi us-central1 e non specifichi una CMEK, verrà utilizzata una chiave di proprietà di Google e gestita da Google. Per impostazione predefinita, in tutte le altre regioni disponibili viene utilizzata una chiave di proprietà di Google e gestita da Google. Per maggiori informazioni informazioni, consulta la panoramica di CMEK.
  • TEMPLATE_URI: il modello di ottimizzazione da utilizzare dipende da quale modello stai ottimizzando:
    • Modello di testo: https://us-kfp.pkg.dev/ml-pipeline/large-language-model-pipelines/tune-large-model/v2.0.0
    • Modello di chat: https://us-kfp.pkg.dev/ml-pipeline/large-language-model-pipelines/tune-large-chat-model/v3.0.0
  • (Facoltativo) SERVICE_ACCOUNT: il servizio utilizzato da Vertex AI per eseguire il job della pipeline. Per impostazione predefinita, Account di servizio predefinito Compute Engine (PROJECT_NUMBER‑compute@developer.gserviceaccount.com) . Scopri di più su come collegare un account di servizio personalizzato.

Metodo HTTP e URL: 

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

Corpo JSON della richiesta: 

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

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente: 

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

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente: 

$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

Dovresti ricevere una risposta JSON simile alla seguente. Tieni presente che pipelineSpec è stato troncato per risparmiare spazio.

Python

Per scoprire come installare o aggiornare l'SDK Vertex AI per Python, vedi Installare l'SDK Vertex AI per Python. Per saperne di più, consulta la documentazione di riferimento dell'API Python. 

from __future__ import annotations

import os

from vertexai.language_models import TextGenerationModel

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")


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

    # Initialize Vertex AI
    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)
    # Example response:
    # pipeline_job = aiplatform.PipelineJob.get('projects/1234567890/locations/europe-west4/pipelineJobs/tune...
    # View Pipeline Job:
    # ...
    # PipelineState.PIPELINE_STATE_PENDING

    return model

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione Node.js riportate nella guida rapida all'utilizzo delle librerie client di Vertex AI. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Node.js di Vertex AI.

Per eseguire l'autenticazione su Vertex AI, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale. 

/**
 * 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

Prima di provare questo esempio, segui le istruzioni di configurazione Java riportate nella guida rapida all'utilizzo delle librerie client di Vertex AI. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Java di Vertex AI.

Per autenticarti in Vertex AI, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale. 

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

Per ottimizzare un modello di testo con l'ottimizzazione supervisionata utilizzando la console Google Cloud, segui questi passaggi:

  1. Nella sezione Vertex AI della console Google Cloud, vai alla pagina Vertex AI Studio.

    Vai a Vertex AI Studio

  2. Fai clic sulla scheda Ottimizzazione e distillazione.
  3. Fai clic su Crea modello ottimizzato.
  4. Fai clic su Ottimizzazione supervisionata.
  5. Configura i dettagli del modello:
    • Nome del modello ottimizzato: inserisci un nome per il modello ottimizzato.
    • Modello di base: seleziona il modello che vuoi ottimizzare.
    • Regione: Seleziona la regione in cui viene eseguito il job di ottimizzazione della pipeline e in cui viene eseguito il deployment del modello ottimizzato.
    • Directory di output: inserisci la posizione di Cloud Storage in cui vengono archiviati gli artefatti quando il modello viene ottimizzato.
  6. Espandi Opzioni avanzate per configurare le impostazioni avanzate.
    • Passaggi di addestramento: inserisci il numero di passaggi da eseguire per ottimizzare il modello. Il valore predefinito è 300. Il batch variano in base alla località di ottimizzazione e alle dimensioni del modello. Per i modelli 8K, come text-bison@002, chat-bison@002, code-bison@002 e codechat-bison@002:
      • us-central1 ha una dimensione del batch pari a 8.
      • europe-west4 ha una dimensione del batch pari a 24.
      Per i modelli 32.000, come text-bison-32k, chat-bison-32k, code-bison-32k e codechat-bison-32k:
      • us-central1 ha una dimensione del batch pari a 8.
      • europe-west4 ha una dimensione del batch pari a 8.

      Ad esempio, se stai addestrando text-bison@002 in europe-west4, ci sono 240 esempi in un set di dati di addestramento e imposti steps su 20, quindi di esempi di addestramento è il prodotto di 20 passaggi e la dimensione del batch di 24, ovvero 480 passaggi. In questo caso, il processo di addestramento prevede due epoche, perché passa attraverso esempi due volte. In us-central1, se un set di dati di addestramento contiene 240 esempi e imposti steps su 15, il numero di esempi di addestramento è il prodotto di 15 passaggi e la dimensione del batch di 8, ovvero 120 passaggi di addestramento. In questo caso, ci sono 0,5 epoche perché ci sono metà delle fasi di addestramento rispetto agli esempi.

    • Moltiplicatore del tasso di apprendimento: Inserisci il dimensione del passo a ogni iterazione. Il valore predefinito è 1.
    • (Facoltativo) Tipo di acceleratore: inserisci il tipo di acceleratore da utilizzare per ottimizzare il modello. Le opzioni valide sono:
      • GPU: utilizza otto GPU A100 da 80 GB per l'ottimizzazione. Assicurati di disporre di quota sufficiente. Se scegli GPU, quindi VPC‑SC è supportato. CMEK è supportata se l'ottimizzazione la località e la località di caricamento del modello sono us-centra1. Per ulteriori informazioni, vedi Impostazioni della regione di ottimizzazione supervisionata. Se scegli GPU, i calcoli di ottimizzazione del modello vengono eseguiti nella regione us-central1.
      • TPU: utilizza 64 core del pod TPU v3 per la regolazione. Assicurati di avere un numero sufficiente di video quota. CMEK non è supportato, ma VPC-SC è supportato. Se scelgo TPU, i calcoli di ottimizzazione del modello vengono eseguiti nella regione europe-west4.
    • Aggiungi un'istanza TensorBoard: (Facoltativo) L'ID di un'istanza Vertex AI TensorBoard. L'istanza Vertex AI TensorBoard viene utilizzata per creare un esperimento al termine del job di ottimizzazione. L'istanza TensorBoard di Vertex AI deve trovarsi nella stessa regione della pipeline di ottimizzazione.
    • Crittografia (Facoltativo) Scegli se utilizzare una chiave di proprietà e gestita da Google o una chiave di crittografia gestita dal cliente (CMEK). Una CMEK è disponibile per la crittografia solo nella regione us-central1. In tutte le altre regioni disponibili, viene utilizzata una chiave di proprietà e gestita da Google. Per ulteriori informazioni, vedi Panoramica di CMEK.
    • (Facoltativo) Account di servizio: scegli un account di servizio gestito dall'utente. Un account di servizio determina a quali risorse Google Cloud può accedere il tuo codice di servizio. Se non scegli un account di servizio, verrà utilizzato un agente di servizio che include le autorizzazioni appropriate per la maggior parte dei modelli.
  7. Fai clic su Continua.
  8. Se vuoi caricare il file del tuo set di dati, seleziona  Carica il file JSONL in Cloud Storage. Se il file del set di dati si trova già in un bucket Cloud Storage, seleziona  File JSONL esistente su Cloud Storage.

    Carica un file JSONL

    • In Seleziona file JSONL, fai clic su Sfoglia e seleziona il file del set di dati.
    • In Posizione del set di dati, fai clic su Sfoglia e seleziona il bucket Cloud Storage in cui vuoi archiviare il file del set di dati.

    Utilizzare un file JSONL esistente

    In Percorso file di Cloud Storage, fai clic su Sfoglia e seleziona il bucket Cloud Storage in cui si trova il file del set di dati individuarlo.
  9. (Facoltativo) Per valutare il modello ottimizzato, seleziona Abilita la valutazione del modello e configura la valutazione del modello:
    • (Facoltativo) Set di dati di valutazione: l'URI del file JSONL contenente il set di dati di valutazione per la previsione e la valutazione batch. La valutazione non è supportata per chat-bison. Per maggiori informazioni, vedi Formato del set di dati per dell'ottimizzazione di un modello di codice. Il set di dati di valutazione richiede tra 10 e 250 esempi.
    • (Facoltativo) Intervallo di valutazione: il numero di passaggi per l'ottimizzazione tra ogni valutazione. Il valore predefinito è 20. L'intervallo di valutazione non è supportato per i modelli di chat. Poiché la valutazione viene eseguita sull'intero set di dati di valutazione, un intervallo di valutazione inferiore determina tempi di ottimizzazione più lunghi. Ad esempio, se steps è 200 e EVAL_INTERVAL è 100, otterrai solo due punti dati per le metriche di valutazione. Questo parametro richiede l'impostazione di evaluation_data_uri.
    • (Facoltativo) Abilita l'interruzione anticipata: il valore predefinito è true. Un valore boolean che, se impostato su true, interrompe l'ottimizzazione prima di completare tutti i relativi passaggi se le prestazioni del modello non migliorano sufficientemente tra un'esecuzione della valutazione e l'altra secondo la misurazione dell'accuratezza dei token previsti. Se è false, l'ottimizzazione continua fino al completamento di tutti i relativi passaggi. Questo parametro richiede l'impostazione di evaluation_data_uri. L'opzione Abilita l'interruzione anticipata non è supportata per i modelli di chat.
    • Abilita selezione dei checkpoint: Se abilitato, Vertex AI seleziona e restituisce il checkpoint con il modello migliore le prestazioni di valutazione da tutti i checkpoint creati durante il job di ottimizzazione. Se l'opzione è disabilitata, viene restituito il checkpoint finale creato durante il job di ottimizzazione. Ogni checkpoint fa riferimento a uno snapshot durante un job di ottimizzazione.
    • (Facoltativo) Istanza TensorBoard: l'ID di un'istanza Vertex AI TensorBoard. La L'istanza di Vertex AI TensorBoard viene utilizzata per creare un esperimento dopo l'ottimizzazione il job viene completato. L'istanza TensorBoard di Vertex AI deve trovarsi nella stessa regione della pipeline di ottimizzazione.
  10. Fai clic su Avvia ottimizzazione.

Comando curl di esempio

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

La tabella seguente mostra le configurazioni consigliate per l'ottimizzazione di un modello di base in base all'attività:

Attività N. di esempi nel set di dati Passaggi di addestramento
Classificazione 100+ 100-500
Riassunto 100-500+ 200-1000
QA estrattivo 100+ 100-500
Chat Oltre 200 1000

Per i passaggi di addestramento, puoi provare più di un valore per ottenere le migliori prestazioni su un determinato set di dati, ad esempio 100, 200, 500.

Visualizza un elenco di modelli ottimizzati

Puoi visualizzare un elenco dei modelli nel tuo progetto corrente, inclusi quelli ottimizzati, utilizzando la console Google Cloud o l'SDK Vertex AI per Python.

Python

Prima di provare questo esempio, segui le istruzioni di configurazione Python riportate nella guida rapida all'utilizzo delle librerie client di Vertex AI. Per ulteriori informazioni, consulta API Python Vertex AI documentazione di riferimento.

Per autenticarti in Vertex AI, configura le credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

import vertexai

from vertexai.language_models import TextGenerationModel

# TODO(developer): Update and un-comment below line
# 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)
# Example response:
# ['projects/1234567890/locations/us-central1/models/1234567889012345',
# ...]

Console

Per visualizzare i tuoi modelli ottimizzati nella console Google Cloud, vai alla Pagina Vertex AI Model Registry.

Vai al registro dei modelli di Vertex AI

Carica un modello di testo ottimizzato

Il seguente codice di esempio utilizza l'SDK Vertex AI per Python per caricare un modello di generazione di testo ottimizzato utilizzando l'ottimizzazione supervisionata:

import vertexai
from vertexai.preview.language_models import TextGenerationModel

model = TextGenerationModel.get_tuned_model(TUNED_MODEL_NAME)

Sostituisci TUNED_MODEL_NAME con il nome qualificato della risorsa del modello ottimizzato. Questo nome ha il formato projects/PROJECT_ID/locations/LOCATION/models/MODEL_ID. Puoi trovare l'ID del modello ottimizzato in Vertex AI Model Registry.

Metriche di ottimizzazione e valutazione

Puoi configurare un job di ottimizzazione del modello per raccogliere e generare report sulle metriche di ottimizzazione e valutazione del modello, che possono essere visualizzate utilizzando Vertex AI TensorBoard.

Metriche di ottimizzazione del modello

Puoi configurare un job di ottimizzazione del modello per raccogliere le seguenti metriche di ottimizzazione per chat-bison, code-bison, codechat-bison e text-bison:
  • /train_total_loss: perdita per il set di dati di ottimizzazione in un passaggio di addestramento.
  • /train_fraction_of_correct_next_step_preds: l'accuratezza del token in un passaggio di addestramento. Una singola previsione è costituita da una sequenza di token. Questa metrica misura la precisione dei token previsti rispetto al suolo per l'ottimizzazione del set di dati.
  • /train_num_predictions: Numero di token previsti in una fase di addestramento.

Metriche di valutazione del modello

Puoi configurare un job di ottimizzazione del modello per raccogliere le seguenti metriche di valutazione per code-bison e text-bison:

  • /eval_total_loss: perdita per il set di dati di valutazione in un passaggio di valutazione.
  • /eval_fraction_of_correct_next_step_preds: l'accuratezza del token di valutazione. Una singola previsione è composta da una sequenza di token. Questo misura l'accuratezza dei token previsti rispetto alla metrica basato su dati empirici reali nel set di dati di valutazione.
  • /eval_num_predictions: numero di token previsti in un passaggio di valutazione.

Le visualizzazioni delle metriche sono disponibili al termine del job di ottimizzazione del modello. Se specifichi solo un ID istanza Vertex AI TensorBoard e non un di valutazione quando si crea il job di ottimizzazione, solo le visualizzazioni le metriche di ottimizzazione sono disponibili.

Risoluzione dei problemi

I seguenti argomenti potrebbero aiutarti a risolvere i problemi relativi all'ottimizzazione di un testo di base utilizzando l'ottimizzazione supervisionata.

Il tentativo di ottimizzare un modello restituisce un errore 500 o Internal error encountered

Se si verifica questo errore 500 durante il tentativo di ottimizzare un modello, prova questa workaround:

Esegui il seguente comando cURL per creare un set di dati Vertex AI vuoto. Assicurati di configurare l'ID progetto nel 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 volta completato il comando, attendi cinque minuti e riprova a ottimizzare il modello.

Errore: autorizzazione "aiplatform.metadataStores.get" negata per la risorsa "...europe-west4/metadataStores/default".

Assicurati che l'API Compute Engine sia abilitata e che all'account di servizio Compute Engine predefinito (PROJECT_NUM‑compute@developer.gserviceaccount.com) siano assegnati i ruoli aiplatform.admin e storage.objectAdmin.

Per concedere i ruoli aiplatform.admin e storage.objectAdmin all'account di servizio 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.

    Se preferisci usare un terminale sul tuo computer, installare e configurare Google Cloud CLI.

  2. Collega aiplatform.admin al tuo account di servizio Compute Engine, Comando gcloud projects add-iam-policy-binding:

    Sostituisci quanto segue:

    • PROJECT_ID con il tuo progetto Google Cloud ID.
    • PROJECT_NUM con il tuo progetto Google Cloud numero.
    gcloud projects add-iam-policy-binding PROJECT_ID --member serviceAccount:PROJECT_NUM-compute@developer.gserviceaccount.com --role roles/aiplatform.admin

  3. Collega storage.objectAdmin al tuo account di servizio Compute Engine, Comando gcloud projects add-iam-policy-binding:

    • PROJECT_ID con il tuo ID progetto Google Cloud.
    • PROJECT_NUM con il numero del tuo progetto Google Cloud.
    gcloud projects add-iam-policy-binding PROJECT_ID --member serviceAccount:PROJECT_NUM-compute@developer.gserviceaccount.com  --role roles/storage.objectAdmin

Errore: l'agente di servizio Vertex AI service-{project-number}@gcp-sa-aiplatform.iam.gserviceaccount.com non dispone dell'autorizzazione per accedere ai progetti del repository Artifact Registry/vertex-ai-restricted/locations/us/repositories/llm.

Questo errore di autorizzazione è dovuto a un ritardo della propagazione. Un nuovo tentativo dovrebbe risolvere l'errore.

Passaggi successivi