Acessar embeddings multimodais

O modelo de embeddings multimodais gera vetores de 1.408 dimensões* com base na entrada fornecida, que pode incluir uma combinação de dados de imagem, texto e vídeo. Os vetores de embedding podem ser usados para tarefas subsequentes, como classificação de imagem ou moderação de conteúdo de vídeo.

O vetor de embedding de imagens e o vetor de embedding de texto estão no mesmo espaço semântico com a mesma dimensionalidade. Consequentemente, esses vetores podem ser usados de maneira intercambiável em casos de uso como pesquisa de imagem por texto ou pesquisa de vídeo por imagem.

Para casos de uso de incorporação de texto, recomendamos usar a API de embeddings de texto da Vertex AI. Por exemplo, a API text-embeddings pode ser melhor para pesquisa semântica baseada em texto, clustering, análise de documentos de longa duração e outros casos de uso de recuperação de texto ou resposta a perguntas. Para mais informações, consulte Usar embeddings de texto.

Modelos compatíveis

É possível conseguir embeddings multimodais usando o seguinte modelo:

  • multimodalembedding

Práticas recomendadas

Considere os seguintes aspectos de entrada ao usar o modelo de embeddings multimodais:

  • Texto em imagens: o modelo pode distinguir texto em imagens, semelhante ao reconhecimento óptico de caracteres (OCR). Se você precisar distinguir entre uma descrição do conteúdo da imagem e o texto dentro de uma imagem, considere usar engenharia imediata para especificar o conteúdo de destino. Por exemplo: em vez de apenas "gato", especifique "imagem de um gato" ou "o texto 'gato'", dependendo do seu caso de uso.




    o texto "gato"
    imagem de texto com a palavra gato




    imagem de um gato
    imagem de um gato
    Crédito da imagem: Manja Vitolic em Unsplash.
  • Semelhanças de embedding: o produto escalar de embeddings não é uma probabilidade calibrada. O produto escalar é uma métrica de similaridade e pode ter diferentes distribuições de pontuação para diferentes casos de uso. Consequentemente, evite usar um limite de valor fixo para avaliar a qualidade. Em vez disso, use abordagens de classificação para recuperação ou use sigmoid para classificação.

Uso da API

Limites da API

Os limites a seguir se aplicam quando você usa o modelo multimodalembedding para embeddings de texto e imagem:

Limite Valor e descrição
Dados de texto e imagem
Número máximo de solicitações de API por minuto em cada projeto 120
Tamanho máximo do texto 32 tokens (aproximadamente 32 palavras)

O tamanho máximo do texto é de 32 tokens (aproximadamente 32 palavras). Se a entrada exceder 32 tokens, o modelo encurtará internamente a entrada para esse comprimento.
Idioma Inglês
Formatos de imagem BMP, GIF, JPG e PNG
Tamanho da imagem Imagens codificadas em Base64: 20 MB (quando transcodificadas para PNG)
Imagens do Cloud Storage: 20 MB (formato de arquivo original)

O tamanho máximo de imagem aceito é 20 MB. Para evitar o aumento da latência da rede, use imagens menores. Além disso, o modelo redimensiona imagens para uma resolução de 512 x 512 pixels. Consequentemente, você não precisa fornecer imagens de resolução mais alta.
Dados de vídeo
Compatível com áudio N/A: o modelo não considera o conteúdo de áudio ao gerar embeddings de vídeo
Formatos de vídeo AVI, FLV, MKV, MOV, MP4, MPEG, MPG, WEBM, e WMV
Duração máxima do vídeo (Cloud Storage) Sem limite. No entanto, somente dois minutos de conteúdo podem ser analisados por vez.

Antes de começar

  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. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

  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. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

  7. Enable the Vertex AI API.

    Enable the API

    8.

  8. Configure a autenticação do ambiente.

    Select the tab for how you plan to use the samples on this page:

    Java

    Para usar os exemplos Java desta página em um ambiente de desenvolvimento local, instale e inicialize o gcloud CLI e e configure o Application Default Credentials com suas credenciais de usuário.

    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.

    Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local na documentação de autenticação do Google Cloud.

    Node.js

    Para usar os exemplos Node.js desta página em um ambiente de desenvolvimento local, instale e inicialize o gcloud CLI e e configure o Application Default Credentials com suas credenciais de usuário.

    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.

    Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local na documentação de autenticação do Google Cloud.

    Python

    Para usar os exemplos Python desta página em um ambiente de desenvolvimento local, instale e inicialize o gcloud CLI e e configure o Application Default Credentials com suas credenciais de usuário.

    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.

    Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local na documentação de autenticação do Google Cloud.

    REST

    Para usar as amostras da API REST nesta página em um ambiente de desenvolvimento local, use as credenciais fornecidas para 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

    Para mais informações, consulte Autenticar para usar REST na documentação de autenticação do Google Cloud.

  9. Para usar o SDK do Python, siga as instruções em Instalar o SDK da Vertex AI para Python. Saiba mais na documentação de referência da API do SDK da Vertex AI para Python.
  10. Opcional. Confira os preços desse recurso. Os preços dos embeddings dependem do tipo de dados enviados (como imagem ou texto) e também do modo usado para determinados tipos de dados (como Vídeo Plus, Vídeo Standard ou Vídeo Essential).

