Ottimizza i modelli di testo PaLM mediante l'ottimizzazione supervisionata

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

• Se l'output del modello è difficile da definire, ti consigliamo di ottimizzare il modello di testo utilizzando l'ottimizzazione dell'apprendimento per rinforzo con feedback umano (RLHF).
• Per scoprire di più sull'ottimizzazione di un modello di codice con l'ottimizzazione supervisionata, consulta Ottimizzare i modelli di codice.

Istruzioni passo passo per l'ottimizzazione supervisionata del modello di testo

Il seguente tutorial guidato ti aiuta a scoprire come utilizzare l'ottimizzazione supervisionata per ottimizzare un modello di base di 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 per l'ottimizzazione del modello.
2. Carica 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, il modello viene implementato in un endpoint Vertex AI. Il nome dell'endpoint è uguale al nome del modello ottimizzato. I modelli ottimizzati sono disponibili per la selezione in Vertex AI Studio quando vuoi 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 di 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 definiti in modo chiaro e conciso in un prompt e il prompt produce in modo coerente l'output previsto. Se vuoi che un modello apprenda qualcosa di poco noto o specifico che si discosta dai modelli linguistici generali, ti consigliamo di ottimizzarlo. Ad esempio, puoi utilizzare la regolazione del modello per insegnare al modello quanto segue:

• 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 specifici di input.

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.

  Prompt: Classifica il seguente testo in una delle seguenti classi: [business, entertainment]. Testo: Diversifica il tuo portafoglio di investimenti Risposta: attività

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

• Riassunto: il riassunto segue un formato specifico. Ad esempio, potresti dover rimuovere informazioni che consentono l'identificazione personale (PII) nel riepilogo di una chat.

  Prompt: Riassumi: Jessica: Ottimo! Ci vediamo a Times Square. Alexander: Ci vediamo alle 10. Risposta: #Persona1 e #Persona2 decidono di incontrarsi a Times Square alle 10:00.

  Questa formattazione che sostituisce i nomi degli altoparlanti con #Person1 e #Person2 è difficile da descrivere e il modello di base potrebbe non produrre una risposta naturale di questo tipo.

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

  Prompt: Contesto: ci sono prove che dimostrano che negli ultimi 21.000 anni si sono verificati cambiamenti significativi nella vegetazione della foresta pluviale amazzonica durante l'ultimo massimo glaciale (LGM) e la successiva deglaciazione. Domanda: che cosa significa LGM? Risposta: Last Glacial Maximum

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

• Chat: devi personalizzare la risposta del modello in base a una persona, un ruolo o un personaggio.

  Prompt: Utente: Che tempo fa oggi? Risposta: Assistente: in qualità di negoziante virtuale di Lola Lollipops, posso aiutarti solo con gli acquisti e la spedizione.

Puoi ottimizzare un modello anche nelle seguenti situazioni:

• I prompt non producono i risultati previsti in modo sufficientemente coerente.
• L'attività è troppo complicata per essere definita 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 con pochi esempi.

Preparare 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 il set di dati di addestramento in formato da testo a testo. Ogni record o riga del set di dati contiene il testo di input (chiamato anche prompt) associato all'output 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 per ottenere buoni risultati consigliamo di includerne almeno da 100 a 500. Più esempi fornisci nel tuo set di dati, migliori saranno i risultati.

Per i 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. Il formato del set di dati utilizzato per ottimizzare un modello di generazione di testo è diverso da quello del set di dati per l'ottimizzazione di un modello di chat di testo. Prima di ottimizzare il modello, devi caricare il set di dati in un bucket Cloud Storage.

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

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

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

