Incorporaciones multimodales

El modelo de incorporaciones para multimodales (multimodalembedding) genera vectores de dimensión (128, 256, 512 o 1, 408 dimensiones) según la entrada que proporciones. Esta entrada puede incluir cualquier combinación de texto, imagen o video. Los vectores de incorporación se pueden usar para otras tareas posteriores, como la clasificación de imágenes o la moderación de contenido.

Los vectores de incorporación de texto, imagen y video se encuentran en el mismo espacio semántico con la misma dimensionalidad. Por lo tanto, estos vectores se pueden usar de forma indistinta para casos de uso como buscar imágenes por texto o buscar video por imagen.

Casos de uso

Estos son algunos casos de uso comunes de las incorporaciones multimodales:

  • Clasificación de imágenes o videos: toma una imagen o un video como entrada y predice una o más clases (etiquetas).
  • Búsqueda con imágenes: Busca imágenes relevantes o similares.
  • Búsqueda de contenido de video
    • Usa una búsqueda semántica: Toma un texto como entrada y muestra un conjunto de marcos con clasificación que coinciden con la consulta.
    • Usa la búsqueda de similitud:
      • Toma un video como entrada y muestra un conjunto de videos que coincidan con la consulta.
      • Toma una imagen como entrada y muestra un conjunto de videos que coincidan con la consulta.
  • Recomendaciones: genera recomendaciones de productos o anuncios según las imágenes o los videos (búsqueda de similitud).

Para explorar este modelo en la consola, consulta la tarjeta de modelo Incorporaciones para multimodales en Model Garden.

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

Solicitud HTTP

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

Cuerpo de la solicitud

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

Usa los siguientes parámetros para el modelo de generación multimodal multimodal embeddings. Para obtener más información, consulta Obtén incorporaciones multimodales.

Parámetro Descripción Valores aceptables
instances Un array que contiene el objeto con datos (texto, imagen y video) sobre los que se debe obtener información. array (se permite 1 objeto)
text El texto de entrada para el que deseas crear una incorporación. Cadena (32 tokens como máximo)
image.bytesBase64Encoded La imagen para la que se obtendrán incorporaciones. Si especificas image.bytesBase64Encoded, no puedes establecer image.gcsUri. Cadena de imagen codificada en base64 (archivo BMP, GIF, JPG o PNG, 20 MB como máximo)
image.gcsUri El URI de Cloud Storage de la imagen para la que se obtendrán incorporaciones. Si especificas image.gcsUri, no puedes establecer image.bytesBase64Encoded. URI de la cadena del archivo de imagen en Cloud Storage (archivo BMP, GIF, JPG o PNG, 20 MB como máximo)
image.mimeType Opcional. El tipo de MIME de la imagen que especificas. cadena (image/bmp, image/gif, image/jpeg o image/png)
video.bytesBase64Encoded El video para el que se obtendrán las incorporaciones. Si especificas video.bytesBase64Encoded, no puedes establecer video.gcsUri. Cadena de video codificada en base64 (archivo AVI, FLV, MKV, MOV, MP4, MPEG, MPG, WEBM o WMV)
video.gcsUri El URI de Cloud Storage del video para el que se obtendrán las incorporaciones. Si especificas video.gcsUri, no puedes establecer video.bytesBase64Encoded. URI de la cadena del archivo de video en Cloud Storage (archivo AVI, FLV, MKV, MOV, MP4, MPEG, MPG, WEBM o WMV)
videoSegmentConfig.startOffsetSec Opcional. El momento (en segundos) en el que el modelo comienza la detección de incorporaciones. Valor predeterminado: 0 integer
videoSegmentConfig.endOffsetSec Opcional. El momento (en segundos) en el que el modelo finaliza la detección de incorporaciones. Predeterminado: 120 integer
videoSegmentConfig.intervalSec Opcional. El tiempo (en segundos) de los segmentos de datos de video para los que se generan las incorporaciones. Este valor corresponde al modo de incorporación de video (Essential, Standard o Plus), que afecta la funciónprecios.

