Texteinbettungen abstimmen

Auf dieser Seite erfahren Sie, wie Sie Texteinbettungsmodelle optimieren.

Foundation-Einbettungsmodelle werden mit einem riesigen Text-Dataset vortrainiert und bieten eine solide Grundlage für viele Aufgaben. In Szenarien, die spezielles Wissen oder eine stark angepasste Leistung erfordern, können Sie mit der Modellabstimmung die Darstellungen des Modells anhand Ihrer eigenen relevanten Daten optimieren. Die Abstimmung wird für die folgenden Texteinbettungsmodelle unterstützt:

Klicken, um unterstützte Modelle einzublenden

  • text-embedding-004
  • text-embedding-005
  • text-multilingual-embedding-002

Texteinbettungsmodelle unterstützen die überwachte Abstimmung. Die überwachte Abstimmung verwendet Beispiele für Labels, die die Art von Ausgabe zeigen, die Sie aus Ihrem Texteinbettungsmodell während der Inferenz verwenden möchten.

Weitere Informationen zur Modellabstimmung finden Sie unter Funktionsweise der Modellabstimmung.

Erwartete Qualitätsverbesserung

Die Gemini Enterprise Agent Platform verwendet eine parametereffiziente Abstimmungsmethode für die Anpassung. Diese Methode zeigt bei Tests mit öffentlichen Benchmark-Datasets für den Abruf erhebliche Qualitätssteigerungen von bis zu 41 % (durchschnittlich 12 %).

Anwendungsfall für die Abstimmung eines Einbettungsmodells

Durch das Abstimmen eines Texteinbettungsmodells kann Ihr Modell die Einbettungen an eine bestimmte Domain oder Aufgabe anpassen. Das kann nützlich sein, wenn das vortrainierte Einbettungsmodell nicht gut zu Ihren spezifischen Anforderungen passt. Sie können beispielsweise ein Einbettungsmodell mit einem bestimmten Dataset von Kundensupport-Tickets für Ihr Unternehmen optimieren. Dadurch kann ein Chatbot die verschiedenen Arten von Kundensupportproblemen verstehen, die Ihre Kunden normalerweise haben, und in der Lage sein, ihre Fragen effektiver beantworten zu können. Ohne Abstimmung kennt das Modell nicht die Details Ihrer Kundensupport-Tickets oder die Lösungen für bestimmte Probleme mit Ihrem Produkt.

Abstimmungsworkflow

Der Workflow zur Modellabstimmung auf der Gemini Enterprise Agent Platform sieht so aus:

  • Modellabstimmungs-Dataset vorbereiten
  • Laden Sie den Datensatz zur Modellabstimmung in einen Cloud Storage-Bucket hoch.
  • Projekt für Gemini Enterprise Agent Platform-Pipelines konfigurieren
  • Modellabstimmungsjob erstellen
  • Stellen Sie das abgestimmte Modell auf einem Gemini Enterprise Agent Platform-Endpunkt mit demselben Namen bereit. Im Gegensatz zu Textmodell-Abstimmungsjobs werden Ihre abgestimmten Modelle durch einen Abstimmungsjob für Texteinbettungen nicht auf einem Gemini Enterprise Agent Platform-Endpunkt bereitgestellt.

Einbettungs-Dataset vorbereiten

Das Dataset zum Optimieren eines Einbettungsmodells enthält Daten, die auf die Aufgabe ausgerichtet sind, welche das Modell ausführen soll.

Dataset-Format zum Abstimmen eines Einbettungsmodells

