1. Einführung
In diesem Lab lernen Sie, wie Sie den gesamten Workflow der überwachten Feinabstimmung für ein Google Gemini-Modell durchführen, um es für eine bestimmte Aufgabe anzupassen: die Zusammenfassung von Artikeln. Large Language Models sind zwar leistungsstark, aber aufgrund ihrer Natur für allgemeine Zwecke können sie durch Feinabstimmung für bestimmte Anwendungsfälle noch effektiver gemacht werden. Wenn Sie das Modell mit einem hochwertigen Dataset mit Beispielen trainieren, können Sie seine Konsistenz, Qualität und Effizienz für Ihre Zielaufgabe verbessern.
Sie verwenden Gemini 3.5 Flash, ein leichtgewichtiges und kostengünstiges Modell, und führen das Fine-Tuning mit der Gemini Enterprise Agent Platform durch.
Überblick über die Architektur
Das werden wir erstellen:
- Cloud Shell: Ihre Entwicklungsumgebung.
- Cloud Storage: Hier werden Trainings- und Validierungsdaten im JSONL-Format gespeichert.
- Gemini Enterprise Agent Platform Training: Verwaltet den Feinabstimmungsjob.
- Gemini Enterprise Agent Platform-Endpunkt: Hier wird Ihr feinabgestimmtes Modell gehostet.
Lerninhalte
- Hochwertige Datasets für die überwachte Feinabstimmung vorbereiten
- Feinabstimmungsjobs mit dem Gemini Enterprise Agent Platform SDK für Python konfigurieren und starten
- Bewerten Sie Modelle anhand automatisierter Messwerte (ROUGE-Werte).
- Vergleichen Sie Basis- und abgestimmte Modelle, um Verbesserungen zu quantifizieren.
2. Projekt einrichten
Google-Konto
Wenn Sie noch kein privates Google-Konto haben, müssen Sie ein Google-Konto erstellen.
Verwenden Sie stattdessen ein privates Konto anstelle eines Kontos einer Bildungseinrichtung.
In der Google Cloud Console anmelden
Melden Sie sich mit einem privaten Google-Konto in der Google Cloud Console an.
Abrechnung aktivieren
Google Cloud-Guthaben einlösen (optional)
Für diesen Workshop benötigen Sie ein Abrechnungskonto mit Guthaben. Verwenden Sie das Guthaben aus dem Banner oben in diesem Codelab, um loszulegen. Wenn Sie bereits mit einem Rechnungskonto verbunden sind, können Sie diesen Schritt überspringen.
Projekt erstellen (optional)
Wenn Sie kein aktuelles Projekt haben, das Sie für dieses Lab verwenden möchten, erstellen Sie hier ein neues Projekt.
3. Cloud Shell-Editor öffnen
- Klicken Sie auf diesen Link, um direkt zum Cloud Shell-Editor zu gelangen.
- Wenn Sie heute zu irgendeinem Zeitpunkt zur Autorisierung aufgefordert werden, klicken Sie auf Autorisieren, um fortzufahren.

- Wenn das Terminal nicht unten auf dem Bildschirm angezeigt wird, öffnen Sie es:
- Klicken Sie auf Ansehen.
- Klicken Sie auf Terminal

