Embedding multimodal

Model Embeddings untuk Multimodal (multimodalembedding) menghasilkan vektor dimensi (dimensi 128, 256, 512, atau 1408) berdasarkan input yang Anda berikan. Input ini dapat mencakup kombinasi teks, gambar, atau video. Kemudian, vektor embedding tersebut dapat digunakan untuk tugas-tugas lain berikutnya, seperti mengklasifikasi gambar atau memoderasi konten.

Vektor embedding teks, gambar, dan video berada di ruang semantik yang sama dengan dimensi yang sama. Oleh karena itu, vektor ini dapat digunakan secara bergantian untuk kasus penggunaan seperti menelusuri gambar melalui teks atau menelusuri video berdasarkan gambar.

Kasus penggunaan

Beberapa kasus penggunaan umum untuk embedding multimodal adalah:

  • Klasifikasi gambar atau video: Mengambil gambar atau video sebagai input dan memprediksi satu atau beberapa class (label).
  • Penelusuran gambar: Menelusuri gambar yang relevan, atau mirip.
  • Penelusuran konten video
    • Menggunakan penelusuran semantik: Mengambil teks sebagai input, dan menampilkan kumpulan frame berperingkat yang cocok dengan kueri.
    • Menggunakan penelusuran kemiripan:
      • Mengambil video sebagai input, dan menampilkan kumpulan video yang cocok dengan kueri.
      • Mengambil gambar sebagai input, dan menampilkan kumpulan video yang cocok dengan kueri.
  • Rekomendasi: Buat rekomendasi produk atau iklan berdasarkan gambar atau video (penelusuran kemiripan).

Untuk mempelajari model ini di konsol, lihat kartu model Embeddings untuk Multimodal di Model Garden.

Pergi ke Model Garden

Permintaan HTTP

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

Isi permintaan

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

Gunakan parameter berikut untuk model pembuatan multimodal multimodal embeddings. Untuk informasi selengkapnya, baca Mendapatkan embeddings multimodal.

Parameter Deskripsi Nilai yang dapat diterima
instances Array yang berisi objek dengan data (teks, gambar, dan video) yang akan mendapatkan informasinya. array (1 objek diizinkan)
text Teks input yang embedding-nya ingin Anda buat. String (maks 32 token)
image.bytesBase64Encoded Gambar yang akan mendapatkan embeddings. Jika menentukan image.bytesBase64Encoded, Anda tidak dapat menetapkan image.gcsUri. String gambar berenkode base64 (file BMP, GIF, JPG, atau PNG, maks 20 MB)
image.gcsUri URI Cloud Storage gambar untuk mendapatkan embedding. Jika menentukan image.gcsUri, Anda tidak dapat menetapkan image.bytesBase64Encoded. URI string file gambar di Cloud Storage (file BMP, GIF, JPG, atau PNG, maks 20 MB)
image.mimeType Opsional. Jenis MIME gambar yang Anda tentukan. string (image/bmp, image/gif, image/jpeg, atau image/png)
video.bytesBase64Encoded Video yang akan disematkan. Jika menentukan video.bytesBase64Encoded, Anda tidak dapat menetapkan video.gcsUri. String video berenkode base64 (file AVI, FLV, MKV, MOV, MP4, MPEG, MPG, WEBM, atau WMV)
video.gcsUri URI Cloud Storage video yang akan mendapatkan embeddings. Jika menentukan video.gcsUri, Anda tidak dapat menetapkan video.bytesBase64Encoded. URI string dari file video di Cloud Storage (file AVI, FLV, MKV, MOV, MP4, MPEG, MPG, WEBM, atau WMV)
videoSegmentConfig.startOffsetSec Opsional. Waktu (dalam detik) saat model memulai deteksi penyematan. Default: 0 bilangan bulat
videoSegmentConfig.endOffsetSec Opsional. Waktu (dalam detik) saat model mengakhiri deteksi penyematan. Default: 120 bilangan bulat
videoSegmentConfig.intervalSec Opsional. Waktu (dalam detik) segmen data video yang digunakan untuk menyematkan embedding. Nilai ini sesuai dengan mode penyematan video (Essential, Standar, atau Plus), yang memengaruhi pricing fitur.

Mode esensial (intervalSec >= 15): Segmen paling sedikit dari video yang menjadi tujuan embeddings. Opsi biaya terendah.
Tingkat standar (8 <= intervalSec < 15): Lebih banyak segmen video yang embeddingsnya dihasilkan daripada mode Penting, tetapi lebih sedikit daripada mode Plus. Opsi biaya menengah.
Mode plus (4 <= intervalSec < 8): Sebagian besar segmen video yang embeddings dihasilkan. Opsi biaya tertinggi.

