Obtenir des représentations vectorielles continues multimodales

Le modèle de représentations vectorielles continues multimodales génère des vecteurs de 1 408 dimensions* à partir de l'entrée que vous fournissez, qui peut inclure une combinaison de données d'image, textuelles et vidéo. Les vecteurs de représentations vectorielles continues peuvent ensuite être utilisés pour des tâches ultérieures, telles que la classification d'images ou la modération de contenu vidéo.

Le vecteur de représentations vectorielles continues d'images et le vecteur de représentations vectorielles continues de texte 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.

Pour les cas d'utilisation de représentations vectorielles continues uniquement basées sur du texte, nous vous recommandons d'utiliser l'API de représentations vectorielles continues basées sur du texte Vertex AI. Par exemple, l'API de représentations vectorielles continues basée sur du texte peut être plus efficace pour la recherche sémantique basée sur du texte, le clustering, l'analyse de documents de longue durée et d'autres cas d'utilisation, comme la récupération de texte ou les systèmes de questions-réponses. Pour en savoir plus, consultez l'article Obtenir des représentations vectorielles continues de texte.

* Valeur par défaut

Cas d'utilisation

Image et texte :

Classification d'images : prend une image en entrée et prédit une ou plusieurs classes (étiquettes).
Recherche d'images : recherche des images pertinentes ou similaires.
Recommandations : génère des recommandations de produits ou d'annonces en fonction d'images.

Image, texte et vidéo :

Recommandations : générez des recommandations de produits ou de publicités à partir de vidéos (recherche de similarités).
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.
Classification de vidéos : part d'une vidéo en entrée et prédit une ou plusieurs classes.

Modèles compatibles

Vous pouvez obtenir des représentations vectorielles continues multimodales à l'aide du modèle suivant :

multimodalembedding

Bonnes pratiques

Tenez compte des aspects d'entrée suivants lorsque vous utilisez le modèle de représentations vectorielles continues multimodales :

Texte dans les images : le modèle peut distinguer du texte des images, comme la reconnaissance optique des caractères (OCR). Si vous devez faire la distinction entre une description de contenu d'image et le texte d'une image, envisagez d'utiliser une ingénierie des requêtes pour spécifier votre contenu cible. Par exemple, au lieu de simplement indiquer "chat", spécifiez "image d'un chat" ou "le texte chat", selon votre cas d'utilisation.

le texte "chat"
image d'un chat	^{Crédit image : Manja Vitolic sur Unsplash.}

Similarités des représentations vectorielles continues : le produit scalaire des représentations vectorielles continues n'est pas une probabilité calibrée. Le produit scalaire est une métrique de similarité et peut avoir des distribution de cotes différentes pour différents cas d'utilisation. Par conséquent, évitez d'utiliser un seuil de valeur fixe pour mesurer la qualité. Utilisez plutôt des approches de classement pour la récupération ou la fonction sigmoïde pour la classification.

Utilisation de l'API

Limites d'API

Les limites suivantes s'appliquent lorsque vous utilisez le modèle multimodalembedding pour les représentations vectorielles continues de texte et d'images :

Limite	Valeur et description
	Données textuelles et d'image
Nombre maximal de requêtes API par minute et par projet	120
Longueur de texte maximale	32 jetons (environ 32 mots) La longueur maximale du texte est de 32 jetons (environ 32 mots). Si l'entrée dépasse 32 jetons, le modèle la raccourcit à cette longueur de manière interne.
Langage	Français
Formats d'image	BMP, GIF, JPG, PNG
Taille d'image	Images encodées en Base64 : 20 Mo (lors du transcodage vers PNG) Images Cloud Storage : 20 Mo (format de fichier d'origine) La taille maximale d'image acceptée est de 20 Mo. Pour éviter d'augmenter la latence du réseau, utilisez des images plus petites. En outre, le modèle redimensionne les images au format 512 x 512 pixels. Par conséquent, vous n'avez pas besoin de fournir des images de résolution supérieure.
	Données vidéo
Compatibilité audio	N/A : le modèle ne prend pas en compte le contenu audio lors de la génération de représentations vectorielles continues de vidéos.
Formats vidéo	AVI, FLV, MKV, MOV, MP4, MPEG, MPG, WEBM et WMV
Durée maximale de la vidéo (Cloud Storage)	Aucune limite Toutefois, vous ne pouvez analyser que deux minutes de contenu à la fois.

Avant de commencer

Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.

Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

Accéder au sélecteur de projet

Vérifiez que la facturation est activée pour votre projet Google Cloud.

Activez l'API Vertex AI

Activer l'API

Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

Accéder au sélecteur de projet

Vérifiez que la facturation est activée pour votre projet Google Cloud.

Activez l'API Vertex AI

Activer l'API

Configurez l'authentification pour votre environnement.

Sélectionnez l'onglet correspondant à la façon dont vous prévoyez d'utiliser les exemples de cette page :
Java

