Textmodelle mit überwachter Abstimmung optimieren

Die überwachte Abstimmung verwendet Labels, um ein Modell zu optimieren. Jedes Beispiel zeigt die Ausgabe, die Sie von Ihrem Textmodell während der Inferenz verwenden möchten. Die überwachte Abstimmung ist eine gute Option, wenn die Ausgabe Ihres Modells nicht sehr komplex und einfach zu definieren ist. Wenn die Ausgabe Ihres Modells schwierig zu definieren ist, sollten Sie Ihr Textmodell mithilfe von bestärkendem Lernen durch menschliches Feedback („Reinforcement learning from human feedback“, RLHF) optimieren.

Schritt-für-Schritt-Anleitung für die überwachte Abstimmung eines Textmodells

In der folgenden Anleitung wird erläutert, wie Sie mithilfe der überwachten Abstimmung ein Textgrundlagemodell in der Google Cloud Console optimieren.

Klicken Sie auf Anleitung, um eine detaillierte Anleitung für diese Aufgabe direkt in der Google Cloud Console aufzurufen.

Anleitung

Unterstützte Modelle

Die folgenden Textmodelle unterstützen die überwachte Abstimmung:

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

Anwendungsfälle für die Verwendung der überwachten Abstimmung von Textmodellen

Foundation-Textmodelle funktionieren gut, wenn die erwartete Ausgabe oder Aufgabe in einem Prompt klar und präzise definiert werden kann und der Prompt konsistent die erwartete Ausgabe erzeugt. Wenn Sie möchten, dass ein Modell bestimmte Nischenthemen oder Besonderheiten lernt, die von den allgemeinen Sprachmustern abweichen, sollten Sie das Modell entsprechend abstimmen. Sie können das Modell zum Beispiel mithilfe der Modellabstimmung Folgendes antrainieren:

• Bestimmte Strukturen oder Formate zum Generieren einer Ausgabe.
• Spezifisches Verhalten, z. B. wenn eine grobe oder ausführliche Ausgabe bereitgestellt werden soll.
• Bestimmte benutzerdefinierte Ausgaben für bestimmte Eingabetypen angeben.

Bei den folgenden Beispielen handelt es sich um Anwendungsfälle, die sich nur schwer mit Eingabeaufforderungen erfassen lassen:

• Klassifizierung: Die erwartete Antwort ist ein bestimmtes Wort oder eine bestimmte Wortgruppe.

  Prompt: Klassifizieren Sie folgenden Text in eine der folgenden Klassen: [Wirtschaft, Unterhaltung]. Text: Investitionsportfolio diversifizieren Antwort: Geschäftswelt

  Durch Abstimmung des Modells kann verhindert werden, dass das Modell ausführliche Antworten generiert.

• Zusammenfassung: Die Zusammenfassung folgt einem bestimmten Format. Es kann beispielsweise vorkommen, dass Sie personenidentifizierbare Informationen aus einer Chatzusammenfassung entfernen müssen.

  Prompt: Zusammenfassung: Jessica: Das klingt toll! Wir sehen uns auf dem Times Square! Alexander: Wir sehen uns um 10! Lösung: #Person1 und #Person2 machen ab, sich um 10:00 Uhr am Times Square zu treffen.

  Das Format der Ersetzung der Namen der Sprecher durch #Person1 und #Person2 ist schwierig zu beschreiben. Das Foundation Model erzeugt möglicherweise keine solche Antwort.

• Antwort auf Extraktionsfrage: Die Frage bezieht sich auf einen Kontext und die Antwort ist ein Teilstring des Kontexts.

  Prompt: Kontext: Es gibt Hinweise dafür, dass es in den letzten 21.000 Jahren durch das Letzteiszeitliche Maximum (LGM) und die folgende Entgletscherung zu deutlichen Veränderungen in der Vegetation des amazonischen Regenwalds kam. Frage: Wofür steht LGM? Antwort: Letzteiszeitliche Maximum

  Die Antwort "Last Glacial Maximum" ist eine spezifische Wortgruppe aus dem Kontext.

• Chat: Sie müssen die Modellantwort anpassen, damit sie einer Identität, einer Rolle oder einem Zeichen genügt.

  Prompt: Nutzer: Wie ist das Wetter heute? Antwort: Assistent: Als virtuelle Verkäuferin von Lola Lollipop kann ich Ihnen nur beim Kauf und beim Versand helfen.

