Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Set di dati multimodali

I set di dati multimodali su Agent Platform consentono di creare, gestire, condividere e utilizzare set di dati multimodali per l'AI generativa. I set di dati multimodali forniscono le seguenti funzionalità principali:

Puoi caricare set di dati da BigQuery, DataFrame o file JSONL in Cloud Storage.
Crea il set di dati una sola volta e utilizzalo in diversi tipi di job, come l'ottimizzazione supervisionata e la previsione in batch, il che impedisce la duplicazione dei dati e i problemi di formattazione.
Mantieni tutti i set di dati di AI generativa in un'unica posizione gestita.
Convalida lo schema e la struttura e quantifica le risorse necessarie per le attività downstream, in modo da rilevare gli errori e stimare il costo prima di iniziare un'attività.

Puoi utilizzare i set di dati multimodali tramite l'SDK Agent Platform o l'API REST.

I set di dati multimodali sono un tipo di set di dati gestiti su Agent Platform. Si differenziano dagli altri tipi di set di dati gestiti nei seguenti modi:

I set di dati multimodali possono includere dati di qualsiasi modalità (testo, immagini, audio, video). Altri tipi di set di dati gestiti sono destinati a una sola modalità.
I set di dati multimodali possono essere utilizzati solo per i servizi di AI generativa su Agent Platform, come l'ottimizzazione e la previsione in batch con modelli generativi. Altri tipi di set di dati gestiti possono essere utilizzati solo per i modelli predittivi di Agent Platform.
I set di dati multimodali supportano metodi aggiuntivi, come assemble e assess, utilizzati per visualizzare l'anteprima dei dati, convalidare le richieste e stimare i costi.
I set di dati multimodali vengono archiviati in BigQuery, ottimizzato per set di dati di grandi dimensioni.

Prima di iniziare

Accedi al tuo Google Cloud account. 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 senza costi per l'esecuzione, il test e il deployment dei carichi di lavoro.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Agent Platform, BigQuery, and Cloud Storage APIs.

Roles required to enable APIs

To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

Enable the APIs

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Agent Platform, BigQuery, and Cloud Storage APIs.

Roles required to enable APIs

Enable the APIs

Installa e inizializza l'SDK Agent Platform per Python

Importa le seguenti librerie e crea un client:

import agentplatform
from agentplatform.types import (
    GeminiExample,
    GeminiRequestReadConfig,
    GeminiTemplateConfig,
)

# To use related features, such as tuning and batch prediction, you may also
# need to import the Google Gen AI SDK:
from google import genai
from google.genai.types import Content, Part

# Create a client for multimodal dataset operations.
client = agentplatform.Client(project="PROJECT_ID", location="LOCATION")

Crea un set di dati

Puoi creare un dataset multimodale da diverse origini:

da un oggetto DataFrame Pandas,

my_dataset = client.datasets.create_from_pandas(
    dataframe=my_dataframe,
    target_table_id=table_id    # optional
)

da un oggetto DataFrame BigQuery:

my_dataset = client.datasets.create_from_bigframes(
    dataframe=my_dataframe,
    target_table_id=table_id    # optional
)

da una tabella BigQuery

my_dataset_from_bigquery = client.datasets.create_from_bigquery(
    bigquery_uri="bq://projectId.datasetId.tableId"
)

da una tabella BigQuery, utilizzando l'API REST

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
"https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT/locations/LOCATION/datasets" \
-d '{
  "display_name": "TestDataset",
  "metadataSchemaUri": "gs://google-cloud-aiplatform/schema/dataset/metadata/multimodal_1.0.0.yaml",
  "metadata": {
    "inputConfig": {
      "bigquery_source": {
        "uri": "bq://projectId.datasetId.tableId"
      }
    }
  }
}'

