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.

* Valor padrão

Casos de uso

Imagem e texto:

Classificação de imagem: usa uma imagem como entrada e prevê uma ou mais classes (rótulos).
Pesquisa de imagens: pesquise imagens relevantes ou semelhantes.
Recomendações: gere recomendações de produtos ou anúncios com base em imagens.

Imagem, texto e vídeo:

Recomendações: gere recomendações de produtos ou publicidade com base em vídeos (pesquisa por similaridade).
Pesquisa de conteúdo em vídeo
- Usando a pesquisa semântica: receba um texto como entrada e retorne um conjunto de frames classificados que correspondem à consulta.
- Usar a pesquisa por similaridade:
  - Toma um vídeo como entrada e retorna um conjunto de vídeos correspondentes à consulta.
  - Considere uma imagem como entrada e retorne um conjunto de vídeos que correspondam à consulta.
Classificação de vídeo: usa um vídeo como entrada e prevê uma ou mais classes.

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

Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

Acessar o seletor de projetos

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

Ative a API Vertex AI.

Ative a API

No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

Acessar o seletor de projetos

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

Ative a API Vertex AI.

Ative a API

Configure a autenticação do ambiente.

Selecione a guia para como planeja usar as amostras nesta página:
Java

Para usar as amostras de Java nesta página de um ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure o Application Default Credentials com as credenciais de usuário.
1. Instale a CLI do Google Cloud.
2. Para inicializar a CLI gcloud, execute o seguinte comando:
```
gcloud init
```
3. Atualize e instale os componentes gcloud:
```
gcloud components update
gcloud components install beta
```
4. Crie as credenciais de autenticação para sua Conta do Google:
```
gcloud auth application-default login
```
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 as amostras de Node.js nesta página de um ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure o Application Default Credentials com as credenciais de usuário.
1. Instale a CLI do Google Cloud.
2. Para inicializar a CLI gcloud, execute o seguinte comando:
```
gcloud init
```
3. Atualize e instale os componentes gcloud:
```
gcloud components update
gcloud components install beta
```
4. Crie as credenciais de autenticação para sua Conta do Google:
```
gcloud auth application-default login
```
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 as amostras de Python nesta página de um ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure o Application Default Credentials com as credenciais de usuário.
1. Instale a CLI do Google Cloud.
2. Para inicializar a CLI gcloud, execute o seguinte comando:
```
gcloud init
```
3. Atualize e instale os componentes gcloud:
```
gcloud components update
gcloud components install beta
```
4. Crie as credenciais de autenticação para sua Conta do Google:
```
gcloud auth application-default login
```
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 a CLI gcloud.
1. Instale a CLI do Google Cloud.
2. Para inicializar a CLI gcloud, execute o seguinte comando:
```
gcloud init
```
3. Atualize e instale os componentes gcloud:
```
gcloud components update
gcloud components install beta
```
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.
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

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que faz login automaticamente na CLI gcloud. É possível verificar a conta ativa atual executando gcloud auth list.

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

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login . É possível verificar a conta ativa atual executando gcloud auth list.

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.

from typing import Optional

import vertexai
from vertexai.vision_models import (
    Image,
    MultiModalEmbeddingModel,
    MultiModalEmbeddingResponse,
)

def get_image_embeddings(
    project_id: str,
    location: str,
    image_path: str,
    contextual_text: Optional[str] = None,
) -> MultiModalEmbeddingResponse:
    """Example of how to generate multimodal embeddings from image and text.

    Args:
        project_id: Google Cloud Project ID, used to initialize vertexai
        location: Google Cloud Region, used to initialize vertexai
        image_path: Path to image (local or Google Cloud Storage) to generate embeddings for.
        contextual_text: Text to generate embeddings for.
    """

    vertexai.init(project=project_id, location=location)

    model = MultiModalEmbeddingModel.from_pretrained("multimodalembedding")
    image = Image.load_from_file(image_path)

    embeddings = model.get_embeddings(
        image=image,
        contextual_text=contextual_text,
    )
    print(f"Image Embedding: {embeddings.image_embedding}")
    print(f"Text Embedding: {embeddings.text_embedding}")

Node.js

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
Standard	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.
O valor definido para videoSegmentConfig.intervalSec afeta o nível de preços da sua cobrança. Para mais informações, consulte a seção modos de embedding de vídeo e a página de preços.

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.

from typing import Optional

import vertexai
from vertexai.vision_models import (
    MultiModalEmbeddingModel,
    MultiModalEmbeddingResponse,
    Video,
    VideoSegmentConfig,
)

def get_video_embeddings(
    project_id: str,
    location: str,
    video_path: str,
    contextual_text: Optional[str] = None,
    dimension: Optional[int] = 1408,
    video_segment_config: Optional[VideoSegmentConfig] = None,
) -> MultiModalEmbeddingResponse:
    """Example of how to generate multimodal embeddings from video and text.

    Args:
        project_id: Google Cloud Project ID, used to initialize vertexai
        location: Google Cloud Region, used to initialize vertexai
        video_path: Path to video (local or Google Cloud Storage) to generate embeddings for.
        contextual_text: Text to generate embeddings for.
        dimension: Dimension for the returned embeddings.
            https://cloud.google.com/vertex-ai/docs/generative-ai/embeddings/get-multimodal-embeddings#low-dimension
        video_segment_config: Define specific segments to generate embeddings for.
            https://cloud.google.com/vertex-ai/docs/generative-ai/embeddings/get-multimodal-embeddings#video-best-practices
    """

    vertexai.init(project=project_id, location=location)

    model = MultiModalEmbeddingModel.from_pretrained("multimodalembedding")
    video = Video.load_from_file(video_path)

    embeddings = model.get_embeddings(
        video=video,
        video_segment_config=video_segment_config,
        contextual_text=contextual_text,
        dimension=dimension,
    )

    # Video Embeddings are segmented based on the video_segment_config.
    print("Video Embeddings:")
    for video_embedding in embeddings.video_embeddings:
        print(
            f"Video Segment: {video_embedding.start_offset_sec} - {video_embedding.end_offset_sec}"
        )
        print(f"Embedding: {video_embedding.embedding}")

    print(f"Text Embedding: {embeddings.text_embedding}")

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.
O valor definido para videoSegmentConfig.intervalSec afeta o nível de preços da sua cobrança. Para mais informações, consulte a seção modos de embedding de vídeo e a página de preços.

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.

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

A seguir

Leia o blog "What is Multimodal Search: 'LLMs with vision" change business".
Para informações sobre casos de uso somente de texto (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), leia Receber embeddings de texto.
Confira todas as ofertas de IA generativa de imagens da Vertex AI na Visão geral do Imagen na Vertex AI.
Confira modelos pré-treinados no Model Garden.
Saiba mais sobre práticas recomendadas de IA responsável e filtros de segurança na Vertex AI.