Multimodale Einbettungen abrufen

Das Modell für multimodale Einbettungen generiert 1.408 dimensionale Vektoren basierend auf der von Ihnen bereitgestellten Eingabe, die eine Kombination aus Bild-, Text- und Videodaten enthalten kann. Die Einbettungsvektoren können dann für nachfolgende Aufgaben wie die Bildklassifizierung oder Video-Inhaltsmoderation verwendet werden.

Der Bild- und der Texteinbettungsvektor befinden sich im selben semantischen Bereich mit derselben Dimensionalität. Daher können diese Vektoren austauschbar für Anwendungsfälle wie die Bildsuche nach Text oder die Videosuche nach Bild verwendet werden.

Für Anwendungsfälle mit Nur-Text-Einbettungen empfehlen wir stattdessen die Vertex AI text-embeddings API. Beispielsweise ist die text-embeddings API möglicherweise für textbasierte semantische Suche, Clustering, ausführliche Dokumentanalyse und andere Anwendungsfälle für das Abrufen von Text oder Question Answering besser geeignet. Weitere Informationen finden Sie unter Texteinbettungen abrufen.

* Standardwert.

Anwendungsfälle

Bild und Text:

  • Bildklassifizierung: Nimmt ein Bild als Eingabe und sagt eine oder mehrere Klassen (Labels) vorher.
  • Bildersuche: Nach relevanten oder ähnlichen Bildern suchen.
  • Empfehlungen: Generiert Produkt- oder Anzeigenempfehlungen auf Basis von Bildern.

Bild, Text und Video:

  • Empfehlungen: Produkt- oder Werbeempfehlungen auf Basis von Videos generieren (Ähnlichkeitssuche).
  • Suche nach Videoinhalten
    • Semantische Suche verwenden: Nimmt einen Text als Eingabe und gibt eine Reihe von eingestuften Frames zurück, die mit der Abfrage übereinstimmen.
    • Ähnlichkeitssuche verwenden:
      • Nehmen Sie ein Video als Eingabe und geben Sie eine Reihe von Videos zurück, die der Abfrage entsprechen.
      • Nehmen Sie ein Bild als Eingabe und geben Sie eine Reihe von Videos zurück, die der Abfrage entsprechen.
  • Videoklassifizierung: Nimmt ein Video als Eingabe und sagt eine oder mehrere Klassen vorher.

Unterstützte Modelle

Sie können multimodale Einbettungen mit dem folgenden Modell abrufen:

  • multimodalembedding

Best Practices

Berücksichtigen Sie bei der Verwendung des Modells für multimodale Einbettungen die folgenden Eingabeaspekte:

  • Text in Bildern: Das Modell kann Text in Bildern unterscheiden, ähnlich wie die optische Zeichenerkennung (Optical Character Recognition, OCR). Wenn Sie zwischen einer Beschreibung des Bildinhalts und dem Text in einem Bild unterscheiden müssen, können Sie die Zielinhalte mithilfe von Prompt Engineering angeben. Geben Sie beispielsweise je nach Anwendungsfall statt „Katze“ „Bild einer Katze“ oder „Text ‚Katze‘“ an.




    der Text "Katze"
    Bild von Text mit dem Wort „Katze“




    Bild einer Katze
    Bild einer Katze
    Bildnachweis: Manja Vitolic auf Unsplash
  • Ähnlichkeiten von Einbettungen: Das Skalarprodukt von Einbettungen ist keine kalibrierte Wahrscheinlichkeit. Das Skalarprodukt ist ein Messwert für die Ähnlichkeit und kann unterschiedliche Punktzahlverteilungen für verschiedene Anwendungsfälle haben. Vermeiden Sie daher die Verwendung eines festen Wertschwellenwerts, um die Qualität zu messen. Verwenden Sie stattdessen Ranking-Ansätze zum Abrufen oder Sigmoid zur Klassifizierung.

API-Nutzung

API-Limits

Die folgenden Limits gelten, wenn Sie das Modell multimodalembedding für Text- und Bildeinbettungen verwenden:

Limit Wert und Beschreibung
Text- und Bilddaten
Maximale Anzahl an API-Anfragen pro Minute und Projekt 120
Maximale Textlänge 32 Tokens (ca. 32 Wörter)

Die maximale Textlänge beträgt 32 Tokens (ca. 32 Wörter). Wenn die Eingabe 32 Tokens überschreitet, kürzt das Modell die Eingabe intern auf diese Länge.
Sprache Englisch
Bildformate BMP, GIF, JPG, PNG
Bildgröße Base64-codierte Bilder: 20 MB (bei der Transcodierung in PNG)
Cloud Storage-Bilder: 20 MB (Originaldateiformat)