da un file JSONL in Cloud Storage. Nell'esempio seguente, il file JSONL contiene richieste già formattate per Gemini, quindi non è necessario alcun assemblaggio.
```
my_dataset = client.datasets.create_from_gemini_request_jsonl(
  gcs_uri = gcs_uri_of_jsonl_file,
)
```

da un set di dati multimodale esistente

# Load dataset based on its name. This accepts a full resource name or a
# dataset ID.
same_dataset = client.datasets.get_multimodal_dataset(name=dataset_name)

Crea e collega una configurazione di lettura

Una configurazione di lettura (GeminiRequestReadConfig) definisce come trasformare il set di dati multimodale in un formato che può essere passato al modello. Contiene un modello con segnaposto che vengono sostituiti con i valori delle colonne del set di dati corrispondenti durante l'assemblaggio. Questa operazione è necessaria per eseguire un job di ottimizzazione o di previsione in batch.

SDK Agent Platform

Crea una configurazione di lettura. Esistono due modi per crearne una:

Utilizza il metodo helper GeminiRequestReadConfig.single_turn_template:

read_config = GeminiRequestReadConfig.single_turn_template(
        prompt="This is the image: {image_uris}",
        response="{labels}",
        system_instruction='You are a botanical image classifier. Analyze the provided image '
                'and determine the most accurate classification of the flower.'
                'These are the only flower categories: [\'daisy\', \'dandelion\', \'roses\', \'sunflowers\', \'tulips\'].'
                'Return only one category per image.'
)

Crea manualmente una configurazione di lettura da un GeminiExample, che consente una granularità più precisa, ad esempio conversazioni a più turni. L'esempio di codice seguente include anche codice commentato facoltativo per specificare un field_mapping, che consente di utilizzare un nome di segnaposto diverso dal nome della colonna del set di dati. Ad esempio:

# Define a GeminiExample
gemini_example = GeminiExample(
  contents=[
      Content(role="user", parts=[Part.from_text(text="This is the image: {image_uris}")]),
      Content(role="model", parts=[Part.from_text(text="This is the flower class: {label}.")]),
      Content(role="user", parts=[Part.from_text(text="Your response should only contain the class label.")]),
      Content(role="model", parts=[Part.from_text(text="{label}")]),

      # Optional: If you specify a field_mapping, you can use different placeholder values. For example:
      # Content(role="user", parts=[Part.from_text(text="This is the image: {uri_placeholder}")]),
      # Content(role="model", parts=[Part.from_text(text="This is the flower class: {flower_placeholder}.")]),
      # Content(role="user", parts=[Part.from_text(text="Your response should only contain the class label.")]),
      # Content(role="model", parts=[Part.from_text(text="{flower_placeholder}")]),
  ],
  system_instruction=Content(
      parts=[
          Part.from_text(
              text='You are a botanical image classifier. Analyze the provided image '
              'and determine the most accurate classification of the flower.'
              'These are the only flower categories: [\'daisy\', \'dandelion\', \'roses\', \'sunflowers\', \'tulips\'].'
              'Return only one category per image.'
          )
      ]
  ),
)

# Construct the read config, specifying a map for the placeholders.
read_config = GeminiRequestReadConfig(
    template_config=GeminiTemplateConfig(
        gemini_example=gemini_example,

        # Optional: Map the template placeholders to the column names of your dataset.
        # Not required if the template placeholders are column names of the dataset.
        # field_mapping={"uri_placeholder": "image_uris", "flower_placeholder": "labels"},
    ),
)

Collega la configurazione al set di dati e rendi permanente la modifica:

my_dataset.set_read_config(read_config=read_config)
my_dataset = client.datasets.update_multimodal_dataset(multimodal_dataset=my_dataset)

REST

Chiama il metodo patch e aggiorna il campo metadata con quanto segue:

L'URI della tabella BigQuery. Per i set di dati creati da una tabella BigQuery, questo è il tuo bigquery_uri di origine. Per i set di dati creati da altre origini, come JSONL o DataFrame, questa è la tabella BigQuery in cui sono stati copiati i dati.
Un gemini_template_config.

