Incorporamenti multimodali

Il modello rappresentazioni distribuite per multimodale (multimodalembedding) genera vettori di dimensione (128, 256, 512 o 1408 dimensioni) in base all'input fornito. Questo input può includere qualsiasi combinazione di testo, immagine o video. I vettori di incorporamento possono quindi essere utilizzati per altre attività successive come la classificazione delle immagini o la moderazione dei contenuti.

I vettori di incorporamento di testo, immagini e video si trovano nello stesso spazio semantico con la stessa dimensionalità. Questi vettori possono essere usati in modo intercambiabile per casi d'uso come la ricerca di immagini per testo o la ricerca di video per immagine.

Casi d'uso

Alcuni casi d'uso comuni per gli incorporamenti multimodali sono:

  • Classificazione di immagini o video: prende un'immagine o un video come input e prevede una o più classi (etichette).
  • Ricerca immagini: cerca immagini pertinenti o simili.
  • Ricerca di contenuti video
    • Utilizzando la ricerca semantica: prendi un testo come input e restituisci un insieme di frame classificati corrispondenti alla query.
    • Utilizzando la ricerca per somiglianza:
      • Prendi un video come input e restituisci un insieme di video corrispondenti alla query.
      • Prendi un'immagine come input e restituisci un insieme di video corrispondenti alla query.
  • Consigli: genera consigli su prodotti o annunci in base a immagini o video (ricerca di somiglianze).

Per esplorare questo modello nella console, consulta la scheda del modello Incorporamenti per il modello multimodale in Model Garden.

Vai a Model Garden

Richiesta HTTP

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

Corpo della richiesta

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

Utilizza i seguenti parametri per il modello di generazione multimodale multimodal embeddings. Per saperne di più, consulta Ottenere incorporamenti multimodali.

Parametro Descrizione Valori accettati
instances Un array che contiene l'oggetto con i dati (testo, immagine e video) su cui ottenere informazioni. array (1 oggetto consentito)
text Il testo di input per il quale vuoi creare un incorporamento. Stringa (massimo 32 token)
image.bytesBase64Encoded L'immagine per cui ottenere gli incorporamenti. Se specifichi image.bytesBase64Encoded, non puoi impostare image.gcsUri. Stringa immagine con codifica Base64 (file BMP, GIF, JPG o PNG, massimo 20 MB)
image.gcsUri L'URI Cloud Storage dell'immagine per cui ricevere gli incorporamenti. Se specifichi image.gcsUri, non puoi impostare image.bytesBase64Encoded. URI stringa del file immagine in Cloud Storage (file BMP, GIF, JPG o PNG, massimo 20 MB)
image.mimeType Facoltativo. Il tipo MIME dell'immagine specificata. stringa (image/bmp, image/gif, image/jpeg o image/png)
video.bytesBase64Encoded Il video per cui ottenere gli incorporamenti. Se specifichi video.bytesBase64Encoded, non puoi impostare video.gcsUri. Stringa video con codifica Base64 (file AVI, FLV, MKV, MOV, MP4, MPEG, MPG, WEBM o WMV)
video.gcsUri L'URI Cloud Storage del video per cui ricevere gli incorporamenti. Se specifichi video.gcsUri, non puoi impostare video.bytesBase64Encoded. URI stringa del file video in Cloud Storage (file AVI, FLV, MKV, MOV, MP4, MPEG, MPG, WEBM o WMV)
videoSegmentConfig.startOffsetSec Facoltativo. Il tempo (in secondi) in cui il modello inizia il rilevamento di incorporamento. Valore predefinito: 0 integer
videoSegmentConfig.endOffsetSec Facoltativo. Il tempo (in secondi) in cui il modello termina il rilevamento dell'incorporamento. Valore predefinito: 120 integer
videoSegmentConfig.intervalSec Facoltativo. Il tempo (in secondi) dei segmenti di dati video per cui vengono generati gli incorporamenti. Questo valore corrisponde alla modalità di incorporamento del video (Essential, Standard o Plus), che influisce sui pricing delle funzionalità.

Modalità essenziale (intervalSec >= 15): il numero minimo di segmenti di video per cui vengono generati gli incorporamenti. L'opzione più economica.
Livello Standard (8 <= intervalSec < 15): un numero maggiore di segmenti di video per cui vengono generati gli incorporamenti rispetto alla modalità Essenziale, ma meno segmenti rispetto alla modalità Plus. Opzione di costo intermedio.
Modalità Plus (4 <= intervalSec < 8): la maggior parte dei segmenti di video per i quali vengono generati gli incorporamenti. L'opzione di costo più alto.