- Legen Sie im Terminal Ihr Projekt mit diesem Befehl fest:
gcloud config set project [PROJECT_ID]- Beispiel:
gcloud config set project lab-project-id-example - Wenn Sie sich nicht an Ihre Projekt-ID erinnern können, können Sie alle Ihre Projekt-IDs mit folgendem Befehl auflisten:
gcloud projects list
- Beispiel:
- Es sollte folgende Meldung angezeigt werden:
Updated property [core/project].
4. APIs aktivieren
Wenn Sie die Gemini Enterprise Agent Platform und andere Dienste verwenden möchten, müssen Sie die erforderlichen APIs in Ihrem Google Cloud-Projekt aktivieren.
- Aktivieren Sie die APIs im Terminal:
- Vertex AI API (
aiplatform.googleapis.com): Ermöglicht die Verwendung von Vertex AI zum Feinabstimmen und Bereitstellen von Modellen. - Cloud Storage API (
storage.googleapis.com): Ermöglicht das Speichern von Datasets und Modellartefakten.
gcloud services enable aiplatform.googleapis.com \ storage.googleapis.com - Vertex AI API (
5. Projektumgebung einrichten
Arbeitsverzeichnis erstellen
- Erstellen Sie im Terminal ein Verzeichnis für Ihr Projekt und rufen Sie es auf.
mkdir gemini-finetuning cd gemini-finetuning
Umgebungsvariablen einrichten
- Definieren Sie im Terminal die Umgebungsvariablen für Ihr Projekt. Wir erstellen eine
env.sh-Datei, in der diese Variablen gespeichert werden, damit sie bei einer Trennung der Sitzung problemlos neu geladen werden können.cat <<EOF > env.sh export PROJECT_ID=\$(gcloud config get-value project) export REGION="us-central1" export LOCATION="global" export BUCKET_NAME="\${PROJECT_ID}-gemini-tuning" EOF source env.sh
Cloud Storage-Bucket erstellen
- Erstellen Sie im Terminal einen Bucket zum Speichern Ihres Datasets und Ihrer Modellartefakte.
gcloud storage buckets create gs://$BUCKET_NAME --project=$PROJECT_ID --location=$REGION
Virtuelle Umgebung einrichten
- Wir verwenden
uv, um unsere Python-Umgebung zu verwalten. Führen Sie im Terminal folgenden Befehl aus:uv venv .venv source .venv/bin/activate - Installieren Sie im Terminal die erforderlichen Python-Pakete.
uv pip install google-cloud-aiplatform rouge-score matplotlib pandas tqdm
6. Trainingsdaten vorbereiten
Hochwertige Daten sind die Grundlage für eine erfolgreiche Feinabstimmung. Sie verwenden das WikiLingua-Dataset, wandeln es in das spezifische JSONL-Format um, das für Gemini erforderlich ist, und laden es in Ihren Speicher-Bucket hoch.
- Erstellen Sie im Terminal eine Datei mit dem Namen
prepare_data.py.cloudshell edit prepare_data.py - Fügen Sie den folgenden Code in
prepare_data.pyein.import json import os import pandas as pd from google.cloud import storage import subprocess # Configuration BUCKET_NAME = os.environ["BUCKET_NAME"] PROJECT_ID = os.environ["PROJECT_ID"] def download_data(): print("Downloading WikiLingua dataset...") # Using gsutil to copy from public bucket subprocess.run(["gsutil", "cp", "gs://github-repo/generative-ai/gemini/tuning/summarization/wikilingua/*", "."], check=True) def convert_to_gemini_format(input_file, output_file, max_samples=1000): print(f"Converting {input_file} to Gemini format (first {max_samples} samples)...") converted_data = [] with open(input_file, 'r') as f: for i, line in enumerate(f): if i >= max_samples: break obj = json.loads(line) messages = obj.get("messages", []) # Convert messages to Gemini format # Input: {"messages": [{"role": "user", "content": "..."}, {"role": "model", "content": "..."}]} # Output: {"contents": [{"role": "user", "parts": [{"text": "..."}]}, {"role": "model", "parts": [{"text": "..."}]}]} contents = [] for msg in messages: role = msg["role"] content = msg["content"] contents.append({ "role": role, "parts": [{"text": content}] }) converted_data.append({"contents": contents}) with open(output_file, 'w') as f: for item in converted_data: f.write(json.dumps(item) + "\n") print(f"Saved {len(converted_data)} examples to {output_file}") def upload_to_gcs(local_file, destination_blob_name): print(f"Uploading {local_file} to gs://{BUCKET_NAME}/{destination_blob_name}...") storage_client = storage.Client(project=PROJECT_ID) bucket = storage_client.bucket(BUCKET_NAME) blob = bucket.blob(destination_blob_name) blob.upload_from_filename(local_file) print("Upload complete.") def main(): download_data() # Process Training Data convert_to_gemini_format("sft_train_samples.jsonl", "train_gemini.jsonl") upload_to_gcs("train_gemini.jsonl", "datasets/train/train_gemini.jsonl") # Process Validation Data convert_to_gemini_format("sft_val_samples.jsonl", "val_gemini.jsonl") upload_to_gcs("val_gemini.jsonl", "datasets/val/val_gemini.jsonl") print("Data preparation complete!") if __name__ == "__main__": main() - Führen Sie im Terminal das Skript zur Datenvorbereitung aus.
python prepare_data.py
7. Referenzleistung ermitteln
Vor dem Feinabstimmen benötigen Sie einen Benchmark. Sie messen anhand von ROUGE-Werten, wie gut das Basismodell gemini-3.5-flash bei der Zusammenfassungsaufgabe abschneidet.
- Erstellen Sie im Terminal eine Datei mit dem Namen
evaluate.py.cloudshell edit evaluate.py - Fügen Sie den folgenden Code in
evaluate.pyein.import argparse import json import os import pandas as pd from google import genai from google.genai import types from rouge_score import rouge_scorer from tqdm import tqdm import matplotlib.pyplot as plt import time # Configuration for Google Gen AI SDK PROJECT_ID = os.environ.get("PROJECT_ID", "") def get_client(model_name): os.environ["GOOGLE_GENAI_USE_ENTERPRISE"] = "true" os.environ["GOOGLE_CLOUD_PROJECT"] = PROJECT_ID if "locations/" in model_name: parts = model_name.split("/") loc = parts[parts.index("locations") + 1] if loc == "us": loc = "us-central1" else: loc = os.environ.get("LOCATION", "global") os.environ["GOOGLE_CLOUD_LOCATION"] = loc return genai.Client() def evaluate(model_name, test_file, max_samples=50, output_json="results.json"): print(f"Evaluating model: {model_name}") client = get_client(model_name) # Load Test Data test_df = pd.read_csv(test_file) test_df = test_df.head(max_samples) config = types.GenerateContentConfig( temperature=0.1, max_output_tokens=1024, ) scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True) results = [] for index, row in tqdm(test_df.iterrows(), total=len(test_df)): input_text = row['input_text'] reference_summary = row['output_text'] try: response = client.models.generate_content( model=model_name, contents=input_text, config=config, ) generated_summary = response.text scores = scorer.score(reference_summary, generated_summary) results.append({ "generated": generated_summary, "reference": reference_summary, "rouge1": scores['rouge1'].fmeasure, "rouge2": scores['rouge2'].fmeasure, "rougeL": scores['rougeL'].fmeasure }) except Exception as e: print(f"Error processing example {index}: {e}") # Sleep briefly to avoid quota issues if hitting limits time.sleep(1) # Save results with open(output_json, 'w') as f: json.dump(results, f, indent=2) return pd.DataFrame(results) def plot_results(df, title, filename): os.makedirs("plots", exist_ok=True) metrics = ['rouge1', 'rouge2', 'rougeL'] fig, axes = plt.subplots(1, 3, figsize=(15, 5)) for i, metric in enumerate(metrics): axes[i].hist(df[metric], bins=10, alpha=0.7, color='skyblue', edgecolor='black') axes[i].set_title(f'{metric} Distribution') axes[i].set_xlabel('Score') axes[i].set_ylabel('Count') plt.suptitle(title) plt.tight_layout() plt.savefig(f"plots/{filename}") print(f"Plot saved to plots/{filename}") def compare_results(baseline_file, tuned_file): with open(baseline_file, 'r') as f: baseline_data = pd.DataFrame(json.load(f)) with open(tuned_file, 'r') as f: tuned_data = pd.DataFrame(json.load(f)) print("\n--- Comparison ---") metrics = ['rouge1', 'rouge2', 'rougeL'] for metric in metrics: base_mean = baseline_data[metric].mean() tuned_mean = tuned_data[metric].mean() diff = tuned_mean - base_mean print(f"{metric}: Base={base_mean:.4f}, Tuned={tuned_mean:.4f}, Diff={diff:+.4f}") # Comparative Plot os.makedirs("plots", exist_ok=True) comparison_df = pd.DataFrame({ 'Metric': metrics, 'Baseline': [baseline_data[m].mean() for m in metrics], 'Tuned': [tuned_data[m].mean() for m in metrics] }) comparison_df.plot(x='Metric', y=['Baseline', 'Tuned'], kind='bar', figsize=(10, 6)) plt.title('Baseline vs Tuned Model Performance') plt.ylabel('Average Score') plt.xticks(rotation=0) plt.tight_layout() plt.savefig("plots/comparison.png") print("Comparison plot saved to plots/comparison.png") def main(): parser = argparse.ArgumentParser() parser.add_argument("--model", type=str, default="gemini-3.5-flash", help="Model resource name") parser.add_argument("--baseline", type=str, help="Path to baseline results json for comparison") parser.add_argument("--output", type=str, default="results.json", help="Output file for results") args = parser.parse_args() # Ensure test data exists (it was downloaded in prepare_data step) if not os.path.exists("sft_test_samples.csv"): # Fallback download if needed subprocess.run(["gsutil", "cp", "gs://github-repo/generative-ai/gemini/tuning/summarization/wikilingua/sft_test_samples.csv", "."], check=True) df = evaluate(args.model, "sft_test_samples.csv", output_json=args.output) print("\n--- Results Summary ---") print(df.describe()) plot_filename = "baseline_dist.png" if not args.baseline else "tuned_dist.png" plot_results(df, f"ROUGE Scores - {args.model}", plot_filename) if args.baseline: compare_results(args.baseline, args.output) if __name__ == "__main__": main() - Führen Sie im Terminal die Baseline-Bewertung aus.
Dadurch wird einepython evaluate.py --model "gemini-3.5-flash" --output "baseline.json"baseline.json-Datei und ein Diagramm inplots/baseline_dist.pnggeneriert.
8. Feinabstimmung konfigurieren und starten
Als Nächstes starten Sie einen verwalteten Fine-Tuning-Job in der Gemini Enterprise Agent Platform.
- Erstellen Sie im Terminal eine Datei mit dem Namen
tune.py.cloudshell edit tune.py - Fügen Sie den folgenden Code in
tune.pyein.import os import time from google import genai from google.genai import types # Configuration for Google Gen AI SDK os.environ["GOOGLE_GENAI_USE_ENTERPRISE"] = "true" os.environ["GOOGLE_CLOUD_PROJECT"] = os.environ.get("PROJECT_ID", "") os.environ["GOOGLE_CLOUD_LOCATION"] = os.environ.get("REGION", "us-central1") BUCKET_NAME = os.environ["BUCKET_NAME"] client = genai.Client() def train(): print("Launching fine-tuning job...") training_dataset = types.TuningDataset( gcs_uri=f"gs://{BUCKET_NAME}/datasets/train/train_gemini.jsonl" ) validation_dataset = types.TuningValidationDataset( gcs_uri=f"gs://{BUCKET_NAME}/datasets/val/val_gemini.jsonl" ) tuning_job = client.tunings.tune( base_model="gemini-3.5-flash", training_dataset=training_dataset, config=types.CreateTuningJobConfig( tuned_model_display_name="gemini-3.5-flash-wikilingua", validation_dataset=validation_dataset, adapter_size=types.AdapterSize.ADAPTER_SIZE_FOUR, epoch_count=1, ), ) print(f"Job started: {tuning_job.name}") print("Waiting for job to complete... (this may take ~45 minutes)") running_states = {"JOB_STATE_PENDING", "JOB_STATE_RUNNING"} while tuning_job.state in running_states: time.sleep(60) tuning_job = client.tunings.get(name=tuning_job.name) print(f"Status: {tuning_job.state}") print("Job completed!") print(f"Tuned Model Endpoint: {tuning_job.tuned_model.endpoint}") return tuning_job.tuned_model.endpoint if __name__ == "__main__": train() - Führen Sie im Terminal das Fine-Tuning-Script aus.
Hinweis: Dieser Vorgang kann etwa 45 Minuten dauern. Sie können den Job in der Gemini Enterprise Agent Platform Console überwachen.python tune.py
9. Trainingscode verstehen
Während der Job ausgeführt wird, sehen wir uns das tune.py-Skript genauer an, um zu verstehen, wie das Fine-Tuning funktioniert.
Verwaltete überwachte Feinabstimmung
Das Skript verwendet die Methode vertexai.tuning.sft.train, um einen verwalteten Abstimmungsjob zu senden. Dadurch wird die Komplexität der Bereitstellung von Infrastruktur, der Verteilung des Trainings und der Verwaltung von Checkpoints abstrahiert.
sft_tuning_job = sft.train(
source_model="gemini-3.5-flash",
train_dataset=f"gs://{BUCKET_NAME}/datasets/train/train_gemini.jsonl",
# ...
)
LoRA-Konfiguration
Anstatt eine LoraConfig manuell zu definieren, wie es in Open-Source-Frameworks üblich ist, wird dies in der Gemini Enterprise Agent Platform auf einige wenige Schlüsselparameter reduziert:
adapter_size: Dieser Parameter (in unserem Skript auf4festgelegt) steuert den Rang der LoRA-Adapter. Eine größere Größe ermöglicht es dem Modell, komplexere Anpassungen zu lernen, erhöht aber die Anzahl der trainierbaren Parameter.epochs: In diesem Lab wird dieser Wert auf1gesetzt, um die Trainingszeit kurz zu halten (ca. 20 Minuten). In einem Produktionsszenario können Sie diesen Wert erhöhen, damit das Modell mehr aus Ihren Daten lernen kann. Achten Sie jedoch auf eine Überanpassung.
Modellauswahl
Wir geben source_model="gemini-3.5-flash" explizit an. Die Gemini Enterprise Agent Platform unterstützt verschiedene Versionen von Gemini. Wenn Sie eine bestimmte Version festlegen, bleibt Ihre Pipeline stabil und reproduzierbar.
10. Modelle vergleichen
Sobald der Feinabstimmungsjob abgeschlossen ist, können Sie die Leistung Ihres neuen Modells mit der Baseline vergleichen.
- Rufen Sie den Endpunkt des feinabgestimmten Modells ab. Sie wurde am Ende des
tune.py-Skripts ausgegeben. Das sieht ungefähr so aus:projects/.../locations/.../endpoints/.... - Führen Sie das Bewertungsskript noch einmal aus. Übergeben Sie dieses Mal Ihr optimiertes Modell und die Referenzergebnisse zum Vergleich.
# Replace [YOUR_TUNED_MODEL_ENDPOINT] with the actual endpoint name export TUNED_MODEL="projects/[YOUR_PROJECT_ID]/locations/[YOUR_REGION]/endpoints/[YOUR_ENDPOINT_ID]" python evaluate.py --model "$TUNED_MODEL" --baseline "baseline.json" --output "tuned.json" - Rufen Sie die Ergebnisse auf. Das Skript gibt einen Vergleich der ROUGE-Werte aus und generiert ein
plots/comparison.png-Diagramm, in dem die Verbesserung dargestellt wird.Sie können die Diagramme ansehen, indem Sie den Ordnerplotsim Cloud Shell-Editor öffnen.
11. Bereinigen
Löschen Sie die erstellten Ressourcen, um Gebühren zu vermeiden.
- Löschen Sie im Terminal den Cloud Storage-Bucket und das abgestimmte Modell.
gcloud storage rm -r gs://$BUCKET_NAME # Note: You can delete the model endpoint from the Gemini Enterprise Agent Platform Console
12. Glückwunsch!
Sie haben Gemini 3.5 Flash auf der Gemini Enterprise Agent Platform erfolgreich feinabgestimmt.
Zusammenfassung
Die Aufgaben in diesem Lab:
- Sie haben ein Dataset im JSONL-Format für die Gemini-Feinabstimmung vorbereitet.
- Es wurde eine Baseline mit dem Basismodell Gemini 3.5 Flash erstellt.
- Sie haben einen Job für überwachte Feinabstimmung auf der Gemini Enterprise Agent Platform gestartet.
- Das feinabgestimmte Modell wurde bewertet und mit der Baseline verglichen.
Nächste Schritte
Dieses Lab ist Teil des Lernpfads Produktionsreife KI mit Google Cloud.
Vollständigen Lehrplan ansehen
Teilen Sie Ihre Fortschritte unter dem Hashtag #ProductionReadyAI.