Das Trainings-Dataset besteht aus den folgenden Dateien, die sich in Cloud Storage befinden müssen. Der Pfad der Dateien wird beim Starten der Abstimmungspipeline durch Parameter definiert. Die drei Dateitypen sind die Korpusdatei, die Abfragedatei und die Labels. Es sind nur Trainingslabels erforderlich, aber Sie können auch Validierungs- und Testlabels angeben, um mehr Kontrolle zu haben.

  • Corpus-Datei: Der Pfad wird durch den Parameter corpus_path definiert. Es handelt sich um eine JSONL-Datei, in der jede Zeile die Felder _id, title und text mit Stringwerten enthält. _id und text sind erforderlich, title ist optional. Hier sehen Sie eine corpus.jsonl-Beispieldatei:

    {"_id": "doc1", "title": "Get an introduction to Agent Platform", "text": "Agent Studio offers a Google Cloud console tool for rapidly prototyping and testing generative AI models. Learn how you can use Agent Studio to test models using prompt samples, design and save prompts, tune a foundation model, and convert between speech and text."}
{"_id": "doc2", "title": "Use gen AI for summarization, classification, and extraction", "text": "Learn how to create text prompts for handling any number of tasks with Agent Platform's generative AI support. Some of the most common tasks are classification, summarization, and extraction. Agent Platform's PaLM API for text lets you design prompts with flexibility in terms of their structure and format."}
{"_id": "doc3", "title": "Custom ML training overview and documentation", "text": "Get an overview of the custom training workflow in Agent Platform, the benefits of custom training, and the various training options that are available. This page also details every step involved in the ML training workflow from preparing data to inferences."}
{"_id": "doc4", "text": "Text embeddings are useful for clustering, information retrieval, retrieval-augmented generation (RAG), and more."}
{"_id": "doc5", "title": "Text embedding tuning", "text": "Google's text embedding models can be tuned on Agent Platform."}

  • Abfragedatei: Die Abfragedatei enthält Ihre Beispielabfragen. Der Pfad wird durch den Parameter queries_path definiert. Die Abfragedatei hat das JSONL-Format und dieselben Felder wie die Korpusdatei. Hier sehen Sie eine queries.jsonl-Beispieldatei:

    {"_id": "query1", "text": "Does Vertex support generative AI?"}
{"_id": "query2", "text": "What can I do with Vertex GenAI offerings?"}
{"_id": "query3", "text": "How do I train my models using Vertex?"}
{"_id": "query4", "text": "What is a text embedding?"}
{"_id": "query5", "text": "Can text embedding models be tuned on Vertex?"}
{"_id": "query6", "text": "embeddings"}
{"_id": "query7", "text": "embeddings for rag"}
{"_id": "query8", "text": "custom model training"}
{"_id": "query9", "text": "Google Cloud PaLM API"}

  • Trainingslabels: Der Pfad wird durch den Parameter train_label_path definiert. Der „train_label_path“ ist der Cloud Storage-URI zum Speicherort der Trainingslabeldaten und wird beim Erstellen des Abstimmungsjobs angegeben. Die Labels müssen in einer TSV-Datei mit einer Kopfzeile enthalten sein. Eine Teilmenge der Abfragen und des Korpus muss in der Datei mit den Trainingslabels enthalten sein. Die Datei muss die Spalten query-id, corpus-id und score enthalten. query-id ist ein String, der mit dem Schlüssel _id aus der Abfragedatei übereinstimmt. corpus-id ist ein String, der mit dem Schlüssel _id in der Korpusdatei übereinstimmt. Score ist ein nicht negativer Ganzzahlwert. Wenn ein Paar aus Abfrage und Dokument nicht zusammengehört, können Sie es entweder aus der Datei mit den Trainingslabels weglassen oder mit einer Punktzahl von null einfügen. Jeder Wert über null gibt an, dass das Dokument mit der Abfrage zusammenhängt. Je höher die Zahl, desto höher die Relevanz. Wenn der Wert weggelassen wird, ist der Standardwert 1. Hier sehen Sie eine train_labels.tsv-Beispieldatei:

    query-id  corpus-id   score
query1    doc1    1
query2    doc2    1
query3    doc3    2
query3    doc5  1
query4    doc4  1
query4    doc5  1
query5    doc5  2
query6    doc4  1
query6    doc5  1
query7    doc4  1
query8    doc3  1
query9    doc2  1

  • Test labels: Optional. Die Testlabels haben dasselbe Format wie die Trainingslabels und werden durch den Parameter test_label_path angegeben. Wenn kein test_label_path angegeben ist, werden die Testlabels automatisch von den Trainingslabels getrennt.

  • Validierungs-Labels: Optional. Die Validierungs-Labels haben dasselbe Format wie die Trainings-Labels und werden durch den Parameter validation_label_path angegeben. Wenn kein validation_label_path angegeben ist, werden die Validierungs-Labels automatisch von den Trainings-Labels getrennt.