Pour utiliser les exemples Java de cette page dans un environnement de développement local, installez et initialisez gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.
1. Installez Google Cloud CLI.
2. Pour initialiser gcloudCLI, exécutez la commande suivante :
```
gcloud init
```
3. Mettez à jour et installez les composants gcloud :
```
gcloud components update
gcloud components install beta
```
4. Créez des identifiants d'authentification locaux pour votre compte Google :
```
gcloud auth application-default login
```
Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local dans la documentation sur l'authentification Google Cloud.
Node.js

Pour utiliser les exemples Node.js de cette page dans un environnement de développement local, installez et initialisez gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.
1. Installez Google Cloud CLI.
2. Pour initialiser gcloudCLI, exécutez la commande suivante :
```
gcloud init
```
3. Mettez à jour et installez les composants gcloud :
```
gcloud components update
gcloud components install beta
```
4. Créez des identifiants d'authentification locaux pour votre compte Google :
```
gcloud auth application-default login
```
Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local dans la documentation sur l'authentification Google Cloud.
Python

Pour utiliser les exemples Python de cette page dans un environnement de développement local, installez et initialisez gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.
1. Installez Google Cloud CLI.
2. Pour initialiser gcloudCLI, exécutez la commande suivante :
```
gcloud init
```
3. Mettez à jour et installez les composants gcloud :
```
gcloud components update
gcloud components install beta
```
4. Créez des identifiants d'authentification locaux pour votre compte Google :
```
gcloud auth application-default login
```
Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local dans la documentation sur l'authentification Google Cloud.
REST

Pour utiliser les exemples d'API REST de cette page dans un environnement de développement local, vous devez utiliser les identifiants que vous fournissez à gcloud CLI.
1. Installez Google Cloud CLI.
2. Pour initialiser gcloudCLI, exécutez la commande suivante :
```
gcloud init
```
3. Mettez à jour et installez les composants gcloud :
```
gcloud components update
gcloud components install beta
```
Pour utiliser le SDK Python, suivez les instructions de la page Installer le SDK Vertex AI pour Python. Pour en savoir plus, consultez la documentation de référence de l'API SDK Vertex AI pour Python.
Facultatif. Consultez les tarifs de cette fonctionnalité. Les tarifs des représentations vectorielles continues dépendent du type de données que vous envoyez (comme des images ou du texte), ainsi que du mode que vous utilisez pour certains types de données (par exemple, Vidéo Plus, Vidéo Standard ou Video Essentiel).

Emplacements

Un emplacement est une région que vous pouvez spécifier dans une requête pour contrôler l'emplacement de stockage des données au repos. Pour obtenir la liste des régions disponibles, consultez la section Emplacements AI générative sur Vertex AI.

Messages d'erreur

Le quota autorisé a été dépassé

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.

Si vous recevez cette erreur pour la première fois, utilisez la console Google Cloud pour demander une augmentation de quota pour votre projet. Utilisez les filtres suivants avant de demander votre augmentation :

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

Accéder à la section "Quotas"

Si vous avez déjà envoyé une demande d'augmentation de quota, attendez avant d'envoyer une autre demande. Si vous devez augmenter davantage le quota, répétez la demande d'augmentation de quota en apportant une justification.

Spécifier des représentations vectorielles continues de dimension inférieure

Par défaut, une requête de représentation vectorielle continue renvoie un vecteur à virgule flottante 1408 pour un type de données. Vous pouvez également spécifier des représentations vectorielles continues de dimension inférieure (128, 256 ou 512 vecteurs à virgule flottante) pour les données textuelles et d'image. Cette option vous permet d'optimiser la latence et le stockage, ou la qualité en fonction de la manière dont vous envisagez d'utiliser les représentations vectorielles continues. Les représentations vectorielles continues de dimension inférieure offrent des besoins de stockage réduits et une latence plus faible pour les tâches de représentations vectorielles continues (comme la recherche ou les recommandations), tandis que celles de dimension supérieure sont plus précises pour les mêmes tâches.

REST

