Texteinbettungen abstimmen

Auf dieser Seite erfahren Sie, wie Sie das Texteinbettungsmodell textembedding-gecko und textembedding-gecko-multilingual optimieren. Diese Foundation Models wurden mit einer großen Menge von öffentlichen Textdaten trainiert. Wenn Sie einen besonderen Anwendungsfall haben, der eigene Trainingsdaten erfordert, können Sie die Modellabstimmung verwenden. Nachdem Sie ein Fundamenteinbettungsmodell optimiert haben, sollte das Modell auf Ihren Anwendungsfall abgestimmt werden. Die Abstimmung wird für stabile Versionen des Texteinbettungsmodells unterstützt.

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. Texteinbettungsmodelle unterstützen keine Abstimmung mit bestärkendem Lernen durch menschliches Feedback (RLHF).

Weitere Informationen zur Modellabstimmung finden Sie unter Funktionsweise der Modellabstimmung.

Erwartete Qualitätssteigerung

Vertex AI verwendet eine parametereffiziente Abstimmungsmethode für die Anpassung. Diese Methode zeigt deutliche Qualitätssteigerungen von bis zu 41% (durchschnittlich 12%) bei Tests, die mit öffentlichen Abruf-Benchmark-Datasets durchgeführt wurden.

Anwendungsfall für die Abstimmung eines Einbettungsmodells

Wenn Sie ein Texteinbettungsmodell optimieren, kann Ihr Modell sich an die Einbettungen an eine bestimmte Domain oder Aufgabe anpassen. Dies kann nützlich sein, wenn das vortrainierte Einbettungsmodell nicht gut für Ihre spezifischen Anforderungen geeignet ist. Sie können beispielsweise ein Einbettungsmodell für ein bestimmtes 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 in Vertex AI für textembedding-gecko und textembedding-gecko-multilingual sieht so aus:

• Modellabstimmungs-Dataset vorbereiten
• Laden Sie den Datensatz zur Modellabstimmung in einen Cloud Storage-Bucket hoch.
• Konfigurieren Sie Ihr Projekt für Vertex AI Pipelines.
• Modellabstimmungsjob erstellen
• Stellen Sie das abgestimmte Modell auf einem Vertex AI-Endpunkt mit demselben Namen bereit. Im Gegensatz zu Text- oder Codey-Modellabstimmungsjobs werden Ihre feinabgestimmten Modelle durch einen Abstimmungsjob für Texteinbettungen nicht auf einem Vertex AI-Endpunkt bereitgestellt.

Einbettungs-Dataset vorbereiten

Das Dataset zum Optimieren eines Einbettungsmodells enthält Daten, die der Aufgabe entsprechen, die das Modell ausführen soll.

Dataset-Format zum Feinabstimmung 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 Korpus-Datei, Abfragedatei und Labels. Es sind nur Trainingslabels erforderlich. Für mehr Kontrolle können Sie aber auch Validierungs- und Testlabels angeben.

• 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 generative AI on Vertex AI", "text": "Vertex AI's Generative AI Studio offers a Google Cloud console tool for rapidly prototyping and testing generative AI models. Learn how you can use Generative AI 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 Vertex AI's generative AI support. Some of the most common tasks are classification, summarization, and extraction. Vertex AI'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 Vertex AI, 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 predictions."}
  {"_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 Vertex AI."}
  

• Abfragedatei: Die Abfragedatei enthält Ihre Beispielabfragen. Der Pfad wird durch den Parameter queries_path definiert. Die Abfragedatei hat das JSONL-Format und hat 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 training_label_path ist der Cloud Storage-URI für den Speicherort der Trainingslabeldaten, der beim Erstellen des Abstimmungsjobs angegeben wird. Die Labels müssen eine TSV-Datei mit einem Header sein. Eine Teilmenge der Abfragen und der Korpus müssen in der Trainingslabeldatei enthalten sein. Die Datei muss die Spalten query-id, corpus-id und score enthalten. Der query-id ist ein String, der mit dem Schlüssel _id aus der Abfragedatei übereinstimmt. Der corpus-id ist ein String, der mit _id in der Korpusdatei übereinstimmt. Score ist eine nicht negative Ganzzahl. Jeder Wert größer als null gibt an, dass das Dokument mit der Abfrage zusammenhängt. Größere Zahlen deuten auf ein höheres Maß an Relevanz hin. 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
  

• Testlabels: 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 aufgeteilt.

• Validierungslabels: Optional. Die Validierungslabels haben dasselbe Format wie die Trainingslabels und werden mit dem Parameter validation_label_path angegeben. Wenn kein validation_label_path angegeben ist, werden die Validierungslabels automatisch von den Trainingslabels aufgeteilt.

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 40.000 liegen.

• Die Anzahl der Dokumente im Korpus muss zwischen 9 und 500.000 liegen.