Die maximal akzeptierte Bildgröße beträgt 20 MB. Verwenden Sie kleinere Bilder, um eine höhere Netzwerklatenz zu vermeiden. Außerdem ändert das Modell Bilder auf die Auflösung 512 x 512 Pixel. Daher müssen Sie keine Bilder mit höherer Auflösung bereitstellen.
Videodaten
Audio-Unterstützung Nicht verfügbar: Das Modell berücksichtigt beim Generieren von Videoeinbettungen keinen Audioinhalt.
Videoformate AVI, FLV, MKV, MOV, MP4, MPEG, MPG, WEBM, und WMV
Maximale Videolänge (Cloud Storage) Kein Limit. Es können jedoch nur zwei Minuten an Inhalt gleichzeitig analysiert werden.

Hinweise

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Make sure that billing is enabled for your Google Cloud project.

  4. Enable the Vertex AI API.

    Enable the API

    5.

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  6. Make sure that billing is enabled for your Google Cloud project.

  7. Enable the Vertex AI API.

    Enable the API

    8.

  8. Richten Sie die Authentifizierung für Ihre Umgebung ein.

    Select the tab for how you plan to use the samples on this page:

    Java

    Wenn Sie die Java Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, installieren und initialisieren Sie die gcloud CLI und richten dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein.

    1. Install the Google Cloud CLI.

    2. To initialize the gcloud CLI, run the following command: 

      gcloud init

    3. Update and install gcloud components:

      gcloud components update
      gcloud components install beta

    4. If you're using a local shell, then create local authentication credentials for your user account: 

      gcloud auth application-default login

      You don't need to do this if you're using Cloud Shell.

    Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten in der Dokumentation zur Google Cloud-Authentifizierung.

    Node.js

    Wenn Sie die Node.js Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, installieren und initialisieren Sie die gcloud CLI und richten dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein.

    1. Install the Google Cloud CLI.

    2. To initialize the gcloud CLI, run the following command: 

      gcloud init

    3. Update and install gcloud components:

      gcloud components update
      gcloud components install beta

    4. If you're using a local shell, then create local authentication credentials for your user account: 

      gcloud auth application-default login

      You don't need to do this if you're using Cloud Shell.

    Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten in der Dokumentation zur Google Cloud-Authentifizierung.

    Python

    Wenn Sie die Python Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, installieren und initialisieren Sie die gcloud CLI und richten dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein.

    1. Install the Google Cloud CLI.

    2. To initialize the gcloud CLI, run the following command: 

      gcloud init

    3. Update and install gcloud components:

      gcloud components update
      gcloud components install beta

    4. If you're using a local shell, then create local authentication credentials for your user account: 

      gcloud auth application-default login

      You don't need to do this if you're using Cloud Shell.

    Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten in der Dokumentation zur Google Cloud-Authentifizierung.

    REST

    Verwenden Sie die von der gcloud CLI bereitgestellten Anmeldedaten, um die REST API-Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung zu verwenden.

    1. Install the Google Cloud CLI.

    2. To initialize the gcloud CLI, run the following command: 

      gcloud init

    3. Update and install gcloud components:

      gcloud components update
      gcloud components install beta

    Weitere Informationen finden Sie unter Für die Verwendung von REST authentifizieren in der Dokumentation zur Google Cloud-Authentifizierung.

  9. Folgen Sie der Anleitung unter Vertex AI SDK für Python installieren, um das Python SDK zu verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI SDK for Python API.
  10. Optional. Preise Die Preise für Einbettungen hängen vom Typ der gesendeten Daten (z. B. Bild oder Text) und vom Modus ab, den Sie für bestimmte Datentypen verwenden (z. B. Video Plus, Video Standard oder Video Essential). “

Standorte

Ein Standort ist eine Region, die Sie in einer Anfrage angeben können, um zu steuern, wo Daten im Ruhezustand gespeichert werden. Eine Liste der verfügbaren Regionen finden Sie unter Generative AI an Vertex AI-Standorten.

Fehlermeldungen

Fehler „Kontingent überschritten“

google.api_core.exceptions.ResourceExhausted: 429 Quota exceeded for
aiplatform.googleapis.com/online_prediction_requests_per_base_model with base
model: multimodalembedding. Please submit a quota increase request.

Wenn Sie diesen Fehler zum ersten Mal erhalten, verwenden Sie die Google Cloud Console, um eine Kontingenterhöhung für Ihr Projekt anzufordern. Verwenden Sie die folgenden Filter, bevor Sie eine Erhöhung anfordern:

  • Service ID: aiplatform.googleapis.com
  • metric: aiplatform.googleapis.com/online_prediction_requests_per_base_model
  • base_model:multimodalembedding

Kontingente aufrufen

Wenn Sie bereits eine Anfrage zur Kontingenterhöhung gesendet haben, warten Sie, bevor Sie eine weitere Anfrage senden. Wenn Sie das Kontingent weiter erhöhen möchten, wiederholen Sie die Kontingenterhöhung mit einer Begründung für eine weitere Kontingentanfrage.