curl -X PATCH \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
-d $'{
  "metadata": {
    "input_config": {
      "bigquery_source": {
        "uri": "bq://projectId.datasetId.tableId"
      }
    },
    "gemini_template_config_source": {
      "gemini_template_config": {
        "gemini_example": {
          "contents": [
            {
              "role": "user",
              "parts": [
                {
                  "text": "This is the image: {image_uris}"

                }
              ]
            },
            {
              "role": "model",
              "parts": [
                {
                  "text": "response"
                }
              ]
            }
          ]
        "systemInstruction": {
            "parts": [
                {
                    "text": "You are a botanical image classifier."
                }
            ]
          }
        }
      }
    }
  }
}' \
"https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID?updateMask=metadata"

(Facoltativo) Assembla il set di dati

Il metodo assemble applica la configurazione di lettura per trasformare il set di dati e archivia l'output in una nuova tabella BigQuery. In questo modo puoi visualizzare l'anteprima dei dati prima che vengano passati al modello.

Per impostazione predefinita, viene utilizzata la configurazione di lettura collegata al set di dati, ma puoi passare un gemini_request_read_config per sostituire il comportamento predefinito.

SDK Agent Platform

Il metodo assemble restituisce una tupla (table_id, dataframe). Passa load_dataframe=True per caricare anche la tabella assemblata come DataFrame per l'ispezione.

table_id, assembly = client.datasets.assemble(
    name=my_dataset.name,
    gemini_request_read_config=read_config,    # optional if attached to the dataset
    load_dataframe=True,
)

# Inspect the results
assembly.head()

REST

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
"https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID:assemble" \
-d '{}'

Ad esempio, supponiamo che il set di dati multimodale contenga i seguenti dati:

Riga	image_uris	etichette
1	gs://cloud-samples-data/ai-platform/flowers/daisy/1396526833_fb867165be_n.jpg	margherite

Il metodo assemble crea una nuova tabella BigQuery con il nome table_id in cui ogni riga contiene il corpo della richiesta. Ad esempio:

{
  "contents": [
    {
      "parts": [
        {
          "text": "This is the image: "
        },
        {
          "fileData": {
            "fileUri": "gs://cloud-samples-data/ai-platform/flowers/daisy/1396526833_fb867165be_n.jpg",
            "mimeType": "image/jpeg"
          }
        }
      ],
      "role": "user"
    },
    {
      "parts": [
        {
          "text": "daisy"
        }
      ],
      "role": "model"
    }
  ],
  "systemInstruction": {
    "parts": [
      {
        "text": "You are a botanical image classifier. Analyze the provided image and determine the most accurate classification of the flower.These are the only flower categories: ['daisy', 'dandelion', 'roses', 'sunflowers', 'tulips'].Return only one category per image."
      }
    ]
  }
}

Ottimizza il modello

Puoi ottimizzare i modelli Gemini utilizzando un set di dati multimodale.

(Facoltativo) Convalida il set di dati

Valuta il set di dati per verificare se contiene errori, ad esempio errori di formattazione del set di dati o errori del modello.

SDK Agent Platform

Chiama assess_tuning_validity(). Per impostazione predefinita, viene utilizzata la configurazione di lettura collegata al set di dati, ma puoi passare un gemini_request_read_config per sostituire il comportamento predefinito.

# Attach the read configuration to the dataset.
my_dataset.set_read_config(read_config=read_config)
my_dataset = client.datasets.update_multimodal_dataset(multimodal_dataset=my_dataset)

# Validation for tuning
validation = client.datasets.assess_tuning_validity(
    dataset_name=my_dataset.name,
    model_name="gemini-2.5-flash",
    dataset_usage="SFT_TRAINING"
)

# Inspect validation result
validation.errors

REST