• Jede Dataset-Labeldatei muss mindestens drei Abfrage-IDs enthalten. In allen Dataset-Aufteilungen muss es mindestens neun Abfrage-IDs geben.

• Die Gesamtzahl der Labels muss kleiner als 500.000 sein.

Projekt für Vertex AI Pipelines konfigurieren

Die Abstimmung wird in Ihrem Projekt mit der Vertex AI Pipelines-Plattform ausgeführt.

Berechtigungen konfigurieren

Die Pipeline führt Trainingscode unter zwei von Google verwalteten Dienstkonten aus. Diese Konten müssen mit bestimmten Berechtigungen konfiguriert werden.

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.

• Vertex AI 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.

Vertex AI-Dienst-Agent

service-PROJECT_NUMBER@gcp-sa-aiplatform.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 Pipelineartefakte konfigurieren.

Beschleuniger verwenden

Jeder der folgenden Beschleuniger kann für die Feinabstimmung 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 Weitere Kontingente anfordern.

Nicht alle Beschleuniger sind in allen Regionen verfügbar. Weitere Informationen finden Sie unter Beschleuniger in Vertex AI verwenden.

Feinabstimmungsjob für Einbettungsmodelle erstellen

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

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

{
  "displayName": "DISPLAY_NAME",
  "runtimeConfig": {
    "gcsOutputDirectory": "PIPELINE_OUTPUT_DIRECTORY",
    "parameterValues": {
      "project": "PROJECT_ID",
      "location": "LOCATION",
      "queries_path": "QUERIES_PATH",
      "corpus_path": "CORPUS_PATH",
      "train_label_path": "TRAIN_LABEL_PATH",
      "test_label_path": "TEST_LABEL_PATH",
      "validation_label_path": "VALIDATION_LABEL_PATH",
      "accelerator_type": "ACCELERATOR_TYPE",
      "accelerator_count": "ACCELERATOR_COUNT",
      "machine_type": "MACHINE_TYPE",
      "base_model_version_id": "BASE_MODEL_VERSION_ID",
      "model_display_name": "MODEL_DISPLAY_NAME",
      "task_type": "TASK_TYPE",
      "batch_size": "BATCH_SIZE",
      "iterations": "ITERATIONS"
    }
  },
  "templateUri": "https://us-kfp.pkg.dev/ml-pipeline/llm-text-embedding/tune-text-embedding-model/v1.1.2"
}

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/pipelineJobs"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/pipelineJobs" | Select-Object -Expand Content

{
  "name": "projects/123456789012/locations/us-central1/pipelineJobs/tune-text-embedding-20231003231411",
  "displayName": "tune-text-embedding-model",
  "createTime": "2023-10-03T23:14:11.705749Z",
  "updateTime": "2023-10-03T23:14:11.705749Z",
  "pipelineSpec": { ... },
  "state": "PIPELINE_STATE_PENDING",
  "labels": {
    "vertex-ai-pipelines-run-billing-id": "1234567890123456789"
  },
  "runtimeConfig": {
    "gcsOutputDirectory": "gs://my-bucket/output-dir",
    "parameterValues": {
      "project": "my-project",
      "location": "us-central1",
      "queries_path": "gs://my-bucket/queries",
      "corpus_path": "gs://my-bucket/corpus",
      "train_label_path": "gs://my-bucket/train",
      "test_label_path": "gs://my-bucket/label",
      "validation_label_path": "",
      "accelerator_type": "NVIDIA_TESLA_V100",
      "accelerator_count": "4",
      "machine_type": "n1-standard-16",
      "base_model_version_id": "textembedding-gecko@003",
      "model_display_name": "tuned-text-embedding-model",
      "task_type" "RETRIEVAL_DOCUMENT",
      "batch_size": "128",
      "iterations": "1000
    }
  },
  "templateUri": "https://us-kfp.pkg.dev/ml-pipeline/llm-text-embedding/tune-text-embedding-model/v1.1.2",
  }

package aiplatform;

// [START aiplatform_sdk_embedding_tuning]
import com.google.cloud.aiplatform.v1beta1.CreatePipelineJobRequest;
import com.google.cloud.aiplatform.v1beta1.LocationName;
import com.google.cloud.aiplatform.v1beta1.PipelineJob;
import com.google.cloud.aiplatform.v1beta1.PipelineJob.RuntimeConfig;
import com.google.cloud.aiplatform.v1beta1.PipelineServiceClient;
import com.google.cloud.aiplatform.v1beta1.PipelineServiceSettings;
import com.google.protobuf.Value;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