Anforderungen an die Dataset-Größe

Die bereitgestellten Dataset-Dateien müssen die folgenden Einschränkungen erfüllen:

  • Die Anzahl der Abfragen muss zwischen 9 und 10.000 liegen.
  • Die Anzahl der Dokumente im Korpus muss zwischen 9 und 500.000 liegen.
  • Jede Dataset-Labeldatei muss mindestens 3 Abfrage-IDs enthalten und in allen Dataset-Aufteilungen müssen mindestens 9 Abfrage-IDs vorhanden sein.
  • Die Gesamtzahl der Labels muss kleiner als 500.000 sein.

Projekt für Gemini Enterprise Agent Platform-Pipelines konfigurieren

Die Abstimmung erfolgt in Ihrem Projekt über die Plattform Gemini Enterprise Agent Platform Pipelines.

Berechtigungen konfigurieren

Die Pipeline führt Trainingscode unter zwei Dienst-Agents aus. Diesen Dienst-Agents müssen bestimmte Rollen zugewiesen werden, damit das Training mit Ihrem Projekt und Dataset beginnen kann.

Standardmäßiges Compute Engine-Dienstkonto
PROJECT_NUMBER-compute@developer.gserviceaccount.com

Für dieses Dienstkonto ist Folgendes erforderlich:

  • Storage Object Viewer-Zugriff auf jede Dataset-Datei, die Sie in Cloud Storage erstellt haben.
  • Storage Object User-Zugriff auf das Cloud Storage-Ausgabeverzeichnis Ihrer Pipeline PIPELINE_OUTPUT_DIRECTORY.
  • Agent Platform User-Zugriff auf Ihr Projekt.

Anstelle des Compute Engine-Standarddienstkontos können Sie ein benutzerdefiniertes Dienstkonto angeben. Weitere Informationen finden Sie unter Dienstkonto mit detaillierten Berechtigungen konfigurieren.

Gemini Enterprise Agent Platform Tuning Service Agent
service-PROJECT_NUMBER@gcp-sa-aiplatform-ft.iam.gserviceaccount.com

Für dieses Dienstkonto ist Folgendes erforderlich:

  • Storage Object Viewer-Zugriff auf jede Dataset-Datei, die Sie in Cloud Storage erstellt haben.
  • Storage Object User-Zugriff auf das Cloud Storage-Ausgabeverzeichnis Ihrer Pipeline PIPELINE_OUTPUT_DIRECTORY.

Weitere Informationen zum Konfigurieren von Cloud Storage-Dataset-Berechtigungen finden Sie unter Cloud Storage-Bucket für Pipeline-Artefakte konfigurieren.

Beschleuniger verwenden

Für die Abstimmung sind GPU-Beschleuniger erforderlich. Für die Pipeline zur Abstimmung von Texteinbettungen können die folgenden Beschleuniger verwendet werden:

  • NVIDIA_L4
  • NVIDIA_TESLA_A100
  • NVIDIA_TESLA_T4
  • NVIDIA_TESLA_V100
  • NVIDIA_TESLA_P100

Zum Starten eines Abstimmungsjobs ist ein ausreichendes Restricted image training GPUs-Kontingent für den ausgewählten Beschleunigertyp und die ausgewählte Region erforderlich, z. B. Restricted image training Nvidia V100 GPUs per region. Informationen zum Erhöhen des Kontingents Ihres Projekts finden Sie unter Zusätzliches Kontingent anfordern.

Nicht alle Beschleuniger sind in allen Regionen verfügbar. Weitere Informationen finden Sie unter Beschleuniger in der Gemini Enterprise Agent Platform verwenden.

Feinabstimmungsjob für Einbettungsmodelle erstellen

Sie können einen Feinabstimmungsjob für Einbettungsmodelle mit der Google Cloud Console, der REST API oder Clientbibliotheken erstellen.

REST

Verwenden Sie zum Erstellen eines Feinabstimmungsjobs für Einbettungsmodelle die Methode projects.locations.pipelineJobs.create.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PROJECT_ID: Ihre Google Cloud Projekt-ID
  • PIPELINE_OUTPUT_DIRECTORY: Pfad für die Pipeline-Ausgabeartefakte, beginnend mit „gs://“.