Chiama il metodo assess e fornisci un TuningValidationAssessmentConfig.

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
"https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID:assess" \
-d '{
  "tuningValidationAssessmentConfig": {
    "modelName": "projects/PROJECT_ID/locations/LOCATION/models/gemini-2.5-flash",
    "datasetUsage": "SFT_TRAINING"
  }
}'

(Facoltativo) Stima l'utilizzo delle risorse

Valuta il set di dati per ottenere il conteggio dei token e dei caratteri fatturabili per il job di ottimizzazione.

SDK Agent Platform

Chiama assess_tuning_resources().

# Resource estimation for tuning.
tuning_resources = client.datasets.assess_tuning_resources(
    dataset_name=my_dataset.name,
    model_name="gemini-2.5-flash"
)

print(tuning_resources)
# For example, TuningResourceUsageAssessmentResult(token_count=362688, billable_character_count=122000)

REST

Chiama il metodo assess e fornisci un TuningResourceUsageAssessmentConfig.

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
"https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID:assess" \
-d '{
  "tuningResourceUsageAssessmentConfig": {
    "modelName": "projects/PROJECT_ID/locations/LOCATION/models/gemini-2.5-flash"
  }
}'

Esegui il job di ottimizzazione

Utilizza l'SDK Google Gen AI per avviare un job di ottimizzazione, passando il nome della risorsa del set di dati multimodale. Al set di dati deve essere collegata una configurazione di lettura.

SDK Google Gen AI

from google import genai
from google.genai.types import HttpOptions, CreateTuningJobConfig

genai_client = genai.Client(http_options=HttpOptions(api_version="v1"))

tuning_job = genai_client.tunings.tune(
  base_model="gemini-2.5-flash",
  # Pass the resource name of the Multimodal Dataset, not the dataset object
  training_dataset={
      "vertex_dataset_resource": my_multimodal_dataset.name
  },
  # Optional
  config=CreateTuningJobConfig(
      validation_dataset={
          "vertex_dataset_resource": my_multimodal_validation_dataset.name
      },
      tuned_model_display_name="Example tuning job"),
)

Per ulteriori informazioni, vedi Creare un job di ottimizzazione.

Previsione in batch

Puoi ottenere previsioni in batch utilizzando un set di dati multimodale.

(Facoltativo) Convalida il set di dati

Valuta il set di dati per verificare se contiene errori, ad esempio errori di formattazione del set di dati o errori del modello.

SDK Agent Platform

Chiama assess_batch_prediction_validity(). Per impostazione predefinita, viene utilizzata la configurazione di lettura collegata al set di dati, ma puoi passare un gemini_request_read_config per sostituire il comportamento predefinito.

# Attach the read configuration to the dataset.
my_dataset.set_read_config(read_config=read_config)
my_dataset = client.datasets.update_multimodal_dataset(multimodal_dataset=my_dataset)

# Validation for batch prediction
validation = client.datasets.assess_batch_prediction_validity(
    dataset_name=my_dataset.name,
    model_name="gemini-2.5-flash"
)

# Inspect validation result
validation.errors

REST

Chiama il metodo assess e fornisci un batchPredictionValidationAssessmentConfig.

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
"https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID:assess" \
-d '{
  "batchPredictionValidationAssessmentConfig": {
    "modelName": "projects/PROJECT_ID/locations/LOCATION/models/gemini-2.5-flash",
  }
}'

(Facoltativo) Stima l'utilizzo delle risorse

Valuta il set di dati per ottenere il conteggio dei token per il job.

SDK Agent Platform

Chiama assess_batch_prediction_resources().

batch_prediction_resources = client.datasets.assess_batch_prediction_resources(
    dataset_name=my_dataset.name,
    model_name="gemini-2.5-flash"
)

print(batch_prediction_resources)
# For example, BatchPredictionResourceUsageAssessmentResult(token_count=362688, audio_token_count=122000)

REST

