Testen Sie Gemini 1.5-Modelle, unsere neuesten multimodalen Modelle in Vertex AI, und erfahren Sie, was Sie mit einem 1 Mio. Tokenkontextfenster erstellen können. Tesen Sie Gemini 1.5-Modelle, unsere neuesten multimodalen Modelle in Vertex AI, und erfahren Sie, was Sie mit einem 1 Mio. Tokenkontextfenster erstellen können.

Multimodale Einbettungen

Durch das Einbettungsmodell für multimodale Modelle (multimodalembedding) werden Dimensionsvektoren (128, 256, 512 oder 1408 Dimensionen) basierend auf der von Ihnen bereitgestellten Eingabe generiert. Diese Eingabe kann eine beliebige Kombination aus Text, Bild oder Video enthalten. Die Einbettungsvektoren können dann für andere nachfolgende Aufgaben wie die Bildklassifizierung oder Inhaltsmoderation verwendet werden.

Die Einbettungsvektoren für Text, Bilder und Videos 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.

Anwendungsfälle

Typische Anwendungsfälle für multimodale Einbettungen:

Bild- oder Videoklassifizierung: Nimmt ein Bild oder Video als Eingabe und sagt eine oder mehrere Klassen (Labels) vorher.
Bildersuche: Nach relevanten oder ähnlichen Bildern suchen.
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.
Empfehlungen: Generiert Produkt- oder Werbeempfehlungen auf Basis von Bildern oder Videos (Ähnlichkeitssuche).

Weitere Informationen zu diesem Modell finden Sie in der Console auf der Modellkarte Einbettungen für multimodal im Model Garden.