HTTP-Methode und URL: 

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

JSON-Text anfordern:

{
  "displayName": "tune_text_embeddings_model_sample",
  "runtimeConfig": {
    "gcsOutputDirectory": "PIPELINE_OUTPUT_DIRECTORY",
    "parameterValues": {
      "corpus_path": "gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/corpus.jsonl",
      "queries_path": "gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/queries.jsonl",
      "train_label_path": "gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/train.tsv",
      "test_label_path": "gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/test.tsv",
      "base_model_version_id":"text-embedding-004",
      "task_type": "DEFAULT",
      "batch_size": "128",
      "train_steps": "1000",
      "output_dimensionality": "768",
      "learning_rate_multiplier": "1.0"
    }
  },
  "templateUri": "https://us-kfp.pkg.dev/ml-pipeline/llm-text-embedding/tune-text-embedding-model/v1.1.3"
}

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

Nachdem Sie die Pipeline gestartet haben, können Sie den Fortschritt des Abstimmungsjobs in der Google Cloud Console verfolgen.

Zur Google Cloud Console

Python

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für Python in der Kurzanleitung zur Verwendung von Clientbibliotheken für die Agent Platform.

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

import os

from google.cloud import aiplatform

# TODO (Developer) set the following environment variables.
PROJECT_ID = os.getenv("PROJECT_ID")
LOCATION_ID = os.getenv("LOCATION_ID", "us-central1")
MODEL_NAME = os.getenv("MODEL_NAME", "text-embedding-004")
# A storage bucket: gs://your-bucket-name/embedding-tuning-output
OUTPUT_URI = os.getenv("OUTPUT_DIR")

TRAIN_LABEL_PATH = (
    "gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/train.tsv"
)
TEST_LABEL_PATH = (
    "gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/test.tsv"
)
CORPUS_PATH = (
    "gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/corpus.jsonl"
)
QUERIES_PATH = (
    "gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/queries.jsonl"
)

ACCELERATOR_TYPE = "NVIDIA_L4"

# Official Google Cloud KFP pipeline template URI for text embedding model tuning
EMBEDDING_TUNING_PIPELINE_URI = "https://us-kfp.pkg.dev/ml-pipeline/llm-text-embedding/tune-text-embedding-model/v1.1.3"


def tune_embedding_model() -> aiplatform.PipelineJob:
    """Tune an embedding model using the specified parameters."""

    aiplatform.init(project=PROJECT_ID, location=LOCATION_ID)

    # Configure parameters expected by the embedding tuning pipeline template
    pipeline_parameters = {
        "base_model_version_id": MODEL_NAME,
        "corpus_path": CORPUS_PATH,
        "queries_path": QUERIES_PATH,
        "train_label_path": TRAIN_LABEL_PATH,
        "test_label_path": TEST_LABEL_PATH,
        "accelerator_type": ACCELERATOR_TYPE,
    }

    # Instantiate the Vertex AI Pipeline job
    pipeline_job = aiplatform.PipelineJob(
        display_name="tune-text-embedding-model-job",
        template_path=EMBEDDING_TUNING_PIPELINE_URI,
        pipeline_root=OUTPUT_URI,
        parameter_values=pipeline_parameters,
        project=PROJECT_ID,
        location=LOCATION_ID,
    )

    pipeline_job.submit()

    print(f"Pipeline submitted successfully: {pipeline_job.resource_name}")

    return pipeline_job

Java

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für Java in der Kurzanleitung zur Verwendung von Clientbibliotheken für die Agent Platform.

