Feinabstimmung und Bewertung verwenden, um die Modelleistung zu verbessern

In dieser Anleitung wird gezeigt, wie Sie ein BigQuery ML Remote-Modell erstellen, das auf ein Vertex AI gemini-2.0-flash-001 Modellverweist. Anschließend verwenden Sie die überwachte Abstimmung , um das Modell mit neuen Trainingsdaten zu optimieren, gefolgt von der Bewertung des Modells mit der ML.EVALUATE Funktion.

Die Feinabstimmung kann Ihnen bei der Behebung von Szenarien helfen, in denen Sie das gehostete Vertex AI-Modell anpassen müssen, z. B. wenn das erwartete Verhalten des Modells schwierig zu definieren ist in einem Prompt oder wenn Prompts nicht die erwarteten Ergebnisse generieren, d. h. Ergebnisse die konsistent genug sind. Die überwachte Abstimmung wirkt sich auch so auf das Modell aus:

Leitet das Modell so, dass bestimmte Antwortstile zurückgegeben werden, z. B. mit prägnanteren oder ausführlicheren Antworten.
Bringt dem Modell neue Verhaltensweisen bei, z. B. das Beantworten von Prompts als eine bestimmte Persona.
Bewirkt, dass das Modell sich mit neuen Informationen aktualisiert.

In dieser Anleitung soll das Modell Text generieren, dessen Stil und Inhalt so nah wie möglich an den bereitgestellten Grundwahrheitsinhalt angelehnt sind.

Erforderliche Rollen

Zum Ausführen dieser Anleitung benötigen Sie die folgenden IAM-Rollen (Identity and Access Management):

BigQuery-Datasets, -Verbindungen und -Modelle erstellen und verwenden: BigQuery-Administrator (roles/bigquery.admin).
Berechtigungen für das Dienstkonto der Verbindung erteilen: Projekt-IAM-Administrator (roles/resourcemanager.projectIamAdmin).

Diese vordefinierten Rollen enthalten die Berechtigungen, die zum Ausführen der Aufgaben in diesem Dokument erforderlich sind. Erweitern Sie den Abschnitt Erforderliche Berechtigungen, um die erforderlichen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Dataset erstellen: bigquery.datasets.create
Tabelle erstellen: bigquery.tables.create
Verbindung erstellen, delegieren und verwenden: bigquery.connections.*
Standardverbindung festlegen: bigquery.config.*
Berechtigungen für Dienstkonten festlegen: resourcemanager.projects.getIamPolicy und resourcemanager.projects.setIamPolicy
Modell erstellen und Inferenz ausführen:
- bigquery.jobs.create
- bigquery.models.create
- bigquery.models.getData
- bigquery.models.updateData
- bigquery.models.updateMetadata

Sie können diese Berechtigungen auch mit benutzerdefinierten Rollen oder anderen vordefinierten Rollen erhalten.

Hinweis

Wählen Sie in der Google Cloud Console auf der Seite für die Projektauswahl ein Projekt von aus oder erstellen Sie eines Google Cloud .
Erforderliche Rollen zum Auswählen oder Erstellen eines Projekts
- Projekt auswählen: Für die Auswahl eines Projekts ist keine bestimmte IAM-Rolle erforderlich. Sie können ein beliebiges Projekt auswählen, für das Ihnen eine Rolle zugewiesen wurde.
- Projekt erstellen: Zum Erstellen eines Projekts benötigen Sie die Rolle „Projektersteller“ (roles/resourcemanager.projectCreator), die die resourcemanager.projects.create Berechtigung enthält. Informationen zum Zuweisen von Rollen.
Hinweis: Wenn Sie die in dieser Anleitung erstellten Ressourcen nicht behalten möchten, erstellen Sie ein Projekt, anstatt ein vorhandenes auszuwählen. Nachdem Sie diese Schritte ausgeführt haben, können Sie das Projekt löschen und damit alle Ressourcen entfernen, die mit dem Projekt verknüpft sind.