Einbettungen mit niedrigeren Dimensionen angeben

Standardmäßig wird bei einer Einbettungsanfrage für einen Datentyp ein Float-Vektor vom Typ 1408 zurückgegeben. Sie können für Text- und Bilddaten auch Einbettungen mit weniger Dimensionen (128, 256 oder 512 Float-Vektoren) angeben. Mit dieser Option können Sie die Latenz und Speicherung oder Qualität optimieren, basierend darauf, wie Sie die Einbettungen verwenden möchten. Einbettungen mit niedriger Dimension bieten einen geringeren Speicherbedarf und eine geringere Latenz für nachfolgende Einbettungsaufgaben (z. B. Suche oder Empfehlung), während Einbettungen mit höheren Dimensionen eine höhere Genauigkeit für dieselben Aufgaben bieten.

REST

Sie können auf Dimensionen mit niedriger Dimension zugreifen, indem Sie das Feld parameters.dimension hinzufügen. Der Parameter akzeptiert einen der folgenden Werte: 128, 256, 512 oder 1408. Die Antwort enthält die Einbettung dieser Dimension.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • LOCATION: Die Region Ihres Projekts. Beispiel: us-central1, europe-west2 oder asia-northeast3. Eine Liste der verfügbaren Regionen finden Sie unter Generative AI an Vertex AI-Standorten.
  • PROJECT_ID: Ihre Google Cloud-Projekt-ID.
  • IMAGE_URI: Der Cloud Storage-URI des Zielvideos, für das Einbettungen abgerufen werden sollen. Beispiel: gs://my-bucket/embeddings/supermarket-img.png.

    Sie können das Bild auch als Base64-codierten Bytestring bereitstellen:

    [...]
"image": {
  "bytesBase64Encoded": "B64_ENCODED_IMAGE"
}
[...]
  • TEXT: Der Zieltext, für den Einbettungen abgerufen werden sollen. Beispiel: a cat
  • EMBEDDING_DIMENSION: Die Anzahl der Einbettungsdimensionen. Niedrigere Werte bieten eine geringere Latenz bei Verwendung dieser Einbettungen für nachfolgende Aufgaben, während höhere Werte eine höhere Genauigkeit bieten. Verfügbare Werte: 128, 256, 512 und 1408 (Standard).

HTTP-Methode und URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/multimodalembedding@001:predict

JSON-Text der Anfrage:

{
  "instances": [
    {
      "image": {
        "gcsUri": "IMAGE_URI"
      },
      "text": "TEXT"
    }
  ],
  "parameters": {
    "dimension": EMBEDDING_DIMENSION
  }
}

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://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/multimodalembedding@001:predict"

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://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/multimodalembedding@001:predict" | Select-Object -Expand Content
Das Einbettungsmodell gibt einen Gleitkommavektor der von Ihnen angegebenen Dimension zurück. Die folgenden Beispielantworten werden aus Platzgründen gekürzt.

128 Dimensionen:

{
  "predictions": [
    {
      "imageEmbedding": [
        0.0279239565,
        [...128 dimension vector...]
        0.00403284049
      ],
      "textEmbedding": [
        0.202921599,
        [...128 dimension vector...]
        -0.0365431122
      ]
    }
  ],
  "deployedModelId": "DEPLOYED_MODEL_ID"
}

256 Dimensionen:

{
  "predictions": [
    {
      "imageEmbedding": [
        0.248620048,
        [...256 dimension vector...]
        -0.0646447465
      ],
      "textEmbedding": [
        0.0757875815,
        [...256 dimension vector...]
        -0.02749932
      ]
    }
  ],
  "deployedModelId": "DEPLOYED_MODEL_ID"
}

512 Dimensionen:

{
  "predictions": [
    {
      "imageEmbedding": [
        -0.0523675755,
        [...512 dimension vector...]
        -0.0444030389
      ],
      "textEmbedding": [
        -0.0592851527,
        [...512 dimension vector...]
        0.0350437127
      ]
    }
  ],
  "deployedModelId": "DEPLOYED_MODEL_ID"
}

Einbettungsanfrage senden (Bild und Text)

Verwenden Sie die folgenden Codebeispiele, um eine Einbettungsanfrage mit Bild- und Textdaten zu senden. Die Beispiele zeigen, wie Sie eine Anfrage mit beiden Datentypen senden. Sie können den Dienst aber auch mit einem einzelnen Datentyp verwenden.

Text- und Bildeinbettungen abrufen

REST