Vous pouvez accéder à une dimension faible en ajoutant le champ parameters.dimension. Le paramètre accepte l'une des valeurs suivantes : 128, 256, 512 ou 1408. La réponse inclut la représentation vectorielle continue de cette dimension.

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.
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"
}
[...]
```
TEXT : texte cible pour lequel vous souhaitez obtenir des représentations vectorielles continues. Par exemple, a cat.
EMBEDDING_DIMENSION : nombre de dimensions d'une représentation vectorielle continue. Les valeurs inférieures permettent de réduire la latence lors de l'utilisation de ces représentations vectorielles continues pour les tâches ultérieures, tandis que les valeurs plus élevées offrent une meilleure précision. Valeurs disponibles : 128, 256, 512 et 1408 (par défaut).

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": [
    {
      "image": {
        "gcsUri": "IMAGE_URI"
      },
      "text": "TEXT"
    }
  ],
  "parameters": {
    "dimension": EMBEDDING_DIMENSION
  }
}

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

curl

Remarque : La commande suivante suppose que vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

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

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

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 de la dimension spécifiée. Les exemples de réponses suivants sont abrégés à des fins de concision.

128 dimensions :

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

256 dimensions :

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

512 dimensions :

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

Envoyer une requête de représentations vectorielles continues (images et texte)

Utilisez les exemples de code suivants pour envoyer une requête de représentation vectorielle continue avec des données de type image et texte. Les exemples montrent comment envoyer une requête avec les deux types de données, mais vous pouvez également utiliser le service avec un seul type de données.

Obtenir des représentations vectorielles continues de texte et d'images

REST

Pour en savoir plus sur les requêtes de modèle multimodalembedding, consultez la Documentation de référence de l'API de modèle multimodalembedding.

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.
B64_ENCODED_IMG : l'image cible pour laquelle vous souhaitez obtenir des représentations vectorielles continues. L'image doit être spécifiée en tant que chaîne d'octets encodée en base64.

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

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

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,
)

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

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.


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

Envoyer une requête de représentations vectorielles continues (vidéos, images ou texte)

Lors de l'envoi d'une requête de représentation vectorielle continue, vous pouvez spécifier uniquement une vidéo en entrée ou une combinaison de données vidéo, d'image et textuelles.

Modes de représentations vectorielles continues des vidéos

Vous pouvez utiliser trois modes avec des représentations vectorielles continues de vidéos : Essentiel, Standard ou Plus. Le mode correspond à la densité des représentations vectorielles continues générées, qui peut être spécifiée par la configuration interval_sec de la requête. Pour chaque intervalle vidéo d'une durée de interval_sec, une représentation vectorielle continue est générée. La durée minimale de l'intervalle vidéo est de quatre secondes. Les intervalles de plus de 120 secondes peuvent avoir un impact négatif sur la qualité des représentations vectorielles continues générées.

Les tarifs de la représentation vectorielle continue de vidéo dépendent du mode que vous utilisez. Pour en savoir plus, reportez-vous à la page Tarifs.

Le tableau suivant récapitule les trois modes que vous pouvez utiliser pour les représentations vectorielles continues de vidéos :

Mode	Nombre maximal de représentations vectorielles continues par minute	Intervalle de représentation vectorielle continue de vidéo (valeur minimale)
Essentiel	4	15 Cela correspond à `intervalSec` >= 15.
Standard	8	8 Cela correspond à 8 <= `intervalSec` < 15.
Plus	15	4 Cela correspond à 4 <= `intervalSec` < 8.

Bonnes pratiques concernant les représentations vectorielles continues de vidéos

Tenez compte des points suivants lorsque vous envoyez des requêtes de représentations vectorielles continues de vidéos :

Pour générer une seule représentation vectorielle continue pour les deux premières minutes d'une vidéo en entrée de n'importe quelle durée, utilisez le paramètre videoSegmentConfig suivant :

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

Pour générer une représentation vectorielle continue pour une vidéo d'une durée supérieure à deux minutes, vous pouvez envoyer plusieurs requêtes spécifiant les heures de début et de fin dans la configuration videoSegmentConfig :

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

Obtenir des représentations vectorielles continues de vidéos

Utilisez l'exemple suivant pour obtenir des représentations vectorielles continues uniquement pour du contenu vidéo.

REST

Pour en savoir plus sur les requêtes de modèle multimodalembedding, consultez la Documentation de référence de l'API de modèle multimodalembedding.

L'exemple suivant 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.
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.
La valeur que vous définissez pour videoSegmentConfig.intervalSec affecte le niveau de tarification qui vous est facturé. Pour en savoir plus, consultez la section Modes de représentations vectorielles continues de vidéos et la page Tarifs.

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": [
    {
      "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. Les exemples de réponses suivants sont abrégés à des fins de concision.

Réponse (sept secondes de vidéo, pas d'élément videoSegmentConfig spécifié) :

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

Réponse (59 secondes de vidéo, avec la configuration de séquence vidéo suivante : "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

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}")

Obtenir des représentations vectorielles continues d'images, de texte et de vidéos

L'exemple suivant permet d'obtenir des représentations vectorielles continues pour du contenu vidéo, du texte et des images.

REST

Pour en savoir plus sur les requêtes de modèle multimodalembedding, consultez la Documentation de référence de l'API de modèle multimodalembedding.

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.
La valeur que vous définissez pour videoSegmentConfig.intervalSec affecte le niveau de tarification qui vous est facturé. Pour en savoir plus, consultez la section Modes de représentations vectorielles continues de vidéos et la page Tarifs.

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

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}")

Étapes suivantes

Consultez le blog "Qu'est-ce que la recherche multimodale : les LLM avec vision modifient les entreprises".
Pour plus d'informations sur les cas d'utilisation uniquement basés sur du texte, la recherche sémantique basée sur du texte, le clustering, l'analyse de documents de longue durée et d'autres cas d'utilisation, comme la récupération de texte ou les systèmes de questions-réponses, consultez la page Obtenir des représentations vectorielles continues de texte.
Consultez toutes les offres d'IA générative d'images de Vertex AI dans la présentation d'Imagen sur Vertex AI.
Découvrez d'autres modèles pré-entraînés dans le jardin de modèles.
Découvrez les bonnes pratiques d'IA responsable et les filtres de sécurité dans Vertex AI.