Obtenir des embeddings multimodaux

Le modèle d'embeddings multimodaux 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 des embeddings uniquement basés sur du texte, nous vous recommandons d'utiliser l'API d'embeddings textuels Vertex AI. Par exemple, l'API d'embeddings 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 embeddings de texte.

Modèles compatibles

Vous pouvez obtenir des embeddings multimodaux à l'aide du modèle suivant :

  • multimodalembedding

Bonnes pratiques

Tenez compte des aspects d'entrée suivants lorsque vous utilisez le modèle d'embeddings multimodaux :

  • 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 le prompt engineering 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 texte avec le mot "chat"




    image d'un chat
    Image d'un chat
    Crédit image : Manja Vitolic sur Unsplash.
  • Similarités des embeddings : le produit scalaire des embeddings 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 embeddings textuels 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.
Langue Anglais
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 d'embeddings 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

  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. Configurez l'authentification pour votre environnement.

    Select the tab for how you plan to use the samples on this 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. 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.

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

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

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

    Pour en savoir plus, consultez la section S'authentifier pour utiliser REST dans la documentation sur l'authentification Google Cloud.

  9. 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.
  10. Facultatif. Consultez les tarifs de cette fonctionnalité. Les tarifs des embeddings 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 embeddings de dimension inférieure

Par défaut, une requête d'embedding renvoie un vecteur à virgule flottante 1408 pour un type de données. Vous pouvez également spécifier des embeddings 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 embeddings. Les embeddings de dimension inférieure offrent des besoins de stockage réduits et une latence plus faible pour les tâches d'embeddings (comme la recherche ou les recommandations), tandis que ceux de dimension supérieure sont plus précis 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 l'embedding 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 embeddings. 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 embeddings. Par exemple, a cat.
  • EMBEDDING_DIMENSION : nombre de dimensions d'un embedding. Les valeurs inférieures permettent de réduire la latence lors de l'utilisation de ces embeddings 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

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
Le modèle d'embedding 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 d'embeddings (images et texte)

Utilisez les exemples de code suivants pour envoyer une requête d'embedding 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 embeddings 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 du 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 embeddings. Par exemple, a cat.
  • B64_ENCODED_IMG : l'image cible pour laquelle vous souhaitez obtenir des embeddings. 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
L'embedding 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. 

import vertexai
from vertexai.vision_models import Image, MultiModalEmbeddingModel

# TODO(developer): Update project_id and location
vertexai.init(project=PROJECT_ID, location="us-central1")

model = MultiModalEmbeddingModel.from_pretrained("multimodalembedding")
image = Image.load_from_file(
    "gs://cloud-samples-data/vertex-ai/llm/prompts/landmark1.png"
)

embeddings = model.get_embeddings(
    image=image,
    contextual_text="Colosseum",
    dimension=1408,
)
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.

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

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

Lors de l'envoi d'une requête d'embedding, 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 embeddings de vidéos : Essentiel, Standard ou Plus. Le mode correspond à la densité des embeddings générés, 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, un embedding est généré. 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 embeddings générés.

Les tarifs l'embedding 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 embeddings de vidéos :

Mode Nombre maximal d'embeddings par minute Intervalle d'embedding 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 embeddings 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 un seul embedding 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 un embedding 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 embeddings de vidéos

Utilisez l'exemple suivant pour obtenir des embeddings 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 embeddings. 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 embeddings sont générés.

    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 embeddings 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 d'embedding 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 d'embedding 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
L'embedding 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

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. 

import vertexai

from vertexai.vision_models import MultiModalEmbeddingModel, Video
from vertexai.vision_models import VideoSegmentConfig

# TODO(developer): Update project_id and location
vertexai.init(project=PROJECT_ID, location="us-central1")

model = MultiModalEmbeddingModel.from_pretrained("multimodalembedding")

embeddings = model.get_embeddings(
    video=Video.load_from_file(
        "gs://cloud-samples-data/vertex-ai-vision/highway_vehicles.mp4"
    ),
    video_segment_config=VideoSegmentConfig(end_offset_sec=1),
    contextual_text="Cars on Highway",
)

# 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 embeddings d'images, de texte et de vidéos

L'exemple suivant permet d'obtenir des embeddings 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 embeddings. Par exemple, a cat.
  • IMAGE_URI : URI Cloud Storage de la vidéo cible pour laquelle vous souhaitez obtenir des embeddings. 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 embeddings. 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 embeddings sont générés.

    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 embeddings 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 d'embedding 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 d'embedding 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
L'embedding 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. 

import vertexai

from vertexai.vision_models import Image, MultiModalEmbeddingModel, Video
from vertexai.vision_models import VideoSegmentConfig

# TODO(developer): Update project_id and location
vertexai.init(project=PROJECT_ID, location="us-central1")

model = MultiModalEmbeddingModel.from_pretrained("multimodalembedding")

image = Image.load_from_file(
    "gs://cloud-samples-data/vertex-ai/llm/prompts/landmark1.png"
)
video = Video.load_from_file(
    "gs://cloud-samples-data/vertex-ai-vision/highway_vehicles.mp4"
)

embeddings = model.get_embeddings(
    image=image,
    video=video,
    video_segment_config=VideoSegmentConfig(end_offset_sec=1),
    contextual_text="Cars on Highway",
)

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