Weitere Informationen zu multimodalembedding-Modellanfragen finden Sie in der API-Referenz des multimodalembedding-Modells.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • LOCATION: Die Region Ihres Projekts. Beispiel: us-central1, europe-west2 oder asia-northeast3. Eine Liste der verfügbaren Regionen finden Sie unter Generative AI an Vertex AI-Standorten.
  • PROJECT_ID: Ihre Google Cloud-Projekt-ID.
  • TEXT: Der Zieltext, für den Einbettungen abgerufen werden sollen. Beispiel: a cat
  • B64_ENCODED_IMG: Das Zielbild, für das Einbettungen abgerufen werden sollen. Das Bild muss als base64-codierter Bytestring angegeben werden.

HTTP-Methode und URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/multimodalembedding@001:predict

JSON-Text der Anfrage:

{
  "instances": [
    {
      "text": "TEXT",
      "image": {
        "bytesBase64Encoded": "B64_ENCODED_IMG"
      }
    }
  ]
}

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://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/multimodalembedding@001:predict"

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://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/multimodalembedding@001:predict" | Select-Object -Expand Content
Die Einbettung des Modells ist ein Float-Vektor vom Typ 1408. Die folgende Beispielantwort wurde aus Platzgründen gekürzt. 
{
  "predictions": [
    {
      "textEmbedding": [
        0.010477379,
        -0.00399621,
        0.00576670747,
        [...]
        -0.00823613815,
        -0.0169572588,
        -0.00472954148
      ],
      "imageEmbedding": [
        0.00262696808,
        -0.00198890246,
        0.0152047109,
        -0.0103145819,
        [...]
        0.0324628279,
        0.0284924973,
        0.011650892,
        -0.00452344026
      ]
    }
  ],
  "deployedModelId": "DEPLOYED_MODEL_ID"
}

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 typing import Optional

import vertexai
from vertexai.vision_models import (
    Image,
    MultiModalEmbeddingModel,
    MultiModalEmbeddingResponse,
)

def get_image_embeddings(
    project_id: str,
    location: str,
    image_path: str,
    contextual_text: Optional[str] = None,
) -> MultiModalEmbeddingResponse:
    """Example of how to generate multimodal embeddings from image and text.

    Args:
        project_id: Google Cloud Project ID, used to initialize vertexai
        location: Google Cloud Region, used to initialize vertexai
        image_path: Path to image (local or Google Cloud Storage) to generate embeddings for.
        contextual_text: Text to generate embeddings for.
    """

    vertexai.init(project=project_id, location=location)

    model = MultiModalEmbeddingModel.from_pretrained("multimodalembedding")
    image = Image.load_from_file(image_path)

    embeddings = model.get_embeddings(
        image=image,
        contextual_text=contextual_text,
    )
    print(f"Image Embedding: {embeddings.image_embedding}")
    print(f"Text Embedding: {embeddings.text_embedding}")

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 bastImagePath = "YOUR_BASED_IMAGE_PATH"
// const textPrompt = 'YOUR_TEXT_PROMPT';
const aiplatform = require('@google-cloud/aiplatform');

// Imports the Google Cloud Prediction service client
const {PredictionServiceClient} = 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: 'us-central1-aiplatform.googleapis.com',
};
const publisher = 'google';
const model = 'multimodalembedding@001';

// Instantiates a client
const predictionServiceClient = new PredictionServiceClient(clientOptions);

async function predictImageFromImageAndText() {
  // Configure the parent resource
  const endpoint = `projects/${project}/locations/${location}/publishers/${publisher}/models/${model}`;

  const fs = require('fs');
  const imageFile = fs.readFileSync(baseImagePath);

  // Convert the image data to a Buffer and base64 encode it.
  const encodedImage = Buffer.from(imageFile).toString('base64');

  const prompt = {
    text: textPrompt,
    image: {
      bytesBase64Encoded: encodedImage,
    },
  };
  const instanceValue = helpers.toValue(prompt);
  const instances = [instanceValue];

  const parameter = {
    sampleCount: 1,
  };
  const parameters = helpers.toValue(parameter);

  const request = {
    endpoint,
    instances,
    parameters,
  };

  // Predict request
  const [response] = await predictionServiceClient.predict(request);
  console.log('Get image embedding response');
  const predictions = response.predictions;
  console.log('\tPredictions :');
  for (const prediction of predictions) {
    console.log(`\t\tPrediction : ${JSON.stringify(prediction)}`);
  }
}