{
  "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 di attività di classificazione che contiene trascrizioni mediche di esempio per varie 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 crei un job di ottimizzazione supervisionata del 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 "context:", anche il traffico di produzione deve essere formattato in modo da includere "question:" e "context:" nello stesso ordine in cui appare negli esempi di set di dati. 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 i set di dati di ottimizzazione in Cloud Storage

Per eseguire un job di ottimizzazione, devi caricare uno o più set di dati in un bucket Cloud Storage. Puoi creare un nuovo bucket Cloud Storage o utilizzarne uno esistente per archiviare i file del set di dati. La regione del bucket non è importante, ma ti consigliamo di utilizzare un bucket nello stesso 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 è la regione in cui viene eseguita la pipeline che ottimizza il modello. L'altra regione è quella in cui viene eseguito il job di ottimizzazione del modello e viene caricato il modello ottimizzato.

Regione del job della pipeline

La regione del job della pipeline è la regione in cui viene eseguito il job della pipeline. Se non viene specificata la regione di caricamento del modello facoltativa, il modello viene caricato e di cui viene eseguito il deployment nella regione del job della pipeline. I dati intermedi, come il set di dati trasformato, vengono archiviati nella regione del job della pipeline. Per scoprire quali regioni puoi utilizzare per la regione del job della pipeline, consulta Regioni supportate per i job della pipeline e il caricamento dei modelli. 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 viene eseguito il job della pipeline utilizzando il parametro tuning_job_location nel metodo tune_model dell'oggetto che rappresenta il modello che stai ottimizzando (ad esempio il metodo TextGenerationModel.tune_model).

• Se crei un job di ottimizzazione supervisionata inviando una richiesta POST utilizzando il metodo pipelineJobs.create, utilizza l'URL per specificare la regione in cui viene eseguito il job della pipeline. 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 di ottimizzazione del modello supervisionato, devi specificare la regione del job della pipeline nel controllo Regione quando crei il job di ottimizzazione. Nella console Google Cloud, il controllo Regione 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 del 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 del modello e dei job della pipeline 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 che stai ottimizzando (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 di ottimizzazione del modello supervisionato, specifica la regione di caricamento del modello nel controllo Regione quando crei il 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 job della pipeline e modelli

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

Creare un job di ottimizzazione supervisionata per i modelli di testo

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

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

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

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"

$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

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION/pipelineJobs/PIPELINEJOB_ID",
  "displayName": "PIPELINEJOB_DISPLAYNAME",
  "createTime": "CREATE_TIME",
  "updateTime": "UPDATE_TIME",
  "pipelineSpec": { ... },
  "state": "PIPELINE_STATE_PENDING",
  "labels": {
    "vertex-ai-pipelines-run-billing-id": "BILLING_ID"
  },
  "runtimeConfig": {
    "gcsOutputDirectory": "gs://OUTPUT_DIR",
    "parameterValues": {
      "project": "PROJECT_ID",
      "model_display_name": "MODEL_DISPLAYNAME",
      "dataset_uri": "gs://DATASET_URI",
      "evaluation_data_uri": "EVAL_DATASET_URI",
      "evaluation_interval": "EVAL_INTERVAL",
      "enable_early_stopping": "ENABLE_EARLY_STOPPING",
      "enable_checkpoint_selection": "ENABLE_CHECKPOINT_SELECTION",
      "tensorboard_resource_id": "TENSORBOARD_RESOURCE_ID",
      "accelerator_type": "ACCELERATOR_TYPE",
      "location": "MODEL_UPLOAD_REGION",
      "large_model_reference": "text-bison@002",
      "train_steps": STEPS,
      "learning_rate_multiplier": "LEARNING_RATE_MULTIPLIER",
      "encryption_spec_key_name": "ENCRYPTION_KEY_NAME"
    }
  },
  "serviceAccount": "PROJECT_NUMBER-compute@developer.gserviceaccount.com",
  "templateUri": "https://us-kfp.pkg.dev/ml-pipeline/large-language-model-pipelines/tune-large-model/v2.0.0",
  "templateMetadata": {
    "version": "sha256:c54b301482463df457b923faff255c528be7d1164531aa756b5974b3dc214b98"
  }
}

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

/**
 * 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();

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();
  }
}

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

Configurazioni consigliate

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

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.

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',
# ...]

Carica un modello di testo ottimizzato

Il seguente codice campione 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 della risorsa qualificata del modello ottimizzato. Questo nome ha il formato projects/PROJECT_ID/locations/LOCATION/models/MODEL_ID. Puoi trovare l'ID modello 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

• /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 l'accuratezza dei token previsti rispetto ai dati empirici reali nel set di dati di ottimizzazione.
• /train_num_predictions: Numero di token previsti in un passaggio 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 in un passaggio di valutazione. Una singola previsione è costituita da una sequenza di token. Questa metrica misura l'accuratezza dei token previsti rispetto ai 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 set di dati di valutazione quando crei il job di ottimizzazione, sono disponibili solo le visualizzazioni per le metriche di ottimizzazione.

Risoluzione dei problemi

I seguenti argomenti potrebbero aiutarti a risolvere i problemi di ottimizzazione di un modello di 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"}]
}'

Al termine del 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 utilizzare un terminale sulla tua macchina, installa e configura Google Cloud CLI.

2. Associa il ruolo aiplatform.admin al tuo account di servizio Compute Engine utilizzando il comando gcloud projects add-iam-policy-binding:

   Sostituisci quanto segue:

   • 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/aiplatform.admin
   

3. Associa il ruolo storage.objectAdmin al tuo account di servizio Compute Engine utilizzando il 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 al repository Artifact Registry projects/vertex-ai-restricted/locations/us/repositories/llm.

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

Passaggi successivi

• Scopri come valutare un modello ottimizzato.
• Scopri come ottimizzare un modello di base utilizzando l'ottimizzazione RLHF.
• Scopri come ottimizzare un modello di codice.