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.

    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.

    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.

    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.

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.

Text

Die einzelnen Beispiele enthalten je ein input_text-Feld, das den Prompt für das Modell enthält, und ein output_text-Feld, das eine vom abgestimmten Modell erwartete Beispielantwort enthält. Zusätzliche Felder aus strukturierten Eingabeaufforderungen wie context werden ignoriert.

Die maximale Tokenlänge für input_text beträgt 8.192, die maximale Tokenlänge für output_text ist 1.024. Wenn eines der Felder die maximale Tokenlänge überschreitet, werden die überschüssigen Tokens abgeschnitten.

Ein Dataset für ein Textgenerierungsmodell kann maximal 10.000 Beispiele enthalten.

Dataset-Beispiel

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

Anleitungen in Beispiele einbinden

Für Aufgaben wie die Klassifizierung ist es möglich, ein Dataset mit Beispielen zu erstellen, die keine Anleitungen enthalten. Wenn Sie Befehle aus den Beispielen im Dataset ausschließen, führt dies nach der Feinabstimmung zu einer schlechteren Leistung als die Einbeziehung von Anweisungen. Dies gilt insbesondere bei kleineren Datasets.

Schließt Anleitungen aus:

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

Schließt Anleitungen ein:

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

Chat

Jedes Unterhaltungsbeispiel in einem Dataset zur Chat-Feinabstimmung besteht aus einem messages-Feld (erforderlich) und einem context-Feld (optional).

Das messages-Feld besteht aus einem Array aus Autoren-Inhalts-Paaren. Das author-Feld bezieht sich auf den Autor der Nachricht und ist abwechselnd auf user oder assistant gesetzt. Das content-Feld ist der Inhalt der Nachricht. Jedes Unterhaltungsbeispiel sollte zwei bis drei Nutzer-Assistent-Nachrichtenpaare enthalten, die eine Nachricht vom Nutzer und eine Antwort vom Modell darstellen.

Im context-Feld können Sie einen Kontext für den Chat angeben. Wenn Sie einen Kontext für ein Beispiel angeben, wird der in default_context angegebene Wert überschrieben.

Für jedes Unterhaltungsbeispiel beträgt die maximale Tokenlänge für context und messages zusammen 8.192 Tokens. Außerdem sollte jedes content-Feld für assistant 1.024 Tokens nicht überschreiten.

Die maximale Anzahl von author-Feldern, die die Beispiele im Dataset für ein Textchatmodell enthalten können, beträgt 10.000. Dieses Maximum entspricht der Summe aller author-Felder in allen messages in allen Beispielen.

Beispiel

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

     https://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.

REST