await predictImageFromImageAndText();

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.v1beta1.EndpointName;
import com.google.cloud.aiplatform.v1beta1.PredictResponse;
import com.google.cloud.aiplatform.v1beta1.PredictionServiceClient;
import com.google.cloud.aiplatform.v1beta1.PredictionServiceSettings;
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import com.google.protobuf.InvalidProtocolBufferException;
import com.google.protobuf.Value;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Base64;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class PredictImageFromImageAndTextSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace this variable before running the sample.
    String project = "YOUR_PROJECT_ID";
    String textPrompt = "YOUR_TEXT_PROMPT";
    String baseImagePath = "YOUR_BASE_IMAGE_PATH";

    // Learn how to use text prompts to update an image:
    // https://cloud.google.com/vertex-ai/docs/generative-ai/image/edit-images
    Map<String, Object> parameters = new HashMap<String, Object>();
    parameters.put("sampleCount", 1);

    String location = "us-central1";
    String publisher = "google";
    String model = "multimodalembedding@001";

    predictImageFromImageAndText(
        project, location, publisher, model, textPrompt, baseImagePath, parameters);
  }

  // Update images using text prompts
  public static void predictImageFromImageAndText(
      String project,
      String location,
      String publisher,
      String model,
      String textPrompt,
      String baseImagePath,
      Map<String, Object> parameters)
      throws IOException {
    final String endpoint = String.format("%s-aiplatform.googleapis.com:443", location);
    final PredictionServiceSettings predictionServiceSettings =
        PredictionServiceSettings.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 (PredictionServiceClient predictionServiceClient =
        PredictionServiceClient.create(predictionServiceSettings)) {
      final EndpointName endpointName =
          EndpointName.ofProjectLocationPublisherModelName(project, location, publisher, model);

      // Convert the image to Base64
      byte[] imageData = Base64.getEncoder().encode(Files.readAllBytes(Paths.get(baseImagePath)));
      String encodedImage = new String(imageData, StandardCharsets.UTF_8);

      JsonObject jsonInstance = new JsonObject();
      jsonInstance.addProperty("text", textPrompt);
      JsonObject jsonImage = new JsonObject();
      jsonImage.addProperty("bytesBase64Encoded", encodedImage);
      jsonInstance.add("image", jsonImage);

      Value instanceValue = stringToValue(jsonInstance.toString());
      List<Value> instances = new ArrayList<>();
      instances.add(instanceValue);

      Gson gson = new Gson();
      String gsonString = gson.toJson(parameters);
      Value parameterValue = stringToValue(gsonString);

      PredictResponse predictResponse =
          predictionServiceClient.predict(endpointName, instances, parameterValue);
      System.out.println("Predict Response");
      System.out.println(predictResponse);
      for (Value prediction : predictResponse.getPredictionsList()) {
        System.out.format("\tPrediction: %s\n", prediction);
      }
    }
  }

  // Convert a Json string to a protobuf.Value
  static Value stringToValue(String value) throws InvalidProtocolBufferException {
    Value.Builder builder = Value.newBuilder();
    JsonFormat.parser().merge(value, builder);
    return builder.build();
  }
}

Einbettungsanfrage senden (Video, Bild oder Text)

Wenn Sie eine Einbettungsanfrage senden, können Sie nur ein Eingabevideo oder eine Kombination aus Video-, Bild- und Textdaten angeben.

Videoeinbettungsmodi

Sie können für Videoeinbettungen drei Modi verwenden: Essential, Standard oder Plus. Der Modus entspricht der Dichte der generierten Einbettungen, die durch die interval_sec-Konfiguration in der Anfrage angegeben werden kann. Für jedes Videointervall mit der Länge interval_sec wird eine Einbettung erstellt. Das Videointervall beträgt mindestens 4 Sekunden. Intervalllängen von mehr als 120 Sekunden können sich negativ auf die Qualität der generierten Einbettungen auswirken.

Die Preise für die Videoeinbettung hängen vom verwendeten Modus ab. Weitere Informationen finden Sie unter Preise.

In der folgenden Tabelle finden Sie eine Übersicht über die drei Modi, die Sie für die Videoeinbettung verwenden können:

Modus Maximale Anzahl an Einbettungen pro Minute Videoeinbettungsintervall (Mindestwert)
Unverzichtbar 4 15

Dies entspricht: intervalSec >= 15
Standard 8 8

Dies entspricht: 8 <= intervalSec < 15
Plus 15 4

Dies entspricht: 4 <= intervalSec < 8

Best Practices für Videoeinbettungen

Beachten Sie beim Senden von Anfragen zur Videoeinbettung Folgendes:

  • Mit der folgenden videoSegmentConfig-Einstellung können Sie eine einzelne Einbettung für die ersten zwei Minuten eines Eingabevideos einer beliebigen Länge erstellen:

    request.json:

    // other request body content
"videoSegmentConfig": {
  "intervalSec": 120
}
// other request body content

  • Wenn Sie eine Einbettung für ein Video mit einer Länge von mehr als zwei Minuten generieren möchten, können Sie mehrere Anfragen senden, die die Start- und Endzeiten in videoSegmentConfig angeben:

    request1.json:

    // other request body content
"videoSegmentConfig": {
  "startOffsetSec": 0,
  "endOffsetSec": 120
}
// other request body content

    request2.json:

    // other request body content