Richten Sie zur Authentifizierung bei der Agent Platform 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.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class EmbeddingModelTuningSample {
  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running this sample.
    String apiEndpoint = "us-central1-aiplatform.googleapis.com:443";
    String project = "PROJECT";
    String baseModelVersionId = "BASE_MODEL_VERSION_ID";
    String taskType = "DEFAULT";
    String pipelineJobDisplayName = "PIPELINE_JOB_DISPLAY_NAME";
    String outputDir = "OUTPUT_DIR";
    String queriesPath = "QUERIES_PATH";
    String corpusPath = "CORPUS_PATH";
    String trainLabelPath = "TRAIN_LABEL_PATH";
    String testLabelPath = "TEST_LABEL_PATH";
    double learningRateMultiplier = 1.0;
    int outputDimensionality = 768;
    int batchSize = 128;
    int trainSteps = 1000;

    createEmbeddingModelTuningPipelineJob(
        apiEndpoint,
        project,
        baseModelVersionId,
        taskType,
        pipelineJobDisplayName,
        outputDir,
        queriesPath,
        corpusPath,
        trainLabelPath,
        testLabelPath,
        learningRateMultiplier,
        outputDimensionality,
        batchSize,
        trainSteps);
  }

  public static PipelineJob createEmbeddingModelTuningPipelineJob(
      String apiEndpoint,
      String project,
      String baseModelVersionId,
      String taskType,
      String pipelineJobDisplayName,
      String outputDir,
      String queriesPath,
      String corpusPath,
      String trainLabelPath,
      String testLabelPath,
      double learningRateMultiplier,
      int outputDimensionality,
      int batchSize,
      int trainSteps)
      throws IOException {
    Matcher matcher = Pattern.compile("^(?<Location>\\w+-\\w+)").matcher(apiEndpoint);
    String location = matcher.matches() ? matcher.group("Location") : "us-central1";
    String templateUri =
        "https://us-kfp.pkg.dev/ml-pipeline/llm-text-embedding/tune-text-embedding-model/v1.1.4";
    PipelineServiceSettings settings =
        PipelineServiceSettings.newBuilder().setEndpoint(apiEndpoint).build();
    try (PipelineServiceClient client = PipelineServiceClient.create(settings)) {
      Map<String, Value> parameterValues =
          Map.of(
              "base_model_version_id", valueOf(baseModelVersionId),
              "task_type", valueOf(taskType),
              "queries_path", valueOf(queriesPath),
              "corpus_path", valueOf(corpusPath),
              "train_label_path", valueOf(trainLabelPath),
              "test_label_path", valueOf(testLabelPath),
              "learning_rate_multiplier", valueOf(learningRateMultiplier),
              "output_dimensionality", valueOf(outputDimensionality),
              "batch_size", valueOf(batchSize),
              "train_steps", valueOf(trainSteps));
      PipelineJob pipelineJob =
          PipelineJob.newBuilder()
              .setTemplateUri(templateUri)
              .setDisplayName(pipelineJobDisplayName)
              .setRuntimeConfig(
                  RuntimeConfig.newBuilder()
                      .setGcsOutputDirectory(outputDir)
                      .putAllParameterValues(parameterValues)
                      .build())
              .build();
      CreatePipelineJobRequest request =
          CreatePipelineJobRequest.newBuilder()
              .setParent(LocationName.of(project, location).toString())
              .setPipelineJob(pipelineJob)
              .build();
      return client.createPipelineJob(request);
    }
  }

  private static Value valueOf(String s) {
    return Value.newBuilder().setStringValue(s).build();
  }

  private static Value valueOf(int n) {
    return Value.newBuilder().setNumberValue(n).build();
  }

  private static Value valueOf(double n) {
    return Value.newBuilder().setNumberValue(n).build();
  }
}

Node.js

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für Node.js in der Kurzanleitung zur Verwendung von Clientbibliotheken für die Agent Platform.

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