Zur Projektauswahl
Prüfen Sie, ob für Ihr Google Cloud Projekt die Abrechnung aktiviert ist.
Aktivieren Sie die BigQuery API, die BigQuery Connection API, die Vertex AI API und die Compute Engine API.
Erforderliche Rollen zum Aktivieren von APIs
Zum Aktivieren von APIs benötigen Sie die IAM-Rolle „Service Usage-Administrator“ (roles/serviceusage.serviceUsageAdmin), die die Berechtigung serviceusage.services.enable enthält. Informationen zum Zuweisen von Rollen.
APIs aktivieren

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

BigQuery: You incur costs for the queries that you run in BigQuery.
BigQuery ML: You incur costs for the model that you create and the processing that you perform in BigQuery ML.
Vertex AI: You incur costs for calls to and supervised tuning of the gemini-2.0-flash-001 model.

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Verwenden Sie den Preisrechner.

Neuen Google Cloud Nutzern vonsteht möglicherweise eine kostenlose Testversion zur Verfügung.

Weitere Informationen finden Sie in den folgenden Ressourcen:

Dataset erstellen

Erstellen Sie ein BigQuery-Dataset, um Ihr ML-Modell zu speichern.

Console

Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

Zur Seite "BigQuery"
Klicken Sie im Bereich Explorer auf den Namen Ihres Projekts.
Klicken Sie auf Aktionen ansehen > Dataset erstellen.
Führen Sie auf der Seite Dataset erstellen die folgenden Schritte aus:
- Geben Sie unter Dataset-ID bqml_tutorial ein.
- Wählen Sie als Standorttyp die Option Multiregional und dann USA aus.
- Übernehmen Sie die verbleibenden Standardeinstellungen unverändert und klicken Sie auf Dataset erstellen.

bq

Verwenden Sie den bq mk --dataset Befehl, um ein neues Dataset zu erstellen.

Erstellen Sie ein Dataset mit dem Namen bqml_tutorial und legen Sie den Datenstandort auf US fest.

bq mk --dataset \
  --location=US \
  --description "BigQuery ML tutorial dataset." \
  bqml_tutorial

Prüfen Sie, ob das Dataset erstellt wurde:
```
bq ls
```

API

Rufen Sie die datasets.insert Methode mit einer definierten Dataset-Ressource auf.

{
  "datasetReference": {
     "datasetId": "bqml_tutorial"
  }
}

Testtabellen erstellen

Erstellen Sie Tabellen mit Trainings- und Bewertungsdaten basierend auf dem öffentlichen task955_wiki_auto_style_transfer Dataset von Hugging Face.

Öffnen Sie die Cloud Shell.

Führen Sie in Cloud Shell die folgenden Befehle aus, um Tabellen mit Test- und Bewertungsdaten zu erstellen:

python3 -m pip install pandas pyarrow fsspec huggingface_hub

python3 -c "import pandas as pd; df_train = pd.read_parquet('hf://datasets/Lots-of-LoRAs/task955_wiki_auto_style_transfer/data/train-00000-of-00001.parquet').drop('id', axis=1); df_train['output'] = [x[0] for x in df_train['output']]; df_train.to_json('wiki_auto_style_transfer_train.jsonl', orient='records', lines=True);"

python3 -c "import pandas as pd; df_valid = pd.read_parquet('hf://datasets/Lots-of-LoRAs/task955_wiki_auto_style_transfer/data/valid-00000-of-00001.parquet').drop('id', axis=1); df_valid['output'] = [x[0] for x in df_valid['output']]; df_valid.to_json('wiki_auto_style_transfer_valid.jsonl', orient='records', lines=True);"

bq rm -t bqml_tutorial.wiki_auto_style_transfer_train

bq rm -t bqml_tutorial.wiki_auto_style_transfer_valid

bq load --source_format=NEWLINE_DELIMITED_JSON bqml_tutorial.wiki_auto_style_transfer_train wiki_auto_style_transfer_train.jsonl input:STRING,output:STRING

bq load --source_format=NEWLINE_DELIMITED_JSON bqml_tutorial.wiki_auto_style_transfer_valid wiki_auto_style_transfer_valid.jsonl input:STRING,output:STRING

Basismodell erstellen