"videoSegmentConfig": {
  "startOffsetSec": 120,
  "endOffsetSec": 240
}
// other request body content

Videoeinbettungen abrufen

Im folgenden Beispiel werden Einbettungen nur für Videoinhalte verwendet.

REST

Weitere Informationen zu multimodalembedding-Modellanfragen finden Sie in der API-Referenz des multimodalembedding-Modells.

Im folgenden Beispiel wird ein Video in Cloud Storage verwendet. Sie können auch das Feld video.bytesBase64Encoded verwenden, um eine base64-codierte Stringdarstellung des Videos bereitzustellen.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • LOCATION: Die Region Ihres Projekts. Beispiel: us-central1, europe-west2 oder asia-northeast3. Eine Liste der verfügbaren Regionen finden Sie unter Generative AI an Vertex AI-Standorten.
  • PROJECT_ID: Ihre Google Cloud-Projekt-ID.
  • VIDEO_URI: Der Cloud Storage-URI des Zielvideos, für das Einbettungen abgerufen werden sollen. Beispiel: gs://my-bucket/embeddings/supermarket-video.mp4.

    Sie können das Video auch als Base64-codierten Bytestring bereitstellen:

    [...]
"video": {
  "bytesBase64Encoded": "B64_ENCODED_VIDEO"
}
[...]
  • videoSegmentConfig (START_SECOND, END_SECOND, INTERVAL_SECONDS). Optional. Die spezifischen Videosegmente (in Sekunden), für die die Einbettungen generiert werden.

    Beispiel:

    [...]
"videoSegmentConfig": {
  "startOffsetSec": 10,
  "endOffsetSec": 60,
  "intervalSec": 10
}
[...]

    Mit dieser Konfiguration werden Videodaten von 10 bis 60 Sekunden angegeben und Einbettungen für die folgenden 10-Sekunden-Videointervalle generiert: [10, 20), [20, 30), [30, 40), [40, 50), [50, 60). Dieses Videointervall ("intervalSec": 10) fällt in den Standardmodus zum Einbetten von Videos und dem Nutzer wird der Standardpreis für den Standardmodus in Rechnung gestellt.

    Wenn Sie videoSegmentConfig weglassen, verwendet der Dienst die folgenden Standardwerte: "videoSegmentConfig": { "startOffsetSec": 0, "endOffsetSec": 120, "intervalSec": 16 }. Dieses Videointervall ("intervalSec": 16) fällt in den Einbettungsmodus für wichtige Videos und dem Nutzer wird der Preis für den wichtigen Modus in Rechnung gestellt.

HTTP-Methode und URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/multimodalembedding@001:predict

JSON-Text der Anfrage:

{
  "instances": [
    {
      "video": {
        "gcsUri": "VIDEO_URI",
        "videoSegmentConfig": {
          "startOffsetSec": START_SECOND,
          "endOffsetSec": END_SECOND,
          "intervalSec": INTERVAL_SECONDS
        }
      }
    }
  ]
}

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://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/multimodalembedding@001:predict"

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://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/multimodalembedding@001:predict" | Select-Object -Expand Content
Die Einbettung, die das Modell zurückgibt, ist ein Float-Vektor vom Typ 1408. Die folgenden Beispielantworten werden aus Platzgründen gekürzt.

Antwort (7-Sekunden-Video, kein videoSegmentConfig angegeben):

{
  "predictions": [
    {
      "videoEmbeddings": [
        {
          "endOffsetSec": 7,
          "embedding": [
            -0.0045467657,
            0.0258095954,
            0.0146885719,
            0.00945400633,
            [...]
            -0.0023291884,
            -0.00493789,
            0.00975185353,
            0.0168156829
          ],
          "startOffsetSec": 0
        }
      ]
    }
  ],
  "deployedModelId": "DEPLOYED_MODEL_ID"
}

Antwort (59-Sekunden-Video mit der folgenden Videosegmentkonfiguration: "videoSegmentConfig": { "startOffsetSec": 0, "endOffsetSec": 60, "intervalSec": 10 }):

{
  "predictions": [
    {
      "videoEmbeddings": [
        {
          "endOffsetSec": 10,
          "startOffsetSec": 0,
          "embedding": [
            -0.00683252793,
            0.0390476175,
            [...]
            0.00657121744,
            0.013023301
          ]
        },
        {
          "startOffsetSec": 10,
          "endOffsetSec": 20,
          "embedding": [
            -0.0104404651,
            0.0357737206,
            [...]
            0.00509833824,
            0.0131902946
          ]
        },
        {
          "startOffsetSec": 20,
          "embedding": [
            -0.0113538112,
            0.0305239167,
            [...]
            -0.00195809244,
            0.00941874553
          ],
          "endOffsetSec": 30
        },
        {
          "embedding": [
            -0.00299320649,
            0.0322436653,
            [...]
            -0.00993082579,
            0.00968887936
          ],
          "startOffsetSec": 30,
          "endOffsetSec": 40
        },
        {
          "endOffsetSec": 50,
          "startOffsetSec": 40,
          "embedding": [
            -0.00591270532,
            0.0368893594,
            [...]
            -0.00219071587,
            0.0042470959
          ]
        },
        {
          "embedding": [
            -0.00458270218,
            0.0368121453,
            [...]
            -0.00317760976,
            0.00595594104
          ],
          "endOffsetSec": 59,
          "startOffsetSec": 50
        }
      ]
    }
  ],
  "deployedModelId": "DEPLOYED_MODEL_ID"
}

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 typing import Optional