<a{: class="button button-primary" l10n-attrs-original-order="href,target,class,track-name,track-type" l10n-encrypted-href="SAHUNDUxy6reWq97H1UtVltigmNHgUGOXn/QVSGplOi71dheYhG9dKuv3S+0ajmQkfzB9oP/Mo2x7xIe1klR5WMcFGqgYIW2vdvnDTxO1+88jFCqaIV0kUsj2YehOF0AqvP4zdF86Pqj1NbCoHpRoQ==" target="console" track-name="consoleLink" track-type="tasks" }="">Go to the Model Garden</a{:>

HTTP-Anfrage

POST https://us-central1-aiplatform.googleapis.com/v1/projects/${PROJECT}/locations/us-central1/publishers/google/models/multimodalembedding:predict

Anfragetext

{
  "instances": [
    {
      "text": string,
      "image": {
        // Union field can be only one of the following:
        "bytesBase64Encoded": string,
        "gcsUri": string,
        // End of list of possible types for union field.
        "mimeType": string
      },
      "video": {
        // Union field can be only one of the following:
        "bytesBase64Encoded": string,
        "gcsUri": string,
        // End of list of possible types for union field.
        "videoSegmentConfig": {
          "startOffsetSec": integer,
          "endOffsetSec": integer,
          "intervalSec": integer
        }
      },
      "parameters": {
        "dimension": integer
      }
    }
  ]
}

Verwenden Sie folgende Parameter für das multimodale Generierungsmodell multimodal embeddings. Weitere Informationen finden Sie unter Multimodale Einbettungen abrufen.

Parameter	Beschreibung	Zulässige Werte
`instances`	Ein Array, das das Objekt mit Daten (Text, Bild und Video) enthält, zu denen Informationen abgerufen werden sollen.	Array (1 Objekt zulässig)
`text`	Der Eingabetext, für den Sie eine Einbettung erstellen möchten.	String (max. 32 Tokens)
`image.bytesBase64Encoded`	Das Bild, für das Einbettungen abgerufen werden sollen. Wenn Sie `image.bytesBase64Encoded` angeben, können Sie `image.gcsUri` nicht festlegen.	Base64-codierter Bildstring (BMP-, GIF-, JPG- oder PNG-Datei, maximal 20 MB)
`image.gcsUri`	Der Cloud Storage-URI des Bildes, für das Einbettungen abgerufen werden sollen. Wenn Sie `image.gcsUri` angeben, können Sie `image.bytesBase64Encoded` nicht festlegen.	String-URI der Bilddatei in Cloud Storage (BMP-, GIF-, JPG- oder PNG-Datei, maximal 20 MB)
`image.mimeType`	Optional. Der MIME-Typ des angegebenen Bilds.	String (`image/bmp`, `image/gif`, `image/jpeg`, oder `image/png`)
`video.bytesBase64Encoded`	Das Video, für das Einbettungen abgerufen werden sollen. Wenn Sie `video.bytesBase64Encoded` angeben, können Sie `video.gcsUri` nicht festlegen.	Base64-codierter Videostring (AVI, FLV, MKV, MOV, MP4, MPEG, MPG, WEBM oder WMV-Datei)
`video.gcsUri`	Der Cloud Storage-URI des Videos, für das Einbettungen abgerufen werden sollen. Wenn Sie `video.gcsUri` angeben, können Sie `video.bytesBase64Encoded` nicht festlegen.	String-URI der Videodatei in Cloud Storage (AVI, FLV, MKV, MOV, MP4, MPEG, MPG, WEBM oder WMV-Datei)
`videoSegmentConfig.startOffsetSec`	Optional. Die Zeit (in Sekunden), zu der das Modell mit der Einbettungserkennung beginnt. Standardwert: 0	integer
`videoSegmentConfig.endOffsetSec`	Optional. Die Zeit (in Sekunden), zu der das Modell die Einbettungserkennung beendet. Standard: 120	integer
`videoSegmentConfig.intervalSec`	Optional. Die Zeit (in Sekunden) von Videodatensegmenten, für die Einbettungen generiert werden. Dieser Wert entspricht dem Einbettungsmodus für Videos (Essential, Standard oder Plus), der sich auf die Funktion pricing auswirkt “ Essentials-Modus (`intervalSec` >= 15): Die wenigsten Videosegmente, für die Einbettungen generiert werden. Die niedrigste Kostenoption. Standardstufe (8 <= `intervalSec` < 15): Für diese Videosegmente werden mehr Videosegmente erstellt als im Modus „Essential“, aber weniger als im Plus-Modus. Zwischenkostenoption. Plus-Modus (4 <= `intervalSec` < 8): Die meisten Segmente des Videos, für die Einbettungen generiert werden. Die höchste Kostenoption. Standardeinstellung: 16 (Essential Modus)	Ganzzahl (Mindestwert: 4)
`parameters.dimension`	Optional. Die Vektordimension, für die Einbettungen generiert werden sollen (nur Text oder Bild). Wenn nicht festgelegt, wird der Standardwert 1408 verwendet.	Ganzzahl (`128`, `256`, `512` oder `1408` [Standard])

Beispielanfrage

REST

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.
Der für videoSegmentConfig.intervalSec festgelegte Wert wirkt sich auf die Preisstufe aus, die Ihnen in Rechnung gestellt wird. Weitere Informationen finden Sie im Abschnitt Videoeinbettungsmodi und auf der Seite pricing.

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

Hinweis: Der folgende Befehl setzt voraus, dass Sie sich mit Ihrem Nutzerkonto in der gcloud CLI angemeldet haben. Dazu haben Sie gcloud init oder gcloud auth login ausgeführt oder die Cloud Shell genutzt, die Sie automatisch in der gcloud CLI anmeldet. Um herauszufinden, welches Konto gerade aktiv ist, führen Sie gcloud auth list aus.

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 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 zum Installieren oder Aktualisieren von Python finden Sie unter Vertex AI SDK für 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}")

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();
  }
}

Antworttext

{
  "predictions": [
    {
      "textEmbedding": [
        float,
        // array of 128, 256, 512, or 1408 float values
        float
      ],
      "imageEmbedding": [
        float,
        // array of 128, 256, 512, or 1408 float values
        float
      ],
      "videoEmbeddings": [
        {
          "startOffsetSec": integer,
          "endOffsetSec": integer,
          "embedding": [
            float,
            // array of 1408 float values
            float
          ]
        }
      ]
    }
  ],
  "deployedModelId": string
}

Antwortelement	Beschreibung
`imageEmbedding`	Liste mit 128-, 256-, 512- oder 1408-Gleitkommazahlen.
`textEmbedding`	Liste mit 128-, 256-, 512- oder 1408-Gleitkommazahlen.
`videoEmbeddings`	Liste mit 1.408-Gleitkommazahlen mit der Start- und Endzeit (in Sekunden) des Videosegments, für das die Einbettungen generiert werden.