async function main(
  apiEndpoint,
  project,
  outputDir,
  pipelineJobDisplayName = 'embedding-customization-pipeline-sample',
  baseModelVersionId = 'text-embedding-005',
  taskType = 'DEFAULT',
  corpusPath = 'gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/corpus.jsonl',
  queriesPath = 'gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/queries.jsonl',
  trainLabelPath = 'gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/train.tsv',
  testLabelPath = 'gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/test.tsv',
  outputDimensionality = 768,
  learningRateMultiplier = 1.0,
  batchSize = 128,
  trainSteps = 1000
) {
  const aiplatform = require('@google-cloud/aiplatform');
  const {PipelineServiceClient} = aiplatform.v1;
  const {helpers} = aiplatform; // helps construct protobuf.Value objects.

  const client = new PipelineServiceClient({apiEndpoint});
  const match = apiEndpoint.match(/(?<L>\w+-\w+)/);
  const location = match ? match.groups.L : 'us-central1';
  const parent = `projects/${project}/locations/${location}`;
  const params = {
    base_model_version_id: baseModelVersionId,
    task_type: taskType,
    queries_path: queriesPath,
    corpus_path: corpusPath,
    train_label_path: trainLabelPath,
    test_label_path: testLabelPath,
    batch_size: batchSize,
    train_steps: trainSteps,
    output_dimensionality: outputDimensionality,
    learning_rate_multiplier: learningRateMultiplier,
  };
  const runtimeConfig = {
    gcsOutputDirectory: outputDir,
    parameterValues: Object.fromEntries(
      Object.entries(params).map(([k, v]) => [k, helpers.toValue(v)])
    ),
  };
  const pipelineJob = {
    templateUri:
      'https://us-kfp.pkg.dev/ml-pipeline/llm-text-embedding/tune-text-embedding-model/v1.1.4',
    displayName: pipelineJobDisplayName,
    runtimeConfig,
  };
  async function createTuneJob() {
    const [response] = await client.createPipelineJob({parent, pipelineJob});
    console.log(`job_name: ${response.name}`);
    console.log(`job_state: ${response.state}`);
  }

  await createTuneJob();
}

Console

Wenn Sie ein Texteinbettungsmodell mithilfe der Google Cloud Console optimieren möchten, können Sie mit den folgenden Schritten eine Anpassungspipeline starten:

  1. Rufen Sie in der Google Cloud Console im Bereich „Agent Platform“ die Seite Gemini Enterprise Agent Platform Pipelines auf.

    Zu den Pipelines der Gemini Enterprise Agent Platform

  2. Klicken Sie auf Ausführung erstellen, um den Bereich Pipeline-Ausführung erstellen zu öffnen.
  3. Klicken Sie auf Aus vorhandenen Pipelines auswählen und geben Sie die folgenden Details ein:
    1. Wählen Sie im Drop-down-Menü Ressource auswählen die Option „ml-pipeline“ aus.
    2. Wählen Sie im Drop-down-Menü Repository die Option „llm-text-embedding“ aus.
    3. Wählen Sie „tune-text-embedding-model“ im Drop-down-Menü Pipeline oder Komponente aus.
    4. Wählen Sie im Drop-down-Menü Version die Version mit der Bezeichnung „v1.1.3“ aus.
  4. Geben Sie einen Ausführungsnamen an, um die Pipelineausführung zu identifizieren.
  5. Wählen Sie in der Drop-down-Liste Region die Region aus, in der die Pipelineausführung erstellt werden soll. Dies ist dieselbe Region, in der Ihr abgestimmtes Modell erstellt wird.
  6. Klicken Sie auf Weiter. Der Bereich Laufzeitkonfiguration wird angezeigt.
  7. Klicken Sie unter Cloud Storage-Speicherort auf Durchsuchen, um den Cloud Storage-Bucket zum Speichern der Pipeline-Ausgabeartefakte auszuwählen. Klicken Sie dann auf Auswählen.
  8. Geben Sie unter Pipelineparameter die Parameter für die Abstimmungspipeline an. Die drei erforderlichen Parameter sind corpus_path, queries_path und train_label_path. Die Formate werden unter Einbettungs-Dataset vorbereiten beschrieben. Weitere Informationen zu den einzelnen Parametern finden Sie auf dem Tab „REST“ in diesem Abschnitt.
  9. Klicken Sie auf Senden, um die Pipelineausführung zu erstellen.

Weitere unterstützte Funktionen

Die Optimierung von Texteinbettungen unterstützt VPC Service Controls und kann so konfiguriert werden, dass sie in einer Virtual Private Cloud (VPC) ausgeführt wird. Dazu wird beim Erstellen der PipelineJob der Parameter network übergeben.

Wenn Sie kundenverwaltete Verschlüsselungsschlüssel (CMEK) verwenden möchten, übergeben Sie den Schlüssel an den Pipelineparameter parameterValues.encryption_spec_key_name sowie an den Parameter encryptionSpec.kmsKeyName, wenn Sie die PipelineJob erstellen.

Feinabgestimmtes Modell verwenden

Feinabgestimmte Modelle in Model Registry ansehen

