Représentations vectorielles continues multimodales

Le modèle de représentations vectorielles continues multimodales (multimodalembedding) génère des vecteurs à dimensions (128, 256, 512 ou 1 408 dimensions) en fonction de l'entrée que vous fournissez. Cette entrée peut inclure n'importe quelle combinaison de texte, d'image ou de vidéo. Les vecteurs de représentations vectorielles continues peuvent ensuite être utilisés pour d'autres tâches ultérieures, telles que la classification d'images ou la modération de contenu.

Les vecteurs de représentations vectorielles continues de texte, d'images et de vidéos se trouvent dans le même espace sémantique avec la même dimensionnalité. Par conséquent, ces vecteurs peuvent être utilisés de manière interchangeable pour les cas d'utilisation comme la recherche d'image par texte ou la recherche de vidéo par image.

Cas d'utilisation

Voici quelques cas d'utilisation courants de représentations vectorielles continues multimodales :

  • Classification d'images ou de vidéos : prend une image ou une vidéo en entrée et prédit une ou plusieurs classes (étiquettes).
  • Recherche d'images : recherche des images pertinentes ou similaires.
  • Recherche de contenu vidéo
    • Utilisation de la recherche sémantique : part d'un texte en entrée et renvoie un ensemble d'images classées correspondant à la requête.
    • Utilisation de la recherche de similarités :
      • part d'une vidéo en entrée et renvoie un ensemble de vidéos correspondant à la requête.
      • Part d'une image en entrée et renvoie un ensemble de vidéos correspondant à la requête.
  • Recommandations : génère des recommandations de produits ou d'annonces à partir d'images ou de vidéos (recherche de similarités).

Pour explorer ce modèle dans la console, consultez la fiche de modèle Représentations vectorielles continues multimodales dans 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" }="">Accéder à Model Garden</a{:>

Requête HTTP

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

Corps de la requête

{
  "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
      }
    }
  ]
}

Utilisez les paramètres suivants pour le modèle de génération multimodal multimodal embeddings. Pour en savoir plus, consultez la page Obtenir des représentations vectorielles continues multimodales.

Paramètre Description Valeurs acceptables
instances Tableau contenant l'objet avec des données (texte, image et vidéo) pour lequel vous souhaitez obtenir des informations. Tableau (1 objet autorisé)
text Texte d'entrée pour lequel vous souhaitez créer une représentation vectorielle continue. Chaîne (32 jetons au maximum)
image.bytesBase64Encoded Image pour laquelle vous souhaitez obtenir des représentations vectorielles continues. Si vous spécifiez image.bytesBase64Encoded, vous ne pouvez pas définir image.gcsUri. Chaîne d'image encodée en base64 (fichier BGP, GIF, JPG ou PNG, 20 Mo au maximum)
image.gcsUri URI Cloud Storage de l'image pour laquelle vous souhaitez obtenir des représentations vectorielles continues. Si vous spécifiez image.gcsUri, vous ne pouvez pas définir image.bytesBase64Encoded. URI de chaîne du fichier image dans Cloud Storage (fichier BGP, GIF, JPG ou PNG, 20 Mo au maximum)
image.mimeType Facultatif. Type MIME de l'image que vous spécifiez. Chaîne (image/bmp, image/gif, image/jpeg ou image/png)
video.bytesBase64Encoded Vidéo pour laquelle vous souhaitez obtenir des représentations vectorielles continues. Si vous spécifiez video.bytesBase64Encoded, vous ne pouvez pas définir video.gcsUri. Chaîne de la vidéo encodée en base64 (AVI, FLV, MKV, MOV, MP4, MPEG, MPG, WEBM ou WMV)
video.gcsUri URI Cloud Storage de la vidéo pour laquelle vous souhaitez obtenir des représentations vectorielles continues. Si vous spécifiez video.gcsUri, vous ne pouvez pas définir video.bytesBase64Encoded. URI de chaîne du fichier vidéo dans Cloud Storage (AVI, FLV, MKV, MOV, MP4, MPEG, MPG, WEBM ou WMV)
videoSegmentConfig.startOffsetSec Facultatif. Moment (en secondes) à partir duquel le modèle commence la détection des représentations vectorielles continues. Valeur par défaut : 0 entier
videoSegmentConfig.endOffsetSec Facultatif. Moment (en secondes) jusqu'auquel le modèle effectue la détection des représentations vectorielles continues. Par défaut : 120 entier
videoSegmentConfig.intervalSec Facultatif. Durée (en secondes) des segments de données vidéo pour lesquels les représentations vectorielles continues sont générées. Cette valeur correspond au mode de représentation vectorielle continue de vidéo (Essentiel, Standard ou Plus) qui affecte le tarif de la fonctionnalité.