Erstellen Sie ein Remote-Modell über dem gemini-2.0-flash-001-Modell von Vertex AI.

Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

BigQuery aufrufen
Führen Sie im Abfrageeditor die folgende Anweisung aus, um ein Remote-Modell zu erstellen:
```
CREATE OR REPLACE MODEL `bqml_tutorial.gemini_baseline`
REMOTE WITH CONNECTION DEFAULT
OPTIONS (ENDPOINT ='gemini-2.0-flash-001');
```
Die Abfrage dauert mehrere Sekunden. Anschließend wird das Modell gemini_baseline im Dataset bqml_tutorial des Bereichs Explorer angezeigt. Da die Abfrage eine CREATE MODEL-Anweisung zum Erstellen eines Modells verwendet, gibt es keine Abfrageergebnisse.

Leistung des Basismodells prüfen

Führen Sie die AI.GENERATE_TEXT Funktion mit dem Remote-Modell aus, um zu sehen, wie es mit den Bewertungsdaten ohne Feinabstimmung funktioniert.

Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

BigQuery aufrufen
Führen Sie im Abfrageeditor folgende Abfrage aus:
```
SELECT result, ground_truth
FROM
  AI.GENERATE_TEXT(
    MODEL `bqml_tutorial.gemini_baseline`,
    (
      SELECT
        input AS prompt, output AS ground_truth
      FROM `bqml_tutorial.wiki_auto_style_transfer_valid`
      LIMIT 10
    ));
```
Wenn Sie die Ausgabedaten untersuchen und die Werte für result und ground_truth vergleichen, sehen Sie, dass das Basismodell zwar Text generiert, der die in den Grundwahrheitsinhalten enthaltenen Fakten genau widerspiegelt, der Stil des Texts jedoch ziemlich unterschiedlich ist.

Basismodell bewerten

Verwenden Sie die ML.EVALUATE Funktion, um die Leistung des Modells detaillierter zu bewerten. Diese Funktion berechnet Modellmesswerte, die die Genauigkeit und Qualität des generierten Texts messen, um die Modellantworten mit idealen Antworten zu vergleichen.

Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

BigQuery aufrufen

Führen Sie im Abfrageeditor folgende Abfrage aus:

SELECT *
FROM
  ML.EVALUATE(
    MODEL `bqml_tutorial.gemini_baseline`,
    (
      SELECT
        input AS input_text, output AS output_text
      FROM `bqml_tutorial.wiki_auto_style_transfer_valid`
    ),
    STRUCT('text_generation' AS task_type));

Die Ausgabe sieht dann ungefähr so aus:

   +---------------------+---------------------+-------------------------------------------+--------------------------------------------+
   | bleu4_score         | rouge-l_precision   | rouge-l_recall      | rouge-l_f1_score    | evaluation_status                          |
   +---------------------+---------------------+---------------------+---------------------+--------------------------------------------+
   | 0.23317359667074181 | 0.37809145226740043 | 0.45902937167791508 | 0.40956844061733139 | {                                          |
   |                     |                     |                     |                     |  "num_successful_rows": 176,               |
   |                     |                     |                     |                     |  "num_total_rows": 176                     |
   |                     |                     |                     |                     | }                                          |
   +---------------------+---------------------+ --------------------+---------------------+--------------------------------------------+

Die Leistung des Basismodells ist nicht schlecht, aber die Ähnlichkeit des generierten Texts mit der Grundwahrheit ist anhand der Bewertungsmetriken gering. Das deutet darauf hin, dass es sich lohnt, eine überwachte Abstimmung vorzunehmen, um zu sehen, ob sich die Modellleistung für diesen Anwendungsfall verbessern lässt.

Abgestimmtes Modell erstellen

Erstellen Sie ein Remote-Modell, das dem ähnelt, das Sie unter Modell erstellen erstellt haben, aber geben Sie dieses Mal die AS SELECT Anweisung an, um die Trainingsdaten bereitzustellen, damit das Modell optimiert wird.

Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

BigQuery aufrufen

Führen Sie im Abfrageeditor die folgende Anweisung aus, um ein Remote-Modell zu erstellen:

CREATE OR REPLACE MODEL `bqml_tutorial.gemini_tuned`
  REMOTE
    WITH CONNECTION DEFAULT
  OPTIONS (
    endpoint = 'gemini-2.0-flash-001',
    max_iterations = 500,
    data_split_method = 'no_split')
AS
SELECT
  input AS prompt, output AS label
FROM `bqml_tutorial.wiki_auto_style_transfer_train`;

Es kann einige Minuten dauern, bis die Abfrage abgeschlossen ist. Das Modell gemini_tuned erscheint danach im Dataset bqml_tutorial im Bereich Explorer. Da die Abfrage eine CREATE MODEL-Anweisung zum Erstellen eines Modells verwendet, gibt es keine Abfrageergebnisse.

Leistung des abgestimmten Modells prüfen

Führen Sie die Funktion AI.GENERATE_TEXT aus, um die Leistung des abgestimmten Modells für die Bewertungsdaten zu sehen.

Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

BigQuery aufrufen

Führen Sie im Abfrageeditor folgende Abfrage aus:

SELECT result, ground_truth
FROM
  AI.GENERATE_TEXT(
    MODEL `bqml_tutorial.gemini_tuned`,
    (
      SELECT
        input AS prompt, output AS ground_truth
      FROM `bqml_tutorial.wiki_auto_style_transfer_valid`
      LIMIT 10
    ));

Bei der Überprüfung der Ausgabedaten stellen Sie fest, dass das abgestimmte Modell Text erzeugt, dessen Stil dem Grundwahrheitsinhalt viel ähnlicher ist.

Abgestimmtes Modell bewerten

Mit der Funktion ML.EVALUATE können Sie die Antworten des abgestimmten Modells mit den idealen Antworten vergleichen.

Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

BigQuery aufrufen

Führen Sie im Abfrageeditor folgende Abfrage aus:

SELECT *
FROM
  ML.EVALUATE(
    MODEL `bqml_tutorial.gemini_tuned`,
    (
      SELECT
        input AS prompt, output AS label
      FROM `bqml_tutorial.wiki_auto_style_transfer_valid`
    ),
    STRUCT('text_generation' AS task_type));

Die Ausgabe sieht dann ungefähr so aus:

   +---------------------+---------------------+-------------------------------------------+--------------------------------------------+
   | bleu4_score         | rouge-l_precision   | rouge-l_recall      | rouge-l_f1_score    | evaluation_status                          |
   +---------------------+---------------------+---------------------+---------------------+--------------------------------------------+
   | 0.416868792119966   | 0.642001000843349   | 0.55910008048151372 | 0.5907226262084847  | {                                          |
   |                     |                     |                     |                     |  "num_successful_rows": 176,               |
   |                     |                     |                     |                     |  "num_total_rows": 176                     |
   |                     |                     |                     |                     | }                                          |
   +---------------------+---------------------+ --------------------+---------------------+--------------------------------------------+

Obwohl im Trainings-Dataset nur 1.408 Beispiele verwendet wurden,hat sich die Leistung deutlich verbessert, wie die höheren Bewertungsmetriken zeigen.

Bereinigen

Achtung: Das Löschen eines Projekts hat folgende Auswirkungen:

Alle Inhalte des Projekts werden gelöscht. Wenn Sie für die Aufgaben in diesem Dokument ein bereits bestehendes Projekt verwendet haben und dieses löschen, werden auch alle anderen im Rahmen des Projekts erstellten Daten gelöscht.
Benutzerdefinierte Projekt-IDs gehen verloren. Beim Erstellen dieses Projekts haben Sie möglicherweise eine benutzerdefinierte Projekt-ID erstellt, die Sie weiterhin verwenden möchten. Damit die URLs, die die Projekt-ID nutzen, z. B. eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, statt das gesamte Projekt.

Wenn Sie mehrere Architekturen, Anleitungen und Kurzanleitungen durcharbeiten möchten, können Sie die Überschreitung von Projektkontingenten verhindern, indem Sie Projekte wiederverwenden.

Wechseln Sie in der Google Cloud Console zur Seite Ressourcen verwalten.
Zur Seite „Ressourcen verwalten“
Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.