Default: 16 (Mode Penting)		 bilangan bulat (nilai minimum: 4)
parameters.dimension Opsional. Dimensi vektor yang digunakan untuk menghasilkan embedding (teks atau gambar saja). Jika tidak disetel, nilai default 1408 akan digunakan. bilangan bulat (128, 256, 512, atau 1408 [default])

Permintaan sampel

REST

Contoh berikut menggunakan data gambar, teks, dan video. Anda dapat menggunakan kombinasi jenis data ini dalam isi permintaan.

Selain itu, contoh ini menggunakan video yang berada di Cloud Storage. Anda juga dapat menggunakan kolom video.bytesBase64Encoded untuk memberikan representasi string berenkode base64 dari video.

Sebelum menggunakan salah satu data permintaan, lakukan penggantian berikut:

  • LOCATION: Region project Anda. Misalnya, us-central1, europe-west2, atau asia-northeast3. Untuk mengetahui daftar region yang tersedia, lihat Generative AI di lokasi Vertex AI.
  • PROJECT_ID: ID project Google Cloud Anda.
  • TEXT: Teks target yang akan diberikan embedding. Contoh, a cat.
  • IMAGE_URI: URI Cloud Storage video target untuk mendapatkan embeddings. Contoh, gs://my-bucket/embeddings/supermarket-img.png.

    Anda juga dapat menyediakan gambar sebagai string byte berenkode base64:

    [...]
"image": {
  "bytesBase64Encoded": "B64_ENCODED_IMAGE"
}
[...]
  • VIDEO_URI: URI Cloud Storage video target untuk mendapatkan embeddings. Contoh, gs://my-bucket/embeddings/supermarket-video.mp4.

    Anda juga dapat menyediakan video sebagai string byte berenkode base64:

    [...]
"video": {
  "bytesBase64Encoded": "B64_ENCODED_VIDEO"
}
[...]
  • videoSegmentConfig (START_SECOND, END_SECOND, INTERVAL_SECONDS). Opsional. Segmen video tertentu (dalam detik) tempat embedding dibuat.

    Contoh:

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

    Menggunakan konfigurasi ini akan menentukan data video dari 10 detik hingga 60 detik dan menghasilkan embeddings untuk interval video 10 detik berikut: [10, 20), [20, 30), [30, 40), [40, 50), [50, 60). Interval video ini ("intervalSec": 10) termasuk dalam Mode penyematan video standar, dan pengguna ditagih dengan Tarif harga mode standar.

    Jika Anda menghapus videoSegmentConfig, layanan akan menggunakan nilai default berikut: "videoSegmentConfig": { "startOffsetSec": 0, "endOffsetSec": 120, "intervalSec": 16 }. Interval video ini ("intervalSec": 16) termasuk dalam Mode penyematan video penting, dan pengguna akan ditagih dengan Tarif harga mode Penting.

Metode HTTP dan URL: 

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

Isi JSON permintaan: 

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

Untuk mengirim permintaan Anda, pilih salah satu opsi berikut:

curl

Simpan isi permintaan dalam file bernama request.json, dan jalankan perintah berikut: 

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

Simpan isi permintaan dalam file bernama request.json, dan jalankan perintah berikut: 

$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
Embedding yang ditampilkan model adalah vektor float 1408. Respons contoh berikut disingkat karena ruang yang terbatas. 
{
  "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

Untuk mempelajari cara menginstal atau mengupdate Vertex AI SDK untuk Python, lihat Menginstal Vertex AI SDK untuk Python. Untuk mengetahui informasi selengkapnya, lihat dokumentasi referensi Python API. 

import vertexai

from vertexai.vision_models import Image, MultiModalEmbeddingModel, Video

# TODO(developer): Update values for project_id,
#            image_path, video_path, contextual_text, video_segment_config
vertexai.init(project=project_id, location="us-central1")

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

Sebelum mencoba contoh ini, ikuti petunjuk penyiapan Node.js di Panduan memulai Vertex AI menggunakan library klien. Untuk mengetahui informasi selengkapnya, lihat Dokumentasi referensi API Node.js Vertex AI.

Untuk melakukan autentikasi ke Vertex AI, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal. 

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

Sebelum mencoba contoh ini, ikuti petunjuk penyiapan Java di Panduan memulai Vertex AI menggunakan library klien. Untuk mengetahui informasi selengkapnya, lihat Dokumentasi referensi API Java Vertex AI.

Untuk melakukan autentikasi ke Vertex AI, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal. 


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

Isi respons

{
  "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
}
Elemen respons Deskripsi
imageEmbedding 128, 256, 512, atau 1408 daftar dimensi float.
textEmbedding 128, 256, 512, atau 1408 daftar dimensi float.
videoEmbeddings Daftar dimensi float 1408 dengan waktu mulai dan berakhir (dalam detik) segmen video tempat embedding dibuat.