Ottieni incorporamenti multimodali

Il modello di incorporamenti multimodali genera 1408 vettori di dimensione* in base all'input fornito, che può includere una combinazione di dati di immagini, testo e video. I vettori di incorporamento possono quindi essere utilizzati per attività successive come la classificazione delle immagini o la moderazione dei contenuti video.

Il vettore di incorporamento di immagini e il vettore di incorporamento di testo si trovano nello stesso spazio semantico con la stessa dimensionalità. Di conseguenza, questi vettori possono essere utilizzati in modo intercambiabile per casi d'uso come la ricerca di immagini per testo o la ricerca di video per immagine.

Per i casi d'uso di incorporamento di solo testo, consigliamo invece di utilizzare l'API Vertex AI text-embeddings. Ad esempio, l'API text-embeddings potrebbe essere migliore per la ricerca semantica basata su testo, il clustering, l'analisi di documenti di lunga durata e altri casi d'uso di recupero di testo o di risposta alle domande. Per ulteriori informazioni, consulta la sezione Ottenere incorporamenti di testo.

* Valore predefinito.

Casi d'uso

Immagine e testo:

  • Classificazione delle immagini: prende un'immagine come input e prevede una o più classi (etichette).
  • Ricerca immagini: consente di cercare immagini pertinenti o simili.
  • Consigli: genera consigli su prodotti o annunci in base alle immagini.

Immagine, testo e video:

  • Consigli: genera consigli su prodotti o pubblicità in base ai video (ricerca di somiglianze).
  • 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.
  • Classificazione video: prende un video come input e prevede una o più classi.

Modelli supportati

Puoi ottenere incorporamenti multimodali utilizzando il seguente modello:

  • multimodalembedding

best practice

Considera i seguenti aspetti di input quando utilizzi il modello di incorporamenti multimodali:

  • Testo nelle immagini: il modello è in grado di distinguere il testo nelle immagini, in modo simile al riconoscimento ottico dei caratteri (OCR). Se devi distinguere tra una descrizione dei contenuti dell'immagine e il testo all'interno di un'immagine, valuta la possibilità di utilizzare il prompt engineering per specificare i contenuti di destinazione. Ad esempio, invece di semplicemente "gatto", specifica "immagine di un gatto" o "il testo "gatto"", a seconda del caso d'uso.




    il testo "gatto"
    immagine di testo con la parola gatto




    immagine di un gatto
    immagine di un gatto
    Immagine di: Manja Vitolic su Unsplash.
  • Somiglianze di incorporamento: il prodotto scalare degli incorporamenti non è una probabilità calibrata. Il prodotto scalare è una metrica di somiglianza e potrebbe avere distribuzioni di punteggi diverse per casi d'uso diversi. Di conseguenza, evita di usare una soglia di valore fissa per misurare la qualità. Usa invece approcci di ranking per il recupero o sigmoidale per la classificazione.

Utilizzo delle API

Limiti dell'API

I seguenti limiti si applicano quando utilizzi il modello multimodalembedding per gli incorporamenti di testo e immagini:

Limite Valore e descrizione
Dati di testo e immagine
Numero massimo di richieste API al minuto per progetto 120
Lunghezza massima del testo 32 token (~32 parole)

La lunghezza massima del testo è 32 token (circa 32 parole). Se l'input supera i 32 token, il modello accorcia internamente l'input in base a questa lunghezza.
Lingua Inglese
Formati immagine BMP, GIF, JPG, PNG
Dimensioni dell'immagine Immagini con codifica Base64: 20 MB (se transcodificate in formato PNG)
Immagini Cloud Storage: 20 MB (formato file originale)

Le dimensioni massime delle immagini accettate sono 20 MB. Per evitare una maggiore latenza di rete, utilizza immagini più piccole. Inoltre, il modello ridimensiona le immagini a una risoluzione di 512 x 512 pixel. Di conseguenza, non è necessario fornire immagini con risoluzione superiore.
Dati relativi ai video
Audio supportato N/A: il modello non prende in considerazione i contenuti audio durante la generazione di incorporamenti video
Formati video AVI, FLV, MKV, MOV, MP4, MPEG, MPG, WEBM e WMV
Durata massima video (Cloud Storage) Nessun limite. Tuttavia, possono essere analizzati solo 2 minuti di contenuti alla volta.

