Questa pagina è stata tradotta dall'API Cloud Translation.

Incorporamenti multimodali

Il modello Embeddings per multimodali (multimodalembedding) genera vettori di dimensioni (128, 256, 512 o 1408 dimensioni) in base all'input fornito. Questo input può includere qualsiasi combinazione di testo, immagini 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 utilizzati in modo intercambiabile per casi d'uso come la ricerca di immagini tramite testo o la ricerca di video tramite 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.
- Utilizzo della ricerca di similitudini:
  - 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 pubblicità in base a immagini o video (ricerca di affinità).

Per esplorare questo modello nella console, consulta la scheda del modello Embeddings for multimodal (Incorporamenti per multimodali) 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 accettabili
`instances`	Un array che contiene l'oggetto con i dati (testo, immagine e video) di 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 ottenere 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 il quale ottenere gli incorporamenti. Se specifichi `video.gcsUri`, non puoi impostare `video.bytesBase64Encoded`.	URI della 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 dell'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 minor numero di segmenti di video per cui vengono generati gli incorporamenti. L'opzione più economica. Livello Standard (8 <= `intervalSec` < 15): più segmenti di video per i quali vengono generati gli incorporamenti rispetto alla modalità Essenziale, ma meno rispetto alla modalità Plus. Opzione di costo intermedio. Modalità più (4 <= `intervalSec` < 8): la maggior parte dei segmenti di video per cui vengono generati gli incorporamenti. L'opzione con il costo più alto. Predefinito: 16 (modalità Essenziale)	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` [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, questo esempio utilizza un video che si trova in Cloud Storage. Puoi anche utilizzare il campo video.bytesBase64Encoded per fornire una rappresentazione stringa del video con codifica Base64.

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 Località per l'AI generativa su Vertex AI.
PROJECT_ID: il tuo ID progetto Google Cloud.
TEXT: il testo di destinazione per cui ottenere gli incorporamenti. Ad esempio, a cat.
IMAGE_URI: l'URI Cloud Storage del video di destinazione per il quale ottenere 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 il quale ottenere 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 cui vengono generati gli incorporamenti.
Il valore impostato per videoSegmentConfig.intervalSec influisce sul livello di prezzo che ti viene addebitato. Per ulteriori informazioni, consulta la sezione relativa alle modalità di incorporamento dei video e la pagina dei pricing.

Ad esempio:
```
[...]
"videoSegmentConfig": {
  "startOffsetSec": 10,
  "endOffsetSec": 60,
  "intervalSec": 10
}
[...]
```
Questa configurazione specifica i dati video compresi tra 10 e 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 video standard e all'utente viene addebitata la tariffa per la 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 per la modalità essenziale.

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:

curl

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti fa accedere automaticamente all'interfaccia a riga di comando di gcloud. . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

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

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando di gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

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 in 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, vedi Installare l'SDK Vertex AI per Python. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Python.

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

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

Per eseguire l'autenticazione su Vertex AI, configura 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 per la configurazione di Java nella guida rapida di Vertex AI sull'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Java Vertex AI.

Per eseguire l'autenticazione su Vertex AI, configura 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 delle dimensioni dei numeri in virgola mobile 128, 256, 512 o 1408.
`textEmbedding`	Elenco delle dimensioni dei numeri in virgola mobile 128, 256, 512 o 1408.
`videoEmbeddings`	Elenco delle dimensioni 1408 dei numeri in virgola mobile con l'ora di inizio e di fine (in secondi) del segmento video per cui vengono generati gli incorporamenti.