Sie können ein Modell auch in folgenden Situationen optimieren:

• Prompts führen nicht konsistent zu den erwarteten Ergebnissen.
• Die Aufgabe ist zu kompliziert, um sie in einem Prompt zu definieren. Beispiel: Das Modell soll ein Verhalten klonen, das nur schwer in einem Prompt zu beschreiben ist.
• Sie haben komplexe Ahnungen über eine Aufgabe, die leicht zu erahnen, aber schwierig in einem Prompt zu formalisieren ist.
• Sie möchten die Beispiele für Schnellerstellungen entfernen, um die Kontextlänge zu reduzieren.

Überwachtes Abstimmungs-Dataset vorbereiten

Das Dataset zum Optimieren eines Basismodells muss Beispiele enthalten, die der Aufgabe entsprechen, die das Modell ausführen soll. Strukturieren Sie Ihr Trainings-Dataset in einem Text-zu-Text-Format. Jeder Eintrag oder jede Zeile im Dataset enthält den Eingabetext (auch als Eingabeaufforderung bezeichnet), der mit der erwarteten Ausgabe des Modells gekoppelt ist. Bei der überwachten Abstimmung wird das Dataset verwendet, um dem Modell zu vermitteln, ein Verhalten oder eine Aufgabe nachzuahmen. Dazu verwenden Sie Hunderte von Beispielen, die dieses Verhalten veranschaulichen.

Ihr Dataset muss mindestens 10 Beispiele enthalten. Für gute Ergebnisse empfehlen wir mindestens 100 bis 500 Beispiele. Je mehr Beispiele Sie in Ihrem Dataset angeben, desto besser sind die Ergebnisse.

Beispiel-Datasets finden Sie auf dieser Seite unter Beispiel-Datasets.

Dataset-Format

Ihr Dataset zur Abstimmung eines Modells muss im JSON Lines-Format (JSONL) vorliegen, wobei jede Zeile ein einzelnes Abstimmungsbeispiel enthält. Das Dataset-Format zum Optimieren eines Textgenerierungsmodells unterscheidet sich vom Dataset-Format zum Optimieren eines Textchat-Modells. Bevor Sie Ihr Modell optimieren, müssen Sie Ihr Dataset in einen Cloud Storage-Bucket hochladen.

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

Beispieldatensätze

Sie können ein Beispiel-Dataset verwenden, um mit der Abstimmung des Modells text-bison@002 zu beginnen. Im Folgenden finden Sie ein Dataset zur Klassifizierungsaufgabe, das Beispiele für medizinische Transkriptionen für verschiedene medizinische Spezialisierungen enthält. Die Daten stammen von mtsamples.com, wie auf Kaggle zur Verfügung gestellt.

• Beispiel für den URI der Feinabstimmung eines Datasets:

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

• Beispiel für einen Evaluierungs-Dataset-URI:

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

Geben Sie die URIs in den entsprechenden Parametern beim Erstellen eines überwachten Abstimmungsjobs für ein Textmodell an, um diese Datasets zu verwenden.

Beispiel:

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

Konsistenz mit Produktionsdaten gewährleisten

Die Beispiele in Ihren Datasets sollten dem erwarteten Produktionstraffic entsprechen. Wenn Ihr Dataset bestimmte Formatierungen, Keywords, Anleitungen oder Informationen enthält, sollten die Produktionsdaten auf die gleiche Weise formatiert sein und die gleichen Anweisungen enthalten.

Wenn die Beispiele in Ihrem Dataset beispielsweise ein "question:" und ein "context:" enthalten, sollte der Produktionstraffic ebenfalls so formatiert werden, dass er ein "question:" und ein "context:" in der gleichen Reihenfolge wie in den Dataset-Beispielen enthält. Wenn Sie den Kontext ausschließen, erkennt das Modell das Muster nicht, selbst wenn die genaue Frage in einem Beispiel im Dataset vorkommt.

Abstimmungs-Datasets in Cloud Storage hochladen