public class CreatePipelineJobEmbeddingModelTuningSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "PROJECT";
    String baseModelVersionId = "BASE_MODEL_VERSION_ID";
    String taskType = "TASK_TYPE";
    String location = "us-central1";
    String pipelineJobDisplayName = "PIPELINE_JOB_DISPLAY_NAME";
    String modelDisplayName = "MODEL_DISPLAY_NAME";
    String outputDir = "OUTPUT_DIR";
    String queriesPath = "DATASET_URI";
    String corpusPath = "DATASET_URI";
    String trainLabelPath = "DATASET_URI";
    String testLabelPath = "DATASET_URI";
    int batchSize = 50;
    int iterations = 300;

    createPipelineJobEmbeddingModelTuningSample(
        project,
        baseModelVersionId,
        taskType,
        location,
        pipelineJobDisplayName,
        modelDisplayName,
        outputDir,
        queriesPath,
        corpusPath,
        trainLabelPath,
        testLabelPath,
        batchSize,
        iterations);
  }

  // Create a model tuning job
  public static void createPipelineJobEmbeddingModelTuningSample(
      String project,
      String baseModelVersionId,
      String taskType,
      String location,
      String pipelineJobDisplayName,
      String modelDisplayName,
      String outputDir,
      String queriesPath,
      String corpusPath,
      String trainLabelPath,
      String testLabelPath,
      int batchSize,
      int iterations)
      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("base_model_version_id", stringToValue(baseModelVersionId));
      parameterValues.put("task_type", stringToValue(taskType));
      parameterValues.put(
          "location",
          stringToValue(
              "us-central1")); // Deployment is only supported in us-central1.
      parameterValues.put("queries_path", stringToValue(queriesPath));
      parameterValues.put("corpus_path", stringToValue(corpusPath));
      parameterValues.put("train_label_path", stringToValue(trainLabelPath));
      parameterValues.put("test_label_path", stringToValue(testLabelPath));
      parameterValues.put("batch_size", numberToValue(batchSize));
      parameterValues.put("iterations", numberToValue(iterations));

      RuntimeConfig runtimeConfig =
          RuntimeConfig.newBuilder()
              .setGcsOutputDirectory(outputDir)
              .putAllParameterValues(parameterValues)
              .build();

      PipelineJob pipelineJob =
          PipelineJob.newBuilder()
              .setTemplateUri(
                  "https://us-kfp.pkg.dev/ml-pipeline/llm-text-embedding/tune-text-embedding-model/v1.1.2")
              .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();
  }
}

// [END aiplatform_sdk_embedding_tuning]

Beispiel: cURL-Befehls

PROJECT_ID=PROJECT_ID
LOCATION=LOCATION
BASE_MODEL_VERSION_ID=BASE_MODEL_VERSION_ID
PIPELINE_OUTPUT_DIRECTORY=PIPELINE_OUTPUT_DIRECTORY
QUERIES_PATH=QUERIES_PATH
CORPUS_PATH=CORPUS_PATH
TRAIN_LABEL_PATH=TRAIN_LABEL_PATH

curl -X POST  \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json; charset=utf-8" \
"https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/pipelineJobs?pipelineJobId=tune-text-embedding-$(date +%Y%m%d%H%M%S)" \
-d '{
  "displayName": "tune-text-embedding-model",
  "runtimeConfig": {
    "gcsOutputDirectory": "'${PIPELINE_OUTPUT_DIRECTORY}'",
    "parameterValues": {
      "project":  "'${PROJECT_ID}'",
      "base_model_version_id":  "'${BASE_MODEL_VERSION_ID}'",
      "location":   "'${LOCATION}'",
      "queries_path":  "'${QUERIES_PATH}'",
      "corpus_path":  "'${CORPUS_PATH}'",
      "train_label_path":  "'${TRAIN_LABEL_PATH}'"
    }
  },
  "templateUri": "https://us-kfp.pkg.dev/ml-pipeline/llm-text-embedding/tune-text-embedding-model/v1.1.2"
}'

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 der Google Cloud Console können Sie eine Liste der Modelle in Ihrem aktuellen Projekt, einschließlich der abgestimmten Modelle, aufrufen.

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

Zur Vertex AI Model Registry

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 Vorhersage zu vermeiden, wird empfohlen, den GPU-Typ NVIDIA_TESLA_A100 bereitzustellen. Dieser kann Batchgrößen bis zu 5 für jede Eingabelänge unterstützen.

Ähnlich wie beim textembedding-gecko-Grundlagenmodell unterstützt Ihr abgestimmtes Modell bis zu 3.072 Tokens und kann längere Eingaben kürzen.

Vorhersagen für ein bereitgestelltes Modell abrufen

Nachdem Ihr abgestimmtes Modell bereitgestellt wurde, können Sie mit einem der folgenden Befehle Anfragen an den Endpunkt des feinabgestimmten Modells senden.

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

Verwenden Sie den folgenden curl-Befehl, um Vorhersagen 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

Diese Ausgabe gilt unabhängig von der Version für die Modelle textembedding-gecko und textembedding-gecko-multilingual.

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

Nächste Schritte

• Foundation Model optimieren
• Verantwortungsbewusste Best Practices für KI und die Sicherheitsfilter von Vertex AI