Valore predefinito: 16 (modalità Essentials)		 numero intero (valore minimo: 4)
parameters.dimension Facoltativo. La dimensione vettoriale per cui generare incorporamenti (solo testo o immagine). Se non viene configurato, viene utilizzato il valore predefinito 1408. numero intero (128, 256, 512 o 1408 [valore predefinito])

Richiesta di esempio

REST

L'esempio seguente utilizza dati di immagini, testo e video. Puoi utilizzare qualsiasi combinazione di questi tipi di dati nel corpo della richiesta.

Inoltre, in questo esempio viene utilizzato un video in Cloud Storage. Puoi anche utilizzare il campo video.bytesBase64Encoded per fornire una rappresentazione stringa con codifica Base64 del video.

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

  • LOCATION: la regione del tuo progetto. Ad esempio, us-central1, europe-west2 o asia-northeast3. Per un elenco delle regioni disponibili, consulta la pagina relativa all'IA generativa sulle località di Vertex AI.
  • PROJECT_ID: il tuo ID progetto Google Cloud.
  • TEXT: il testo di destinazione per cui ricevere gli incorporamenti. Ad esempio, a cat.
  • IMAGE_URI: l'URI Cloud Storage del video di destinazione per cui ricevere gli incorporamenti. Ad esempio, gs://my-bucket/embeddings/supermarket-img.png.

    Puoi anche fornire l'immagine come stringa di byte codificata in base64:

    [...]
"image": {
  "bytesBase64Encoded": "B64_ENCODED_IMAGE"
}
[...]
  • VIDEO_URI: l'URI Cloud Storage del video di destinazione per cui ricevere gli incorporamenti. Ad esempio, gs://my-bucket/embeddings/supermarket-video.mp4.

    Puoi anche fornire il video come stringa di byte codificata in Base64:

    [...]
"video": {
  "bytesBase64Encoded": "B64_ENCODED_VIDEO"
}
[...]
  • videoSegmentConfig (START_SECOND, END_SECOND, INTERVAL_SECONDS). Facoltativa. I segmenti video specifici (in secondi) per i quali vengono generati gli incorporamenti.

    Ad esempio:

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

    L'utilizzo di questa configurazione consente di specificare i dati video da 10 a 60 secondi e genera incorporamenti per i seguenti intervalli video di 10 secondi: [10, 20), [20, 30), [30, 40), [40, 50), [50, 60). Questo intervallo video ("intervalSec": 10) rientra nella modalità di incorporamento standard dei video e all'utente viene addebitata la tariffa di prezzo della modalità Standard.

    Se ometti videoSegmentConfig, il servizio utilizza i seguenti valori predefiniti: "videoSegmentConfig": { "startOffsetSec": 0, "endOffsetSec": 120, "intervalSec": 16 }. Questo intervallo video ("intervalSec": 16) rientra nella modalità di incorporamento dei video essenziali e all'utente viene addebitata la tariffa di prezzo della modalità Essentials.

Metodo HTTP e URL: 

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

Corpo JSON della richiesta: 

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

Per inviare la richiesta, scegli una delle seguenti opzioni:

arricciatura

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando: 

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/multimodalembedding@001:predict"

PowerShell

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando: 

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/multimodalembedding@001:predict" | Select-Object -Expand Content
L'incorporamento restituito dal modello è un vettore a virgola mobile 1408. La seguente risposta di esempio è abbreviata per lo spazio. 
{
  "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

Per scoprire come installare o aggiornare l'SDK Vertex AI per Python, consulta Installare l'SDK Vertex AI per Python. Per saperne di più, consulta la documentazione di riferimento dell'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}")

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js riportate nella guida rapida di Vertex AI sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Node.js Vertex AI.

Per eseguire l'autenticazione in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Java riportate nella guida rapida di Vertex AI sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Java Vertex AI.

Per eseguire l'autenticazione in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 


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

Corpo della risposta

{
  "predictions": [
    {
      "textEmbedding": [
        float,
        // array of 128, 256, 512, or 1408 float values
        float
      ],
      "imageEmbedding": [
        float,
        // array of 128, 256, 512, or 1408 float values
        float
      ],
      "videoEmbeddings": [
        {
          "startOffsetSec": integer,
          "endOffsetSec": integer,
          "embedding": [
            float,
            // array of 1408 float values
            float
          ]
        }
      ]
    }
  ],
  "deployedModelId": string
}
Elemento risposta Descrizione
imageEmbedding Elenco di dimensioni dei valori mobili: 128, 256, 512 o 1408.
textEmbedding Elenco di dimensioni dei valori mobili: 128, 256, 512 o 1408.
videoEmbeddings Elenco di dimensioni 1408 di valori mobili con l'ora di inizio e di fine (in secondi) del segmento video per cui vengono generati gli incorporamenti.