Zum Ausführen eines Abstimmungsjobs müssen Sie ein oder mehrere Datasets in einen Cloud Storage-Bucket hochladen. Sie können entweder einen neuen Cloud Storage-Bucket erstellen oder einen vorhandenen Bucket zum Speichern von Dataset-Dateien verwenden. Die Region des Buckets spielt keine Rolle. Wir empfehlen jedoch die Verwendung eines Buckets im selben Google Cloud-Projekt, in dem Sie die Modellabstimmung ausführen möchten.

Wenn der Bucket bereit ist, laden Sie Ihre Dataset-Datei in den Bucket hoch.

Einstellungen: Überwachte Feinabstimmungsregion

Beim Konfigurieren eines überwachten Abstimmungsjobs können drei Google Cloud-Regionseinstellungen festgelegt werden. In einer Region wird die Pipeline ausgeführt, die Ihr Modell optimiert. In der anderen Region wird der Modellabstimmungsjob ausgeführt und das abgestimmte Modell wird hochgeladen.

Pipelinejobregionen

Die Pipelinejobregion ist die Region, in der der Pipelinejob ausgeführt wird. Wenn die optionale Modelluploadregion nicht angegeben ist, wird das Modell in die Pipelinejobregion hochgeladen und dort bereitgestellt. Zwischendaten, wie das transformierte Dataset, werden in der Pipelinejobregion gespeichert. Informationen dazu, welche Regionen als Pipelinejobregion verwendt werden können, finden Sie unter Unterstützte Pipelinejob- und Modelluploadregionen. Sie müssen die Pipelinejobregion auf eine der folgenden Methoden angeben:

• Wenn Sie das Vertex AI SDK verwenden, können Sie die Region, in der der Pipelinejob ausgeführt wird, mit dem tuning_job_location-Parameter für die tune_model-Methode des Objekts, das das abzustimmende Modell darstellt (z. B. die TextGenerationModel.tune_model-Methode).

• Wenn Sie einen überwachten Abstimmungsjob durch Senden einer POST-Anfrage mit der pipelineJobs.create-Methode erstellen, verwenden Sie die URL, um die Region anzugeben, in der der Pipelinejob ausgeführt wird. Ersetzen Sie in der folgenden URL beide Instanzen von PIPELINE_JOB_REGION durch die Region, in der die Pipeline ausgeführt wird:

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

• Wenn Sie die Google Cloud Console verwenden, um einen überwachten Modellabstimmungsjob zu erstellen, geben Sie die Pipelinejobregion in der Regionssteuerung bei der Erstellung der Region an. In der Google Cloud Console gibt die Regionssteuerung sowohl die Pipelinejob- als auch die Modelluploadregion an. Wenn Sie die Google Cloud Console zum Erstellen eines überwachten Jobs zur Feinabstimmung des Modells verwenden, sind beide Regionen immer identisch.

Modelluploadregionen

Mit dem optionalen Parameter tuned_model_location geben Sie an, wohin Ihr abgestimmtes Modell hochgeladen werden soll. Ist die Modelluploadregion nicht angegeben ist, wird das abgestimmte Modell in die Pipelinejobregion hochgeladen. Sie können eine unterstützten Pipelinejobs- und Modelluploadregionen für Ihre Modelluploadregion verwenden. Sie können die Modelluploadregion mit einer der folgenden Methoden angeben:

• Wenn Sie das Vertex AI SDK verwenden, wird der tuned_model_location-Parameter in der tune_model-Methode des Objekts angegeben, das das abzustimmende Modell darstellt (z. B., die TextGenerationModel.tune_model-Methode).

• Wenn Sie einen überwachten Modellabstimmungsjob durch Senden einer POST-Anfrage mit der pipelineJobs-Methode erstellen, können Sie dielocation-Parameter zur Angabe der Modelluploadregion verwenden.

• Wenn Sie die Google Cloud Console verwenden, um einen überwachten Modellabstimmungsjob zu erstellen, geben Sie bei der Erstellung des Abstimmungsjobs die Pipelinejobregion in der Regionssteuerung an. In der Google Cloud Console gibt die Regionssteuerung sowohl die Region des Modelluploads als auch die des Pipelinejobs an. Wenn Sie die Google Cloud Console zum Erstellen eines überwachten Jobs zur Feinabstimmung des Modells verwenden, sind beide Regionen immer identisch.

Modelloptimierungsregion