import vertexai
from vertexai.vision_models import (
    MultiModalEmbeddingModel,
    MultiModalEmbeddingResponse,
    Video,
    VideoSegmentConfig,
)

def get_video_embeddings(
    project_id: str,
    location: str,
    video_path: str,
    contextual_text: Optional[str] = None,
    dimension: Optional[int] = 1408,
    video_segment_config: Optional[VideoSegmentConfig] = None,
) -> MultiModalEmbeddingResponse:
    """Example of how to generate multimodal embeddings from video and text.

    Args:
        project_id: Google Cloud Project ID, used to initialize vertexai
        location: Google Cloud Region, used to initialize vertexai
        video_path: Path to video (local or Google Cloud Storage) to generate embeddings for.
        contextual_text: Text to generate embeddings for.
        dimension: Dimension for the returned embeddings.
            https://cloud.google.com/vertex-ai/docs/generative-ai/embeddings/get-multimodal-embeddings#low-dimension
        video_segment_config: Define specific segments to generate embeddings for.
            https://cloud.google.com/vertex-ai/docs/generative-ai/embeddings/get-multimodal-embeddings#video-best-practices
    """

    vertexai.init(project=project_id, location=location)

    model = MultiModalEmbeddingModel.from_pretrained("multimodalembedding")
    video = Video.load_from_file(video_path)

    embeddings = model.get_embeddings(
        video=video,
        video_segment_config=video_segment_config,
        contextual_text=contextual_text,
        dimension=dimension,
    )

    # Video Embeddings are segmented based on the video_segment_config.
    print("Video Embeddings:")
    for video_embedding in embeddings.video_embeddings:
        print(
            f"Video Segment: {video_embedding.start_offset_sec} - {video_embedding.end_offset_sec}"
        )
        print(f"Embedding: {video_embedding.embedding}")

    print(f"Text Embedding: {embeddings.text_embedding}")

Bild-, Text- und Videoeinbettungen abrufen

Im folgenden Beispiel werden Einbettungen für Video-, Text- und Bildinhalte abgerufen.

REST

Weitere Informationen zu multimodalembedding-Modellanfragen finden Sie in der API-Referenz des multimodalembedding-Modells.

Im folgenden Beispiel werden Bild-, Text- und Videodaten verwendet. Sie können eine beliebige Kombination dieser Datentypen im Anfragetext verwenden.

Außerdem wird in diesem Beispiel ein Video in Cloud Storage verwendet. Sie können auch das Feld video.bytesBase64Encoded verwenden, um eine base64-codierte Stringdarstellung des Videos bereitzustellen.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • LOCATION: Die Region Ihres Projekts. Beispiel: us-central1, europe-west2 oder asia-northeast3. Eine Liste der verfügbaren Regionen finden Sie unter Generative AI an Vertex AI-Standorten.
  • PROJECT_ID: Ihre Google Cloud-Projekt-ID.
  • TEXT: Der Zieltext, für den Einbettungen abgerufen werden sollen. Beispiel: a cat
  • IMAGE_URI: Der Cloud Storage-URI des Zielvideos, für das Einbettungen abgerufen werden sollen. Beispiel: gs://my-bucket/embeddings/supermarket-img.png.

    Sie können das Bild auch als Base64-codierten Bytestring bereitstellen:

    [...]
"image": {
  "bytesBase64Encoded": "B64_ENCODED_IMAGE"
}
[...]
  • VIDEO_URI: Der Cloud Storage-URI des Zielvideos, für das Einbettungen abgerufen werden sollen. Beispiel: gs://my-bucket/embeddings/supermarket-video.mp4.

    Sie können das Video auch als Base64-codierten Bytestring bereitstellen:

    [...]
"video": {
  "bytesBase64Encoded": "B64_ENCODED_VIDEO"
}
[...]
  • videoSegmentConfig (START_SECOND, END_SECOND, INTERVAL_SECONDS). Optional. Die spezifischen Videosegmente (in Sekunden), für die die Einbettungen generiert werden.

    Beispiel:

    [...]