Senden Sie zum Erstellen eines Modellabstimmungsjobs eine POST-Anfrage mit der Methode pipelineJobs. Beachten Sie, dass einige Parameter nicht von allen Modellen unterstützt werden. Achten Sie darauf, dass Sie nur die für das abzustimmende Modell relevanten Parameter einfügen.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PIPELINEJOB_DISPLAYNAME: Ein Anzeigename für den pipelineJob.
  • OUTPUT_DIR: Der URI des Buckets, an den Pipelineartefakte ausgegeben werden sollen.
  • PROJECT_ID: Ihre Projekt-ID.
  • MODEL_DISPLAYNAME: Ein Anzeigename für das von der Pipelinejob hochgeladene (erstellte) Modell.
  • DATASET_URI: URI Ihrer Dataset-Datei.
  • PIPELINE_JOB_REGION: Die Region, in der der Pipeline-Abstimmungsjob ausgeführt wird. Dies ist auch die Standardregion, in der das abgestimmte Modell hochgeladen wird. Wenn Sie Ihr Modell in eine andere Region hochladen möchten, verwenden Sie den location-Parameter, um die Uploadregion für das abgestimmte Modell anzugeben. Weitere Informationen finden Sie unter Modelluploadregion.
  • MODEL_UPLOAD_REGION: (Optional) Die Region, in der das abgestimmte Modell hochgeladen wird. Wenn Sie keine Region für den Modellupload angeben, wird das abgestimmte Modell in die Region hochgeladen, in der der Pipelinejob ausgeführt wird. Weitere Informationen finden Sie unter Modelluploadregion.
  • ACCELERATOR_TYPE: (optional, Standard GPU) Der Beschleunigertyp, der für die Modelloptimierung verwendet werden soll. Gültige Optionen sind:
    • GPU: Verwendet acht A100 mit 80 GPUs zur Abstimmung. Achten Sie darauf, dass Ihr Kontingent ausreicht. Wenn Sie GPU auswählen, wird VPC-SC unterstützt. CMEK wird unterstützt, wenn Feinabstimmungs- und Modelluploadstandort us-centra1 sind. Weitere Informationen finden Sie unter Einstellungen für die überwachte Optimierungsregion. Wenn Sie GPU wählen, werden die Berechnungen zur Modelloptimierung in der us-central1-Region durchgeführt.
    • TPU: Verwendet 64 Kerne des TPU v3-Pods für die Optimierung. Achten Sie darauf, dass Ihr Kontingent ausreicht. CMEK wird nicht unterstützt, aber VPC-SC wird unterstützt. Wenn Sie TPU wählen, werden die Berechnungen zur Modelloptimierung in der europe-west4-Region durchgeführt.
  • LARGE_MODEL_REFERENCE: Name des zu optimierenden Foundation Models. Folgende Optionen sind verfügbar:
    • text-bison@002
    • chat-bison@002
  • DEFAULT_CONTEXT (chat only): Der Kontext, der für alle Feinabstimmungsbeispiele im Abstimmungs-Dataset gilt. Wenn Sie in einem Beispiel das context-Feld festlegen, wird der Standardkontext überschrieben.
  • STEPS: Die Anzahl der Schritte, die für die Abstimmung eines Modells ausgeführt werden sollen. Der Standardwert ist 300. Die Batchgröße variiert je nach Ort der Abstimmung und Modellgröße. Für 8.000-Modelle, z. B. text-bison@002, chat-bison@002, code-bison@002 und codechat-bison@002:
    • us-central1 hat eine Batchgröße von 8.
    • europe-west4 hat eine Batchgröße von 24.
    Für 32.000-Modelle wie text-bison-32k, chat-bison-32k, code-bison-32k und codechat-bison-32k:
    • us-central1 hat eine Batchgröße von 8.
    • europe-west4 hat eine Batchgröße von 8.

    Wenn Sie beispielsweise text-bison@002 in europe-west4 trainieren, gibt es 240 Beispiele in einem Trainings-Dataset und Sie setzen steps auf 20, dann beträgt die Anzahl der Trainingsbeispiele das Produkt aus 20 Schritten und die Batchgröße von 24 oder 480 Trainingsschritten. In diesem Fall umfasst der Trainingsprozess zwei Epochen, da die Beispiele zweimal durchlaufen werden. Wenn in us-central1 240 Beispiele in einem Trainings-Dataset vorhanden sind und Sie steps auf 15 setzen, beträgt die Anzahl der Trainingsbeispiele das Produkt aus 15 Schritten und der Batchgröße von 8 oder 120 Trainingsschritte. In diesem Fall gibt es 0,5 Epochen, da es halb so viele Trainingsschritte wie Beispiele gibt.

  • LEARNING_RATE_MULTIPLIER Ein Multiplikator, der auf die empfohlene Lernrate anzuwenden ist. Verwenden Sie 1.0, um die empfohlene Lernrate zu verwenden.
  • EVAL_DATASET_URI (text only): (Optional) Der URI der JSONL-Datei, die das Bewertungs-Dataset für Batchvorhersage und -bewertung enthält. Die Bewertung wird für chat-bison nicht unterstützt. Weitere Informationen finden Sie unter Dataset-Format zur Abstimmung eines Codemodells. Das Bewertungs-Dataset erfordert zwischen 10 und 250 Beispiele.
  • EVAL_INTERVAL (text only): (Optional, Standard 20) Die Anzahl der Feinabstimmungsschritte zwischen den einzelnen Bewertungen. Bewertungsintervalle werden für Chatmodelle nicht unterstützt. Da die Bewertung für das gesamte Bewertungs-Dataset ausgeführt wird, führt ein kleineres Bewertungsintervall zu einer längeren Abstimmungszeit. Beispiel: Wenn steps 200 und EVAL_INTERVAL 100 ist, erhalten Sie nur zwei Datenpunkte für die Bewertungsmesswerte. Für diesen Parameter muss evaluation_data_uri festgelegt sein.
  • ENABLE_EARLY_STOPPING (text only): (optional, Standard true) Ein boolean, der bei Einstellung auf true die Abstimmung vor der Ausführung aller Feinabstimmungsschritte beendet, falls sich die Modellleistung, gemessen über die Genauigkeit der vorhergesagten Tokens, zwischen den Auswertungsausführungen nicht verbessert. Bei false wird die Abstimmung fortgesetzt, bis alle Abstimmungsschritte abgeschlossen sind. Für diesen Parameter muss evaluation_data_uri festgelegt sein. Das Aktivieren des vorzeitigen Beendens wird für Chatmodelle nicht unterstützt.
  • TENSORBOARD_RESOURCE_ID: (Optional) Die ID einer Vertex AI TensorBoard-Instanz. Die Vertex AI TensorBoard-Instanz wird verwendet, um nach Abschluss des Abstimmungsjobs einen Test zu erstellen. Die Vertex AI TensorBoard-Instanz muss sich in derselben Region wie die Abstimmungspipeline befinden.
  • ENCRYPTION_KEY_NAME: (optional) Der voll qualifizierte Name eines vom Kunden verwalteten Verschlüsselungsschlüssels (Customer-Managed Encryption Key, CMEK), den Sie für die Datenverschlüsselung verwenden möchten. Ein CMEK ist nur in us-central1 verfügbar. Wenn Sie us-central1 verwenden und keinen CMEK angeben, wird ein von Google verwalteter Verschlüsselungsschlüssel verwendet. Ein von Google verwalteter Verschlüsselungsschlüssel wird standardmäßig in allen anderen verfügbaren Regionen verwendet. Weitere Informationen finden Sie in der Übersicht zu CMEK.
  • TEMPLATE_URI: Die zu verwendende Feinabstimmungsvorlage hängt von dem Modell ab, das Sie optimieren möchten:
    • Textmodell: https://us-kfp.pkg.dev/ml-pipeline/large-language-model-pipelines/tune-large-model/v2.0.0
    • Chatmodell: https://us-kfp.pkg.dev/ml-pipeline/large-language-model-pipelines/tune-large-chat-model/v3.0.0
  • SERVICE_ACCOUNT: (optional) Das Dienstkonto, das Vertex AI zum Ausführen Ihres Pipelinejobs verwendet. Standardmäßig wird das Compute Engine-Standarddienstkonto Ihres Projekts (PROJECT_NUMBER‑compute@developer.gserviceaccount.com) verwendet. Weitere Informationen zum Anhängen eines benutzerdefinierten Dienstkontos.