Mode Essentiel (intervalSec >= 15) : des représentations vectorielles continues sont générées pour moins de séquences vidéo. Option la plus économique.
Niveau Standard (8 <= intervalSec < 15) : des représentations vectorielles continues sont générées pour davantage de séquences vidéo que le mode Essentiel, mais moins que le mode Plus. Option de coût intermédiaire.
Mode Plus (4 <= intervalSec < 8) : des représentations vectorielles continues sont générées pour la plupart des séquences vidéo. Option la plus coûteuse.

Par défaut : 16 (mode Essentiel)		 Entier (valeur minimale : 4)
parameters.dimension Facultatif. Dimension vectorielle pour laquelle générer des représentations vectorielles continues (texte ou image uniquement). Si non défini, la valeur par défaut de 1 408 est utilisée. Entier (128, 256, 512 ou 1408 [par défaut])

Exemple de requête

REST

L'exemple ci-dessous utilise des données de type image, texte et vidéo. Vous pouvez utiliser n'importe quelle combinaison de ces types de données dans le corps de votre requête.

En outre, cet exemple utilise une vidéo située dans Cloud Storage. Vous pouvez également utiliser le champ video.bytesBase64Encoded pour fournir une représentation de la vidéo sous forme de chaîne encodée en base64.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • LOCATION : région de votre projet. Par exemple, us-central1, europe-west2 ou asia-northeast3. Pour obtenir la liste des régions disponibles, consultez la section Emplacements IA générative sur Vertex AI.
  • PROJECT_ID : L'ID de votre projet Google Cloud.
  • TEXT : texte cible pour lequel vous souhaitez obtenir des représentations vectorielles continues. Par exemple, a cat.
  • IMAGE_URI : URI Cloud Storage de la vidéo cible pour laquelle vous souhaitez obtenir des représentations vectorielles continues. Par exemple, gs://my-bucket/embeddings/supermarket-img.png.

    Vous pouvez également fournir l'image en tant que chaîne d'octets encodée en base64 :

    [...]
"image": {
  "bytesBase64Encoded": "B64_ENCODED_IMAGE"
}
[...]
  • VIDEO_URI : URI Cloud Storage de la vidéo cible pour laquelle vous souhaitez obtenir des représentations vectorielles continues. Par exemple, gs://my-bucket/embeddings/supermarket-video.mp4.

    Vous pouvez également fournir la vidéo en tant que chaîne d'octets encodée en base64 :

    [...]
"video": {
  "bytesBase64Encoded": "B64_ENCODED_VIDEO"
}
[...]
  • videoSegmentConfig (START_SECOND, END_SECOND, INTERVAL_SECONDS). Facultatif. Définit les séquences vidéo spécifiques (en secondes) pour lesquelles les représentations vectorielles continues sont générées.

    Exemple :

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

    L'utilisation de cette configuration spécifie la présence de données vidéo de la 10e à la 60e seconde, et génère des représentations vectorielles continues pour les intervalles de 10 secondes suivants : [10, 20), [20, 30), [30, 40), [40, 50), [50, 60). Cet intervalle vidéo ("intervalSec": 10) est défini sur le mode de représentation vectorielle continue de vidéo Standard. L'utilisateur est facturé au tarif en mode Standard.

    Si vous omettez videoSegmentConfig, le service utilise les valeurs par défaut suivantes : "videoSegmentConfig": { "startOffsetSec": 0, "endOffsetSec": 120, "intervalSec": 16 }. Cet intervalle vidéo ("intervalSec": 16) est défini sur le mode de représentation vectorielle continue de vidéo Essentiel. L'utilisateur est facturé au tarif en mode Essentiel.

Méthode HTTP et URL : 

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

Corps JSON de la requête : 

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

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

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

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$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
La représentation vectorielle continue du modèle renvoie un vecteur à virgule flottante 1408. L'exemple de réponse suivant est abrégé pour les espaces. 
{
  "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

Pour savoir comment installer ou mettre à jour le SDK Vertex AI pour Python, consultez la section Installer le SDK Vertex AI pour Python. Pour en savoir plus, consultez la documentation de référence de l'API Python. 

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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Node.js.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

/**
 * 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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Java décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Java.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 


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

Corps de la réponse

{
  "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
}
Élément de réponse Description
imageEmbedding Liste de 128, 256, 512 ou 1 408 dimensions à virgule flottante.
textEmbedding Liste de 128, 256, 512 ou 1 408 dimensions à virgule flottante.
videoEmbeddings Liste de 1 408 dimensions à virgule flottante avec les heures de début et de fin (en secondes) de la séquence vidéo pour laquelle les représentations vectorielles continues sont générées.