"videoSegmentConfig": {
  "startOffsetSec": 10,
  "endOffsetSec": 60,
  "intervalSec": 10
}
[...]

    Mit dieser Konfiguration werden Videodaten von 10 bis 60 Sekunden angegeben und Einbettungen für die folgenden 10-Sekunden-Videointervalle generiert: [10, 20), [20, 30), [30, 40), [40, 50), [50, 60). Dieses Videointervall ("intervalSec": 10) fällt in den Standardmodus zum Einbetten von Videos und dem Nutzer wird der Standardpreis für den Standardmodus in Rechnung gestellt.

    Wenn Sie videoSegmentConfig weglassen, verwendet der Dienst die folgenden Standardwerte: "videoSegmentConfig": { "startOffsetSec": 0, "endOffsetSec": 120, "intervalSec": 16 }. Dieses Videointervall ("intervalSec": 16) fällt in den Einbettungsmodus für wichtige Videos und dem Nutzer wird der Preis für den wichtigen Modus in Rechnung gestellt.

HTTP-Methode und URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/multimodalembedding@001:predict

JSON-Text der Anfrage:

{
  "instances": [
    {
      "text": "TEXT",
      "image": {
        "gcsUri": "IMAGE_URI"
      },
      "video": {
        "gcsUri": "VIDEO_URI",
        "videoSegmentConfig": {
          "startOffsetSec": START_SECOND,
          "endOffsetSec": END_SECOND,
          "intervalSec": INTERVAL_SECONDS
        }
      }
    }
  ]
}

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://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/multimodalembedding@001:predict"

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://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/multimodalembedding@001:predict" | Select-Object -Expand Content
Die Einbettung des Modells ist ein Float-Vektor vom Typ 1408. Die folgende Beispielantwort wurde aus Platzgründen gekürzt. 
{
  "predictions": [
    {
      "textEmbedding": [
        0.0105433334,
        -0.00302835181,
        0.00656806398,
        0.00603460241,
        [...]
        0.00445805816,
        0.0139605571,
        -0.00170318608,
        -0.00490092579
      ],
      "videoEmbeddings": [
        {
          "startOffsetSec": 0,
          "endOffsetSec": 7,
          "embedding": [
            -0.00673126569,
            0.0248149596,
            0.0128901172,
            0.0107588246,
            [...]
            -0.00180952181,
            -0.0054573305,
            0.0117037306,
            0.0169312079
          ]
        }
      ],
      "imageEmbedding": [
        -0.00728622358,
        0.031021487,
        -0.00206603738,
        0.0273937676,
        [...]
        -0.00204976718,
        0.00321615417,
        0.0121978866,
        0.0193375275
      ]
    }
  ],
  "deployedModelId": "DEPLOYED_MODEL_ID"
}

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 typing import Optional

import vertexai
from vertexai.vision_models import (
    Image,
    MultiModalEmbeddingModel,
    MultiModalEmbeddingResponse,
    Video,
    VideoSegmentConfig,
)

def get_image_video_text_embeddings(
    project_id: str,
    location: str,
    image_path: str,
    video_path: str,
    contextual_text: Optional[str] = None,
    dimension: Optional[int] = 1408,
    video_segment_config: Optional[VideoSegmentConfig] = None,
) -> MultiModalEmbeddingResponse:
    """Example of how to generate multimodal embeddings from image, video, and text.

    Args:
        project_id: Google Cloud Project ID, used to initialize vertexai
        location: Google Cloud Region, used to initialize vertexai
        image_path: Path to image (local or Google Cloud Storage) to generate embeddings for.
        video_path: Path to video (local or Google Cloud Storage) to generate embeddings for.
        contextual_text: Text to generate embeddings for.
        dimension: Dimension for the returned embeddings.
            https://cloud.google.com/vertex-ai/docs/generative-ai/embeddings/get-multimodal-embeddings#low-dimension
        video_segment_config: Define specific segments to generate embeddings for.
            https://cloud.google.com/vertex-ai/docs/generative-ai/embeddings/get-multimodal-embeddings#video-best-practices
    """

    vertexai.init(project=project_id, location=location)

    model = MultiModalEmbeddingModel.from_pretrained("multimodalembedding")
    image = Image.load_from_file(image_path)
    video = Video.load_from_file(video_path)

    embeddings = model.get_embeddings(
        image=image,
        video=video,
        video_segment_config=video_segment_config,
        contextual_text=contextual_text,
        dimension=dimension,
    )

    print(f"Image Embedding: {embeddings.image_embedding}")

    # Video Embeddings are segmented based on the video_segment_config.
    print("Video Embeddings:")
    for video_embedding in embeddings.video_embeddings:
        print(
            f"Video Segment: {video_embedding.start_offset_sec} - {video_embedding.end_offset_sec}"
        )
        print(f"Embedding: {video_embedding.embedding}")

    print(f"Text Embedding: {embeddings.text_embedding}")

Nächste Schritte