Wenn der Abstimmungsjob abgeschlossen ist, wird das abgestimmte Modell nicht automatisch auf einem Endpunkt bereitgestellt. Es ist als Modellressource in Model Registry verfügbar. Mit derGoogle Cloud Console können Sie eine Liste der Modelle in Ihrem aktuellen Projekt, einschließlich der abgestimmten Modelle, aufrufen.

Rufen Sie die Seite Gemini Enterprise Agent Platform Model Registry auf, um Ihre optimierten Modelle in der Google Cloud Console aufzurufen.

Zur Model Registry der Gemini Enterprise Agent Platform

Modell bereitstellen

Nachdem Sie das Einbettungsmodell optimiert haben, müssen Sie die Modellressource bereitstellen. Informationen zum Bereitstellen Ihres abgestimmten Einbettungsmodells finden Sie unter Modell auf einem Endpunkt bereitstellen.

Im Gegensatz zu Fundamentmodellen werden abgestimmte Texteinbettungsmodelle vom Nutzer verwaltet. Dazu gehört die Verwaltung von Bereitstellungsressourcen wie Maschinentyp und Beschleunigern. Um Fehler aufgrund mangelnden Arbeitsspeichers während der Inferenz zu vermeiden, wird empfohlen, die Bereitstellung mit dem GPU-Typ NVIDIA_TESLA_A100 durchzuführen. Dieser unterstützt Batchgrößen von bis zu 5 für jede Eingabelänge.

Ihr abgestimmtes Modell unterstützt bis zu 3.072 Tokens und kann längere Eingaben kürzen.

Inferenzen für ein bereitgestelltes Modell abrufen

Sobald Ihr abgestimmtes Modell bereitgestellt ist, können Sie einen der folgenden Befehle verwenden, um Anfragen an den Endpunkt des abgestimmten Modells zu senden.

curl-Beispielbefehle für abgestimmte textembedding-gecko@001-Modelle

Verwenden Sie den folgenden curl-Befehl, um Inferenzen aus einer optimierten Version von textembedding-gecko@001 abzurufen.

PROJECT_ID=PROJECT_ID
LOCATION=LOCATION
ENDPOINT_URI=https://${LOCATION}-aiplatform.googleapis.com
MODEL_ENDPOINT=TUNED_MODEL_ENDPOINT_ID

curl -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json"  \
    ${ENDPOINT_URI}/v1/projects/${PROJECT_ID}/locations/${LOCATION}/endpoints/${MODEL_ENDPOINT}:predict \
    -d '{
  "instances": [
    {
      "content": "Dining in New York City"
    },
    {
      "content": "Best resorts on the east coast"
    }
  ]
}'

curl-Befehle für nicht textembedding-gecko@001-Modelle

Optimierte Versionen anderer Modelle (z. B. textembedding-gecko@003 und textembedding-gecko-multilingual@001) erfordern zwei zusätzliche Eingaben: task_type und title. Weitere Dokumentation zu diesen Parametern finden Sie unter curl-Befehl.

PROJECT_ID=PROJECT_ID
LOCATION=LOCATION
ENDPOINT_URI=https://${LOCATION}-aiplatform.googleapis.com
MODEL_ENDPOINT=TUNED_MODEL_ENDPOINT_ID

curl -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json"  \
    ${ENDPOINT_URI}/v1/projects/${PROJECT_ID}/locations/${LOCATION}/endpoints/${MODEL_ENDPOINT}:predict \
    -d '{
  "instances": [
    {
      "content": "Dining in New York City",
      "task_type": "DEFAULT",
      "title": ""
    },
    {
      "content": "There are many resorts to choose from on the East coast...",
      "task_type": "RETRIEVAL_DOCUMENT",
      "title": "East Coast Resorts"
    }
  ]
}'

Beispielausgabe

Die Ausgabe einer Inferenzanfrage an das bereitgestellte abgestimmte Modell hat nicht dasselbe Format wie die Ausgabe einer Anfrage an die API zum Texteinbetten.

{
 "predictions": [
   [ ... ],
   [ ... ],
   ...
 ],
 "deployedModelId": "...",
 "model": "projects/.../locations/.../models/...",
 "modelDisplayName": "tuned-text-embedding-model",
 "modelVersionId": "1"
}

Nächste Schritte