Modo Essential (intervalSec >= 15): la menor cantidad de segmentos de video para los que se generan incorporaciones. La opción de menor costo.
Nivel Estándar (8 <= intervalSec < 15): más segmentos de video en los que se generan incorporaciones que en el modo Essential, pero menos que en el modo Plus. Opción de costo intermedio.
Modo Plus (4 <= intervalSec < 8): la mayoría de los segmentos de video para los que se generan incorporaciones. La opción de costo más alto.

Predeterminado: 16 (modo Essential)		 número entero (valor mínimo: 4)
parameters.dimension Opcional. La dimensión del vector para la que se generan las incorporaciones (solo texto o imagen). Si no se establece, se usa el valor predeterminado de 1,408. número entero (128, 256, 512 o 1408 [predeterminado])

Solicitud de muestra

REST

En el siguiente ejemplo, se usan datos de imagen, texto y video. Puedes usar cualquier combinación de estos tipos de datos en el cuerpo de tu solicitud.

Además, este ejemplo usa un video ubicado en Cloud Storage. También puedes usar el campo video.bytesBase64Encoded para proporcionar una representación de string codificada en base64 del video.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • LOCATION: La región del proyecto. Por ejemplo, us-central1, europe-west2 o asia-northeast3. Para obtener una lista de las regiones disponibles, consulta IA generativa en ubicaciones de Vertex AI.
  • PROJECT_ID: El ID del proyecto de Google Cloud.
  • TEXT: El texto de destino para el que se obtendrán las incorporaciones. Por ejemplo:a cat
  • IMAGE_URI: Es el URI de Cloud Storage del video objetivo del que deseas obtener las incorporaciones. Por ejemplo, gs://my-bucket/embeddings/supermarket-img.png

    También puedes proporcionar la imagen como una cadena de bytes codificada en Base64:

    [...]
"image": {
  "bytesBase64Encoded": "B64_ENCODED_IMAGE"
}
[...]
  • VIDEO_URI: Es el URI de Cloud Storage del video objetivo del que deseas obtener las incorporaciones. Por ejemplo, gs://my-bucket/embeddings/supermarket-video.mp4

    También puedes proporcionar el video como una cadena de bytes codificada en Base64:

    [...]
"video": {
  "bytesBase64Encoded": "B64_ENCODED_VIDEO"
}
[...]
  • videoSegmentConfig (START_SECOND, END_SECOND, INTERVAL_SECONDS). Opcional. Los segmentos de video específicos (en segundos) para los que se generan las incorporaciones.

    Por ejemplo:

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

    El uso de esta configuración especifica los datos de video de 10 a 60 segundos y genera incorporaciones para los siguientes intervalos de video de 10 segundos: [10, 20), [20, 30), [30, 40), [40, 50), [50, 60]. Este intervalo de video ("intervalSec": 10) se encuentra en el modo de incorporación de video Standard, y se cobra al usuario la tarifa del modo Standard.

    Si omites videoSegmentConfig, el servicio usa los siguientes valores predeterminados: "videoSegmentConfig": { "startOffsetSec": 0, "endOffsetSec": 120, "intervalSec": 16 }. Este intervalo de video ("intervalSec": 16) se encuentra en el modo de incorporación de video Essential, y se le cobra al usuario la tarifa del modo Essential.

HTTP method and URL: 

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

Cuerpo JSON de la solicitud:

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

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

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

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$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 incorporación que muestra el modelo es un vector de número de punto flotante de 1,408. La siguiente muestra de respuesta se acorta por razones de espacio. 
{
  "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

Si deseas obtener información para instalar o actualizar el SDK de Python, consulta Instala el SDK de Vertex AI para Python. Si deseas obtener más información, consulta la documentación de referencia de la API de 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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Node.js incluidas en la guía de inicio rápido de Vertex AI sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Vertex AI Node.js.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Java incluidas en la guía de inicio rápido de Vertex AI sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Vertex AI Java.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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();
  }
}

Cuerpo de la respuesta

{
  "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
}
Elemento de la respuesta Descripción
imageEmbedding Lista de números de punto flotante en las dimensiones 128, 256, 512 o 1,408.
textEmbedding Lista de números de punto flotante en las dimensiones 128, 256, 512 o 1,408.
videoEmbeddings Lista de números de punto flotante de 1,408 dimensiones con la hora de inicio y finalización (en segundos) del segmento de video para el que se generan las incorporaciones.