Im Bereich der Modelloptimierung wird die Berechnungen zur Modellabstimmung durchgeführt. Diese Region wird durch den ausgewählten Beschleunigertyp bestimmt. Wenn Sie für Ihren Beschleunigertyp TPU angeben, erfolgt die Berechnung der Modellfeinabstimmung in europe-west4. Wenn Sie für Ihren Beschleunigertyp GPU angeben, erfolgt die Modelloptimierung in us-central1.

Unterstützte Pipelinejob- und Modelluploadregionen

Sie können eine der folgenden Regionen verwenden, um die Modellupload- und die Pipelinejobregion anzugeben:

• 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

Überwachten Abstimmungsjob für Textmodelle erstellen

Sie können einen überwachten Textmodell-Abstimmungsjob mit der Google Cloud Console, API oder dem Vertex AI SDK für Python erstellen. Anleitungen zur Konfiguration von Modellabstimmungen finden Sie unter Empfohlene Konfigurationen.

POST http://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 \
     "http://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 "http://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[email protected]",
  "templateUri": "http://us-kfp.pkg.dev/ml-pipeline/large-language-model-pipelines/tune-large-model/v2.0.0",
  "templateMetadata": {
    "version": "sha256:c54b301482463df457b923faff255c528be7d1164531aa756b5974b3dc214b98"
  }
}

from __future__ import annotations

from typing import Optional

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

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

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

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

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

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

    print(model._job.status)

    return model