Prima di iniziare

  1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

  2. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  4. Attiva l'API Vertex AI.

    Abilita l'API

    5.

  5. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  6. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  7. Attiva l'API Vertex AI.

    Abilita l'API

    8.

  8. Configura l'autenticazione per il tuo ambiente.

    Seleziona la scheda relativa a come prevedi di utilizzare gli esempi in questa pagina:

    Java

    Per utilizzare gli esempi Java in questa pagina da un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.

    1. Installa Google Cloud CLI.

    2. Per initialize gcloud CLI, esegui questo comando: 

      gcloud init
    3. Aggiorna e installa i componenti di gcloud: 
      gcloud components update
      gcloud components install beta

    4. Crea credenziali di autenticazione locali per il tuo Account Google: 

      gcloud auth application-default login

    Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale nella documentazione sull'autenticazione di Google Cloud.

    Node.js

    Per utilizzare gli esempi Node.js in questa pagina da un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.

    1. Installa Google Cloud CLI.

    2. Per initialize gcloud CLI, esegui questo comando: 

      gcloud init
    3. Aggiorna e installa i componenti di gcloud: 
      gcloud components update
      gcloud components install beta

    4. Crea credenziali di autenticazione locali per il tuo Account Google: 

      gcloud auth application-default login

    Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale nella documentazione sull'autenticazione di Google Cloud.

    Python

    Per utilizzare gli esempi Python in questa pagina da un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.

    1. Installa Google Cloud CLI.

    2. Per initialize gcloud CLI, esegui questo comando: 

      gcloud init
    3. Aggiorna e installa i componenti di gcloud: 
      gcloud components update
      gcloud components install beta

    4. Crea credenziali di autenticazione locali per il tuo Account Google: 

      gcloud auth application-default login

    Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale nella documentazione sull'autenticazione di Google Cloud.

    REST

    Per utilizzare gli esempi di API REST in questa pagina in un ambiente di sviluppo locale, devi utilizzare le credenziali che fornisci a gcloud CLI.

    1. Installa Google Cloud CLI.

    2. Per initialize gcloud CLI, esegui questo comando: 

      gcloud init
    3. Aggiorna e installa i componenti di gcloud: 
      gcloud components update
      gcloud components install beta
  9. Per utilizzare l'SDK Python, segui le istruzioni riportate in Installare l'SDK Vertex AI per Python. Per maggiori informazioni, consulta la documentazione di riferimento dell'SDK Vertex AI per l'API Python.
  10. Facoltativo. Consulta i pricing per questa funzionalità. I prezzi degli incorporamenti dipendono dal tipo di dati inviati (come immagine o testo) e dalla modalità utilizzata per determinati tipi di dati (ad esempio Video Plus, Video Standard o Video Essential).

Località

Una località è una regione che puoi specificare in una richiesta per controllare dove sono archiviati i dati at-rest. Per un elenco delle regioni disponibili, consulta Generative AI on Vertex AI località.

Messaggi di errore

Errore di superamento quota

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 è la prima volta che ricevi questo errore, utilizza la console Google Cloud per richiedere un aumento della quota per il tuo progetto. Utilizza i seguenti filtri prima di richiedere l'aumento:

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

Vai a Quote

Se hai già inviato una richiesta di aumento della quota, attendi prima di inviare un'altra richiesta. Se hai bisogno di aumentare ulteriormente la quota, ripeti la richiesta di aumento della quota con la tua giustificazione per una richiesta di quota sostenuta.

Specifica incorporamenti con dimensioni inferiori

Per impostazione predefinita, una richiesta di incorporamento restituisce un vettore float 1408 per un tipo di dati. Puoi anche specificare incorporamenti con dimensioni inferiori (128, 256 o 512 vettori mobili) per i dati di testo e di immagine. Questa opzione consente di ottimizzare latenza e archiviazione o qualità in base a come prevedi di utilizzare gli incorporamenti. Gli incorporamenti di dimensioni inferiori offrono meno esigenze di archiviazione e minore latenza per attività di incorporamento successive (come ricerca o suggerimenti), mentre gli incorporamenti di dimensioni più elevate offrono una maggiore precisione per le stesse attività.

REST