Chiama il metodo assess e fornisci un batchPredictionResourceUsageAssessmentConfig.

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
"https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID:assess" \
-d '{
  "batchPredictionResourceUsageAssessmentConfig": {
    "modelName": "projects/PROJECT_ID/locations/LOCATION/models/gemini-2.5-flash"
  }
}'

Esegui il job di previsione in batch

Puoi utilizzare il set di dati multimodale per eseguire la previsione in batch passando il table_id BigQuery dell'output assemblato:

SDK Google Gen AI

from google import genai
from google.genai.types import HttpOptions

# Attach the read configuration to the dataset.
my_dataset.set_read_config(read_config=read_config)
my_dataset = client.datasets.update_multimodal_dataset(multimodal_dataset=my_dataset)

# Assemble the dataset to get the assembled BigQuery table.
table_id, _ = client.datasets.assemble(name=my_dataset.name)

genai_client = genai.Client(http_options=HttpOptions(api_version="v1"))

job = genai_client.batches.create(
    model="gemini-2.5-flash",
    src=f"bq://{table_id}",
)

Per ulteriori informazioni, vedi Richiedere un job di previsione in batch.

Limitazioni

I set di dati multimodali possono essere utilizzati solo con le funzionalità di AI generativa. Non possono essere utilizzati con funzionalità di AI non generativa come l'addestramento AutoML e l'addestramento personalizzato.
I set di dati multimodali possono essere utilizzati solo con i modelli Google come Gemini. Non possono essere utilizzati con modelli di terze parti.

Prezzi

Quando ottimizzi un modello o esegui un job di previsione in batch, ti vengono addebitati i costi per l'utilizzo dell'AI generativa e per l'esecuzione di query sul set di dati in BigQuery.

Quando crei, assembli o valuti il set di dati multimodale, ti vengono addebitati i costi per l'archiviazione e l'esecuzione di query sui set di dati multimodali in BigQuery. Nello specifico, le seguenti operazioni utilizzano questi servizi sottostanti:

Set di dati Create
- I set di dati creati da una tabella BigQuery o da un DataFrame esistenti non comportano costi di archiviazione aggiuntivi. Questo perché utilizziamo una visualizzazione logica anziché archiviare un'altra copia dei dati.
- I set di dati creati da altre origini copiano i dati in una nuova tabella BigQuery, che comporta costi di archiviazione in BigQuery. Ad esempio, l'archiviazione logica attiva costa 0,02 $per GiB al mese.
Set di dati Assemble
- Questo metodo crea una nuova tabella BigQuery che contiene l'intero set di dati nel formato della richiesta del modello, che comporta costi di archiviazione in BigQuery. Ad esempio, l'archiviazione logica attiva costa 0,02 $per GiB al mese.
- Questo metodo legge anche il set di dati una volta, il che comporta costi di query in BigQuery. Ad esempio, il calcolo on demand nei prezzi costa 6, 25 $ per TiB.
Assess legge il set di dati una volta, il che comporta costi di query in BigQuery. Ad esempio, il calcolo on demand nei prezzi costa 6, 25 $ per TiB.

Utilizza il Calcolatore prezzi per generare una stima dei costi in base all'utilizzo previsto.

Set di dati multimodali Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Prima di iniziare

Crea un set di dati

Crea e collega una configurazione di lettura

SDK Agent Platform

REST

(Facoltativo) Assembla il set di dati

SDK Agent Platform

REST

Ottimizza il modello

(Facoltativo) Convalida il set di dati

SDK Agent Platform

REST

(Facoltativo) Stima l'utilizzo delle risorse

SDK Agent Platform

REST

Esegui il job di ottimizzazione

SDK Google Gen AI

Previsione in batch

(Facoltativo) Convalida il set di dati

SDK Agent Platform

REST

(Facoltativo) Stima l'utilizzo delle risorse

SDK Agent Platform

REST

Esegui il job di previsione in batch

SDK Google Gen AI

Limitazioni

Prezzi

Set di dati multimodali