Locais

Um local é uma região que pode ser especificada em uma solicitação para controlar onde os dados são armazenados em repouso. Para uma lista de regiões disponíveis, consulte IA generativa em locais da Vertex AI.

Mensagens de erro

Erro de cota excedida

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.

Se esta for a primeira vez que você recebe esse erro, use o console do Google Cloud para solicitar um aumento de cota para o projeto. Use os filtros a seguir antes de solicitar um aumento:

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

Acessar Cotas

Se você já tiver enviado uma solicitação de aumento de cota, aguarde antes de enviar outra. Se você precisar aumentar ainda mais a cota, repita a solicitação de aumento de cota com sua justificativa para uma solicitação de cota sustentada.

Especificar embeddings de dimensões menores

Por padrão, uma solicitação de embedding retorna um vetor flutuante 1408 para um tipo de dados. Também é possível especificar embeddings de menor dimensão (128, 256 ou 512 vetores de ponto flutuante) para dados de texto e imagem. Essa opção permite otimizar a latência e o armazenamento ou a qualidade com base em como você planeja usar os embeddings. Os embeddings de menor dimensão oferecem menos necessidades de armazenamento e menor latência para tarefas de embedding subsequentes (como pesquisa ou recomendação), enquanto embeddings de maior dimensão oferecem maior acurácia para as mesmas tarefas.

REST

Acesse a dimensão de baixa dimensão adicionando o campo parameters.dimension. O parâmetro aceita um dos seguintes valores: 128, 256, 512 ou 1408. A resposta inclui o embedding dessa dimensão.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • LOCATION: a região do seu projeto. Por exemplo, us-central1, europe-west2 ou asia-northeast3. Para uma lista de regiões disponíveis, consulte IA generativa em locais da Vertex AI.
  • PROJECT_ID: o ID do projeto do Google Cloud.
  • IMAGE_URI: o URI do Cloud Storage do vídeo de destino para os embeddings serão recebidos. Por exemplo, gs://my-bucket/embeddings/supermarket-img.png.

    Também é possível fornecer a imagem como uma string de bytes codificada em base64:

    [...]
"image": {
  "bytesBase64Encoded": "B64_ENCODED_IMAGE"
}
[...]
  • TEXT: o texto de destino para receber embeddings. Por exemplo, a cat.
  • EMBEDDING_DIMENSION: o número de dimensões de incorporação. Valores mais baixos oferecem latência reduzida ao usar esses embeddings para tarefas subsequentes, enquanto valores mais altos oferecem melhor precisão. Valores disponíveis: 128, 256, 512 e 1408 (padrão).

Método HTTP e URL: 

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

Corpo JSON da solicitação:

{
  "instances": [
    {
      "image": {
        "gcsUri": "IMAGE_URI"
      },
      "text": "TEXT"
    }
  ],
  "parameters": {
    "dimension": EMBEDDING_DIMENSION
  }
}

Para enviar a solicitação, escolha uma destas opções:

curl

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

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

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

$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
A incorporação do modelo retorna um vetor flutuante da dimensão especificada. Os exemplos de respostas abaixo são encurtados para espaço.

128 dimensões:

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

256 dimensões:

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

512 dimensões:

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

Enviar uma solicitação de incorporação (imagem e texto)

Use os exemplos de código a seguir para enviar uma solicitação de incorporação com dados de imagem e texto. Nos exemplos, mostramos como enviar uma solicitação com os dois tipos de dados, mas você também pode usar o serviço com um tipo de dados individual.

Receber embeddings de texto e imagem

REST