HTTP-Methode und URL:

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

JSON-Text der Anfrage:

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

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

curl

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

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

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

$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

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten: Beachten Sie, dass pipelineSpec gekürzt wurde, um Speicherplatz zu sparen.

Python

Informationen zur Installation des Vertex AI SDK for Python finden Sie unter Vertex AI SDK for Python installieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Python API. 

from __future__ import annotations

from typing import Optional

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

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

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

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

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

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

    print(model._job.status)

    return model

Node.js

Bevor Sie dieses Beispiel anwenden, folgen Sie den Node.js-Einrichtungsschritten in der Vertex AI-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI Node.js API.

Richten Sie zur Authentifizierung bei Vertex AI Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

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

Bevor Sie dieses Beispiel anwenden, folgen Sie den Java-Einrichtungsschritten in der Vertex AI-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI Java API.

Richten Sie zur Authentifizierung bei Vertex AI Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

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

Führen Sie folgende Schritte aus, um ein Textmodell mit überwachter Feinabstimmung über die Cloud Console zu optimieren:

  1. Rufen Sie im Bereich „Vertex AI“ der Google Cloud Console die Seite Vertex AI Studio auf.

    Zu Vertex AI Studio

  2. Klicken Sie auf den Tab Abstimmen und destillieren.
  3. Klicken Sie auf Abgestimmtes Modell erstellen.
  4. Klicken Sie auf Überwachte Feinabstimmung.
  5. Konfigurieren Sie die Modelldetails:
    • Name des abgestimmten Modells: Geben Sie einen Namen für das abgestimmte Modell ein.
    • Basismodell: Wählen Sie das Modell aus, das Sie anpassen möchten.
    • Region: Wählen Sie die Region aus, in der der Pipeline-Optimierungsjob ausgeführt und in der das abgestimmte Modell bereitgestellt wird.
    • Ausgabeverzeichnis: Geben Sie den Cloud Storage-Speicherort ein, an dem Artefakte gespeichert werden, nachdem Ihr Modell optimiert wurde.
  6. Maximieren Sie Erweiterte Optionen, um erweiterte Einstellungen zu konfigurieren.
    • Trainingsschritte: Geben Sie die Anzahl der Schritte ein, die zur Modellabstimmung ausgeführt werden sollen. Der Standardwert ist 300. Die Batchgröße variiert je nach Ort der Abstimmung und Modellgröße. Für 8.000-Modelle, z. B. text-bison@002, chat-bison@002, code-bison@002 und codechat-bison@002:
      • us-central1 hat eine Batchgröße von 8.
      • europe-west4 hat eine Batchgröße von 24.
      Für 32.000-Modelle wie text-bison-32k, chat-bison-32k, code-bison-32k und codechat-bison-32k:
      • us-central1 hat eine Batchgröße von 8.
      • europe-west4 hat eine Batchgröße von 8.

      Wenn Sie beispielsweise text-bison@002 in europe-west4 trainieren, gibt es 240 Beispiele in einem Trainings-Dataset und Sie setzen steps auf 20, dann beträgt die Anzahl der Trainingsbeispiele das Produkt aus 20 Schritten und die Batchgröße von 24 oder 480 Trainingsschritten. In diesem Fall umfasst der Trainingsprozess zwei Epochen, da die Beispiele zweimal durchlaufen werden. Wenn in us-central1 240 Beispiele in einem Trainings-Dataset vorhanden sind und Sie steps auf 15 setzen, beträgt die Anzahl der Trainingsbeispiele das Produkt aus 15 Schritten und der Batchgröße von 8 oder 120 Trainingsschritte. In diesem Fall gibt es 0,5 Epochen, da es halb so viele Trainingsschritte wie Beispiele gibt.

    • Multiplikator für die Lernrate: Geben Sie die Schrittgröße pro Durchlauf ein. Der Standardwert ist 1.
    • Beschleunigertyp: (Optional) Geben Sie den Typ des Beschleunigers ein, der für die Modelloptimierung verwendet werden soll. Gültige Optionen sind:
      • GPU: Verwendet acht A100 mit 80 GPUs zur Abstimmung. Achten Sie darauf, dass Ihr Kontingent ausreicht. Wenn Sie GPU auswählen, wird VPC-SC unterstützt. CMEK wird unterstützt, wenn Feinabstimmungs- und Modelluploadstandort us-centra1 sind. Weitere Informationen finden Sie unter Einstellungen für die überwachte Optimierungsregion. Wenn Sie GPU wählen, werden die Berechnungen zur Modelloptimierung in der us-central1-Region durchgeführt.
      • TPU: Verwendet 64 Kerne des TPU v3-Pods für die Optimierung. Achten Sie darauf, dass Ihr Kontingent ausreicht. CMEK wird nicht unterstützt, aber VPC-SC wird unterstützt. Wenn Sie TPU wählen, werden die Berechnungen zur Modelloptimierung in der europe-west4-Region durchgeführt.
    • TensorBoard-Instanz hinzufügen: (optional) Die ID einer Vertex AI TensorBoard-Instanz. Die Vertex AI TensorBoard-Instanz wird verwendet, um nach Abschluss des Abstimmungsjobs einen Test zu erstellen. Die Vertex AI TensorBoard-Instanz muss sich in derselben Region wie die Abstimmungspipeline befinden.
    • Verschlüsselung (optional) Wählen Sie aus, ob Sie einen von Google verwalteten Verschlüsselungsschlüssel oder einen vom Kunden verwalteten Verschlüsselungsschlüssel (CMEK, Customer Managed Encryption Key) verwenden möchten. Ein CMEK ist nur für Verschlüsselungen in der Region us-central1 verfügbar. In allen anderen verfügbaren Regionen wird ein von Google verwalteter Verschlüsselungsschlüssel verwendet. Weitere Informationen finden Sie in der Übersicht zu CMEK.
    • Dienstkonto (optional) Wählen Sie ein nutzerverwaltetes Dienstkonto aus. Ein Dienstkonto bestimmt, auf welche Google Cloud-Ressourcen Ihr Dienstcode zugreifen kann. Wenn Sie kein Dienstkonto auswählen, wird ein von Google verwaltetes Dienstkonto verwendet, das für die meisten Modelle passende Berechtigungen enthält.
  7. Klicken Sie auf Weiter.
  8. Wenn Sie Ihre Dataset-Datei hochladen möchten, wählen Sie  JSONL-Datei in Cloud Storage hochladen aus. Wenn sich die Dataset-Datei bereits in einem Cloud Storage-Bucket befindet, wählen Sie  Vorhandene JSONL-Datei in Cloud Storage.

    JSONL-Datei hochladen

    • Klicken Sie unter JSONL-Datei auswählen auf Durchsuchen und wählen Sie die Dataset-Datei aus.
    • Klicken Sie unter Dataset-Speicherort auf Durchsuchen und wählen Sie den Cloud Storage-Bucket, in dem Sie die Dataset-Datei speichern möchten.

    Vorhandene JSONL-Datei verwenden

    Klicken Sie unter Cloud Storage-Dateipfad auf Durchsuchen und wählen Sie den Cloud Storage-Bucket, in dem sich Ihre Dataset-Datei befindet.
  9. (Optional) Wählen Sie Evaluierung des Modells aktivieren aus und konfigurieren Sie die Modellbewertung, um das destillierte Modell zu bewerten:
    • Bewertungs-Dataset: (optional) Der URI der JSONL-Datei, die das Bewertungs-Dataset für Batchvorhersage und -bewertung enthält. Die Bewertung wird für chat-bison nicht unterstützt. Weitere Informationen finden Sie unter Dataset-Format zur Abstimmung eines Codemodells. Das Bewertungs-Dataset erfordert zwischen 10 und 250 Beispiele.
    • Bewertungs-Intervall: (optional, Standard 20) Die Anzahl der Abstimmungsschritte zwischen den einzelnen Bewertungen. Ein Auswertungsintervall wird für Chatmodelle nicht unterstützt. Da die Bewertung für das gesamte Bewertungs-Dataset ausgeführt wird, führt ein kleineres Bewertungsintervall zu einer längeren Abstimmungszeit. Beispiel: Wenn steps 200 und EVAL_INTERVAL 100 ist, erhalten Sie nur zwei Datenpunkte für die Bewertungsmesswerte. Für diesen Parameter muss evaluation_data_uri festgelegt sein.
    • Vorzeitiges Beenden aktivieren: (optional, Standardeinstellung true) Ein boolean, der bei Einstellung auf true die Abstimmung vor der Ausführung aller Feinabstimmungsschritte beendet, falls sich die Modellleistung, gemessen über die Genauigkeit der vorhergesagten Tokens, zwischen den Auswertungsausführungen nicht verbessert. Bei false wird die Abstimmung fortgesetzt, bis alle Abstimmungsschritte abgeschlossen sind. Für diesen Parameter muss evaluation_data_uri festgelegt sein. Das Aktivieren des vorzeitigen Beendens wird für Chatmodelle nicht unterstützt.
    • Prüfpunktauswahl aktivieren: Wenn diese Option aktiviert ist, wählt Vertex AI den Prüfpunkt mit der besten Modellbewertungsleistung von allen während des Abstimmungsjobs erstellten Prüfpunkten aus. Bei Deaktivierung wird der letzte Prüfpunkt zurückgegeben, der während des Abstimmungsjobs erstellt wurde. Jeder Prüfpunkt bezieht sich auf einen während eines Abstimmungsjobs erstellten Snapshot des Modells.
    • TensorBoard-Instanz: (Optional) Die ID einer Vertex AI TensorBoard-Instanz. Die Vertex AI TensorBoard-Instanz wird verwendet, um nach Abschluss des Abstimmungsjobs einen Test zu erstellen. Die Vertex AI TensorBoard-Instanz muss sich in derselben Region wie die Abstimmungspipeline befinden.
  10. Klicken Sie auf Abstimmung starten.

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

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

Task Anzahl der Beispiele im Datensatz Trainingsschritte
Klassifizierung Über 100 100-500
Zusammenfassung 100-500+ 200-1000
Extractive QA Über 100 100-500
Chat Über 200 1.000

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.

Python

Bevor Sie dieses Beispiel anwenden, folgen Sie den Python-Einrichtungsschritten in der Vertex AI-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI Python API.

Richten Sie zur Authentifizierung bei Vertex AI Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 


import vertexai
from vertexai.language_models import TextGenerationModel

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

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

    return tuned_model_names

Console

Rufen Sie die Seite Vertex AI Model Registry auf, um Ihre optimierten Modelle in der Google Cloud Console aufzurufen.

Zur Vertex AI Model Registry

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

Sie können einen Modellabstimmungsjob konfigurieren, um die folgenden Abstimmungsmesswerte für chat-bison, code-bison, codechat-bison und text-bison zu erfassen:
  • /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" \
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"}]
}'

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‑compute@developer.gserviceaccount.com) 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. 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.

    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-compute@developer.gserviceaccount.com --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-compute@developer.gserviceaccount.com  --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