/**
 * 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:
      'http://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(
                  "http://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();
  }
}

Beispiel: cURL-Befehls

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" \
"http://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": "http://us-kfp.pkg.dev/ml-pipeline/large-language-model-pipelines/tune-large-model/v2.0.0"
}'

Empfohlene Konfigurationen

Die folgende Tabelle zeigt die empfohlenen Konfigurationen zum Optimieren eines Foundation Models nach Aufgabe:

Als Trainingsschritten können Sie mehr als einen Wert ausprobieren, um die beste Leistung für ein bestimmtes Dataset zu erhalten, z. B. 100, 200, 500.

Liste der optimierten Modelle anzeigen

Sie können eine Liste der Modelle in Ihrem aktuellen Projekt, einschließlich Ihrer feinabgestimmten Modelle, über die Google Cloud Console oder das Vertex AI SDK für Python anzeigen.

import vertexai
from vertexai.language_models import TextGenerationModel

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

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

    return tuned_model_names

Feinabgestimmtes Textmodell laden

Der folgende Beispielcode verwendet das Vertex AI SDK für Python, um ein Textgenerierungsmodell zu laden, das mit überwachter Abstimmung optimiert wurde:

import vertexai
from vertexai.preview.language_models import TextGenerationModel

model = TextGenerationModel.get_tuned_model(TUNED_MODEL_NAME)

Ersetzen Sie TUNED_MODEL_NAME durch den qualifizierten Ressourcennamen Ihres feinabgestimmten Modells. Dieser Name hat das Format projects/PROJECT_ID/locations/LOCATION/models/MODEL_ID. Die Modell-ID Ihres feinabgestimmten Modells finden Sie in Vertex AI Model Registry.

Messwerte für die Abstimmung und Evaluierung

Sie können einen Modellabstimmungsjob konfigurieren, um Messwerte zur Modellabstimmung und Modellbewertung zu erfassen und zu melden. Diese können dann mit Vertex AI TensorBoard visualisiert werden.

Messwerte für die Modellabstimmung

• /train_total_loss: Verlust für das Abstimmungs-Dataset in einem Trainingsschritt.
• /train_fraction_of_correct_next_step_preds: Die Tokengenauigkeit in einem Trainingsschritt. Eine einzelne Vorhersage besteht aus einer Abfolge von Tokens. Dieser Messwert misst die Genauigkeit der vorhergesagten Tokens im Vergleich zum Ground Truth im Abstimmungs-Dataset.
• /train_num_predictions:: Anzahl der vorhergesagten Tokens in einem Trainingsschritt.

Modellvalidierungsmesswerte

Modellbewertungsmesswerte

Sie können einen Modellabstimmungsjob konfigurieren, um die folgenden Bewertungsmesswerte für code-bison und text-bison zu erfassen:

• /eval_total_loss: Verlust für das Bewertungs-Dataset in einem Bewertungsschritt.
• /eval_fraction_of_correct_next_step_preds: Die Tokengenauigkeit in einem Bewertungsschritt. Eine einzelne Vorhersage besteht aus einer Abfolge von Tokens. Dieser Messwert misst die Genauigkeit der vorhergesagten Tokens im Vergleich zum Ground Truth im Bewertungs-Dataset.
• /eval_num_predictions: Anzahl der vorhergesagten Tokens in einem Bewertungsschritt.

Die Messwertvisualisierungen sind verfügbar, sobald der Modellabstimmungsjob abgeschlossen wurde. Wenn Sie beim Erstellen des Abstimmungsjobs nur eine Vertex AI TensorBoard-Instanz-ID und kein Bewertungs-Dataset angeben, sind nur die Visualisierungen für die Abstimmungsmesswerte verfügbar.

Fehlerbehebung

Die folgenden Themen können helfen, Probleme bei der Abstimmung eines Basis-Textmodells mit überwachter Abstimmung zu beheben.

Bei dem Versuch, ein Modell zu optimieren, wird der Fehler 500 oder Internal error encountered zurückgegeben.

Wenn dieser 500-Fehler beim Optimieren eines Modells auftritt, versuchen Sie es mit diesem Workaround:

Führen Sie folgenden cURL-Befehl aus, um ein leeres Vertex AI-Dataset zu erstellen. Achten Sie darauf, dass Sie Ihre Projekt-ID im Befehl konfigurieren.

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
http://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"}]
}'

Warten Sie nach Abschluss des Befehls fünf Minuten und wiederholen Sie dann die Modellabstimmung.

Fehler: Berechtigung „aiplatform.metadataStores.get“ wurde für die Ressource „...europe-west4/metadataStores/default“ abgelehnt.

Achten Sie darauf, dass die Compute Engine API aktiviert ist und das Compute Engine-Standarddienstkonto (PROJECT_NUM‑[email protected]) die Rollen aiplatform.admin und storage.objectAdmin erhält.

So weisen Sie dem Compute Engine-Dienstkonto die Rollen aiplatform.admin und storage.objectAdmin zu:

1. Aktivieren Sie Cloud Shell in der Google Cloud Console.

   Cloud Shell aktivieren

   Unten in der Google Cloud Console wird eine Cloud Shell-Sitzung gestartet und eine Eingabeaufforderung angezeigt. Cloud Shell ist eine Shell-Umgebung, in der das Google Cloud CLI bereits installiert ist und Werte für Ihr aktuelles Projekt bereits festgelegt sind. Das Initialisieren der Sitzung kann einige Sekunden dauern.

   Wenn Sie ein Terminal auf Ihrem Computer verwenden möchten, installieren und konfigurieren Sie die Google Cloud CLI.

2. Hängen Sie die Rolle aiplatform.admin mithilfe des Befehls gcloud projects add-iam-policy-binding an Ihr Compute Engine-Dienstkonto an:

   Ersetzen Sie Folgendes:

   • PROJECT_ID durch Ihre Google Cloud-Projekt-ID
   • PROJECT_NUM durch Ihre Google Cloud-Projektnummer.

   gcloud projects add-iam-policy-binding PROJECT_ID --member serviceAccount:PROJECT_NUM[email protected] --role roles/aiplatform.admin
   

3. Hängen Sie die Rolle storage.objectAdmin mithilfe des Befehls gcloud projects add-iam-policy-binding an Ihr Compute Engine-Dienstkonto an:

   • PROJECT_ID durch Ihre Google Cloud-Projekt-ID
   • PROJECT_NUM durch Ihre Google Cloud-Projektnummer.

   gcloud projects add-iam-policy-binding PROJECT_ID --member serviceAccount:PROJECT_NUM[email protected]  --role roles/storage.objectAdmin
   

Fehler: Der Vertex AI-Dienst-Agent-Dienst-{project-number}@gcp-sa-aiplatform.iam.gserviceaccount.com ist nicht berechtigt, auf Artifact Registry-Repository-Projekte/vertex-ai-restricted/locations/us/repositories/llm zuzugreifen.

Dieser Berechtigungsfehler ist auf eine Übertragungsverzögerung zurückzuführen. Durch einen nachfolgenden Wiederholungsversuch sollte dieser Fehler behoben werden.

Nächste Schritte

• Ein abgestimmtes Modell bewerten.
• Basismodell mithilfe der RLHF-Abstimmung optimieren.
• Codemodell abstimmen.