Para mais informações sobre solicitações de modelo multimodalembedding, consulte a referência da API do modelo multimodalembedding.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • LOCATION: a região do seu projeto. Por exemplo, us-central1, europe-west2 ou asia-northeast3. Para uma lista de regiões disponíveis, consulte IA generativa em locais da Vertex AI.
  • PROJECT_ID: o ID do projeto do Google Cloud.
  • TEXT: o texto de destino para receber embeddings. Por exemplo, a cat.
  • B64_ENCODED_IMG: a imagem de destino que receberá os embeddings. A imagem precisa ser especificada como uma string de bytes codificada em base64.

Método HTTP e URL: 

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

Corpo JSON da solicitação:

{
  "instances": [
    {
      "text": "TEXT",
      "image": {
        "bytesBase64Encoded": "B64_ENCODED_IMG"
      }
    }
  ]
}

Para enviar a solicitação, escolha uma destas opções:

curl

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

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

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

$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
O embeddingdo modelo retorna um vetor de flutuação 1408. O exemplo de resposta a seguir é reduzido para o espaço. 
{
  "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

Para saber como instalar o SDK da Vertex AI para Python, consulte Instalar o SDK da Vertex AI para Python. Para mais informações, consulte a documentação de referência da API Python. 

import vertexai
from vertexai.vision_models import Image, MultiModalEmbeddingModel

# TODO(developer): Update project
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

Antes de testar essa amostra, siga as instruções de configuração para Node.js Guia de início rápido da Vertex AI: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Node.js.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 testar essa amostra, siga as instruções de configuração para Java Guia de início rápido da Vertex AI: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Java.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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();
  }
}

Enviar uma solicitação de incorporação (vídeo, imagem ou texto)

Ao enviar uma solicitação de embedding, especifique apenas um vídeo de entrada ou uma combinação de dados de vídeo, imagem e texto.

Modos de embedding de vídeo

Existem três modos que podem ser usados com embeddings de vídeo: Essential, Standard ou Plus. O modo corresponde à densidade dos embeddings gerados, que pode ser especificado pela configuração interval_sec na solicitação. Para cada intervalo de vídeo com interval_sec de duração, um embedding é gerado. A duração mínima do intervalo de vídeo é de 4 segundos. Intervalos maiores que 120 segundos podem afetar negativamente a qualidade dos embeddings gerados.

Os preços dos embeddings de vídeo dependem do modo usado. Para mais informações, consulte Preços.

A tabela a seguir resume os três modos que podem ser usados para embeddings de vídeo:

Modo Número máximo de embeddings por minuto Intervalo de embedding de vídeo (valor mínimo)
Essencial 4 15

Isso corresponde a: intervalSec >= 15
Padrão 8 8

Isso corresponde a: 8 <= intervalSec < 15
Mais 15 4

Isso corresponde a: 4 <= intervalSec < 8

Práticas recomendadas para embeddings de vídeo

Ao enviar solicitações de embedding de vídeo, considere isto:

  • Para gerar um único embedding para os dois primeiros minutos de um vídeo de entrada de qualquer duração, use a seguinte configuração de videoSegmentConfig:

    request.json:

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

  • Para gerar o embedding de um vídeo com duração superior a dois minutos, envie várias solicitações que especifiquem os horários de início e término em 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

Gerar embeddings de vídeo

Use o exemplo a seguir para receber embeddings para conteúdo de vídeo.

REST

Para mais informações sobre solicitações de modelo multimodalembedding, consulte a referência da API do modelo multimodalembedding.

O exemplo a seguir usa um vídeo localizado no Cloud Storage. Também é possível usar o campo video.bytesBase64Encoded para fornecer uma representação de string codificada em base64 do vídeo.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • LOCATION: a região do seu projeto. Por exemplo, us-central1, europe-west2 ou asia-northeast3. Para uma lista de regiões disponíveis, consulte IA generativa em locais da Vertex AI.
  • PROJECT_ID: o ID do projeto do Google Cloud.
  • VIDEO_URI: o URI do Cloud Storage do vídeo de destino para os embeddings serão recebidos. Por exemplo, gs://my-bucket/embeddings/supermarket-video.mp4.

    Você também pode fornecer o vídeo como uma string de bytes codificada em base64:

    [...]
"video": {
  "bytesBase64Encoded": "B64_ENCODED_VIDEO"
}
[...]
  • videoSegmentConfigSTART_SECONDEND_SECOND INTERVAL_SECONDS. Opcional. Os segmentos de vídeo específicos (em segundos) para os quais os embeddings são gerados.

    Exemplo:

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

    O uso dessa configuração especifica dados de vídeo de 10 a 60 segundos e gera embeddings para os seguintes intervalos de vídeo de 10 segundos: [10, 20), [20, 30), [30, 40), [40, 50), [50, 60). Esse intervalo de vídeo ("intervalSec": 10) se enquadra no modo de embedding de vídeo Standard, e a cobrança do usuário é feita conforme a taxa de preços do modo Standard.

    Se você omitir videoSegmentConfig, o serviço usará os seguintes valores padrão: "videoSegmentConfig": { "startOffsetSec": 0, "endOffsetSec": 120, "intervalSec": 16 }. Esse intervalo de vídeo ("intervalSec": 16) se enquadra no modo de embedding de vídeo Essential, e a cobrança do usuário é feita conforme a taxa de preços do modo Essential.