Per accedere a dimensioni ridotte, aggiungi il campo parameters.dimension. Il parametro accetta uno dei seguenti valori: 128, 256, 512 o 1408. La risposta include l'incorporamento di quella dimensione.

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.
  • 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"
}
[...]
  • TEXT: il testo di destinazione per cui ricevere gli incorporamenti. Ad esempio, a cat.
  • EMBEDDING_DIMENSION: il numero di dimensioni di incorporamento. Valori più bassi offrono una minore latenza quando si utilizzano questi incorporamenti per attività successive, mentre i valori più alti offrono una maggiore precisione. Valori disponibili: 128, 256, 512 e 1408 (valore predefinito).

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": [
    {
      "image": {
        "gcsUri": "IMAGE_URI"
      },
      "text": "TEXT"
    }
  ],
  "parameters": {
    "dimension": EMBEDDING_DIMENSION
  }
}

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 del modello restituisce un vettore mobile della dimensione specificata. Le seguenti risposte di esempio sono abbreviate per lo spazio.

128 dimensioni:

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

256 dimensioni:

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

Dimensioni 512:

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

Invia una richiesta di incorporamento (immagine e testo)

Utilizza i seguenti esempi di codice per inviare una richiesta di incorporamento con dati di immagini e testo. Gli esempi mostrano come inviare una richiesta con entrambi i tipi di dati, ma puoi anche utilizzare il servizio con un singolo tipo di dati.

Ottieni incorporamenti di testo e immagini

REST

Per maggiori informazioni sulle richieste del modello multimodalembedding, consulta Riferimento API del modello multimodalembedding.

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.
  • B64_ENCODED_IMG: l'immagine di destinazione per cui ricevere gli incorporamenti. L'immagine deve essere specificata come una stringa di byte codificata in Base64.

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

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

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


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

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

Invia una richiesta di incorporamento (video, immagine o testo)

Quando invii una richiesta di incorporamento, puoi specificare solo un video di input oppure una combinazione di dati video, immagine e testo.

Modalità di incorporamento dei video

Esistono tre modalità che puoi utilizzare con gli incorporamenti video: Essential, Standard o Plus. La modalità corrisponde alla densità degli incorporamenti generati, che può essere specificata dalla configurazione interval_sec nella richiesta. Per ogni intervallo video di durata pari a interval_sec, viene generato un incorporamento. La durata minima dell'intervallo video è di 4 secondi. Le durate degli intervalli superiori a 120 secondi potrebbero influire negativamente sulla qualità degli incorporamenti generati.

I prezzi dell'incorporamento dei video dipendono dalla modalità utilizzata. Per ulteriori informazioni, consulta la sezione relativa ai pricing.

La seguente tabella riassume le tre modalità che puoi utilizzare per gli incorporamenti dei video:

Modalità Numero massimo di incorporamenti al minuto Intervallo di incorporamento del video (valore minimo)
Essential 4 15

Corrisponde a: intervalSec >= 15
Standard 8 8

Corrisponde a: 8 <= intervalSec < 15
Plus 15 4

Corrisponde a: 4 <= intervalSec < 8

Best practice per gli incorporamenti dei video

Tieni presente quanto segue quando invii richieste di incorporamento dei video:

  • Per generare un singolo incorporamento per i primi due minuti di un video di input di qualsiasi durata, utilizza la seguente impostazione videoSegmentConfig:

    request.json:

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

  • Per generare l'incorporamento per un video di durata superiore a due minuti, puoi inviare più richieste che specificano l'ora di inizio e di fine in 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

Visualizza gli incorporamenti dei video

Utilizza il seguente esempio per ottenere gli incorporamenti solo per i contenuti video.

REST

Per maggiori informazioni sulle richieste del modello multimodalembedding, consulta Riferimento API del modello multimodalembedding.

L'esempio seguente utilizza un video situato 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.
  • 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": [
    {
      "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. Le seguenti risposte di esempio sono abbreviate per lo spazio.

Risposta (video di 7 secondi, nessun videoSegmentConfig specificato):

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

Risposta (video di 59 secondi, con la seguente configurazione del segmento video: "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

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

Ottieni incorporamenti di immagini, testo e video

Utilizza il seguente esempio per ottenere incorporamenti per contenuti video, di testo e di immagini.

REST

Per maggiori informazioni sulle richieste del modello multimodalembedding, consulta Riferimento API del modello multimodalembedding.

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

Passaggi successivi