Método HTTP e URL: 

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

Corpo JSON da solicitação:

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

Para enviar a solicitação, escolha uma destas opções:

curl

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

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

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

$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
O embeddingdo modelo retorna um vetor de flutuação 1408. Os exemplos de respostas abaixo são encurtados para espaço.

Resposta (vídeo de sete segundos, sem videoSegmentConfig especificado):

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

Resposta (vídeo de 59 segundos, com a seguinte configuração de trecho de vídeo: "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

Para saber como instalar o SDK da Vertex AI para Python, consulte Instalar o SDK da Vertex AI para Python. Para mais informações, consulte a documentação de referência da API Python. 

import vertexai

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

# TODO(developer): Update project
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}")

Incorporar imagens, textos e vídeos

Use o exemplo a seguir para conseguir embeddings para conteúdo de vídeo, texto e imagem.

REST

Para mais informações sobre solicitações de modelo multimodalembedding, consulte a referência da API do modelo multimodalembedding.

O exemplo a seguir usa dados de imagem, texto e vídeo. É possível usar qualquer combinação desses tipos de dados no corpo da solicitação.

Além disso, essa amostra usa um vídeo localizado no Cloud Storage. Também é possível usar o campo video.bytesBase64Encoded para fornecer uma representação de string codificada em base64 do vídeo.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • LOCATION: a região do seu projeto. Por exemplo, us-central1, europe-west2 ou asia-northeast3. Para uma lista de regiões disponíveis, consulte IA generativa em locais da Vertex AI.
  • PROJECT_ID: o ID do projeto do Google Cloud.
  • TEXT: o texto de destino para receber embeddings. Por exemplo, a cat.
  • IMAGE_URI: o URI do Cloud Storage do vídeo de destino para os embeddings serão recebidos. Por exemplo, gs://my-bucket/embeddings/supermarket-img.png.

    Também é possível fornecer a imagem como uma string de bytes codificada em base64:

    [...]
"image": {
  "bytesBase64Encoded": "B64_ENCODED_IMAGE"
}
[...]
  • VIDEO_URI: o URI do Cloud Storage do vídeo de destino para os embeddings serão recebidos. Por exemplo, gs://my-bucket/embeddings/supermarket-video.mp4.

    Você também pode fornecer o vídeo como uma string de bytes codificada em base64:

    [...]
"video": {
  "bytesBase64Encoded": "B64_ENCODED_VIDEO"
}
[...]
  • videoSegmentConfigSTART_SECONDEND_SECOND INTERVAL_SECONDS. Opcional. Os segmentos de vídeo específicos (em segundos) para os quais os embeddings são gerados.

    Exemplo:

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

    O uso dessa configuração especifica dados de vídeo de 10 a 60 segundos e gera embeddings para os seguintes intervalos de vídeo de 10 segundos: [10, 20), [20, 30), [30, 40), [40, 50), [50, 60). Esse intervalo de vídeo ("intervalSec": 10) se enquadra no modo de embedding de vídeo Standard, e a cobrança do usuário é feita conforme a taxa de preços do modo Standard.

    Se você omitir videoSegmentConfig, o serviço usará os seguintes valores padrão: "videoSegmentConfig": { "startOffsetSec": 0, "endOffsetSec": 120, "intervalSec": 16 }. Esse intervalo de vídeo ("intervalSec": 16) se enquadra no modo de embedding de vídeo Essential, e a cobrança do usuário é feita conforme a taxa de preços do modo Essential.

Método HTTP e URL: 

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

Corpo JSON da solicitação:

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

Para enviar a solicitação, escolha uma destas opções:

curl

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

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

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

$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
O embeddingdo modelo retorna um vetor de flutuação 1408. O exemplo de resposta a seguir é reduzido para o espaço. 
{
  "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

Para saber como instalar o SDK da Vertex AI para Python, consulte Instalar o SDK da Vertex AI para Python. Para mais informações, consulte a documentação de referência da API Python. 

import vertexai

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

# TODO(developer): Update project
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}")

A seguir