Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Set di dati multimodali

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

Puoi caricare set di dati da BigQuery, DataFrame o file JSONL in Cloud Storage.
Crea il set di dati una volta e utilizzalo in diversi tipi di job, come il fine-tuning supervisionato e la previsione in batch, per evitare la duplicazione dei dati e problemi di formattazione.
Conserva tutti i tuoi 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, aiutandoti a rilevare gli errori e a 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 solo per una singola modalità.
I set di dati multimodali possono essere utilizzati solo per i servizi di AI generativa su Agent Platform, ad esempio l'ottimizzazione e la previsione in batch con i 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, che vengono utilizzati per visualizzare l'anteprima dei dati, convalidare le richieste e stimare i costi.
I set di dati multimodali vengono archiviati in BigQuery, che è ottimizzato per set di dati di grandi dimensioni.

Prima di iniziare

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 senza costi per l'esecuzione, il test e il deployment dei workload.

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, if any are not already enabled.

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, if any are not already enabled.

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 DataFrame Pandas

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

da un 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 allega 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. Questo è necessario per eseguire un job di ottimizzazione o di previsioni in batch.

SDK Agent Platform

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

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. Il seguente esempio di codice include anche un codice commentato facoltativo per specificare un field_mapping, che consente di utilizzare un nome 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"},
    ),
)

Collegalo al set di dati e mantieni 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, questa è l'origine bigquery_uri. Per i set di dati creati da altre origini, come JSONL o DataFrame, si tratta della tabella BigQuery in cui sono stati copiati i dati.
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 eseguire l'override del 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 tuo 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	margherita

Poi, 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 il assess_tuning_validity(). Per impostazione predefinita, viene utilizzata la configurazione di lettura collegata del set di dati, ma puoi passare un gemini_request_read_config per eseguire l'override del 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-3.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-3.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 il assess_tuning_resources().

# Resource estimation for tuning.
tuning_resources = client.datasets.assess_tuning_resources(
    dataset_name=my_dataset.name,
    model_name="gemini-3.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-3.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. Il set di dati deve avere una configurazione di lettura allegata.

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-3.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 saperne di più, consulta Crea 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 il assess_batch_prediction_validity(). Per impostazione predefinita, viene utilizzata la configurazione di lettura collegata del set di dati, ma puoi passare un gemini_request_read_config per eseguire l'override del 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-3.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-3.5-flash",
  }
}'

(Facoltativo) Stima l'utilizzo delle risorse

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

SDK Agent Platform

Chiama il assess_batch_prediction_resources().

batch_prediction_resources = client.datasets.assess_batch_prediction_resources(
    dataset_name=my_dataset.name,
    model_name="gemini-3.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-3.5-flash"
  }
}'

Esegui il job di previsione in batch

Puoi utilizzare il tuo set di dati multimodale per eseguire previsioni in batch passando il BigQuerytable_id 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-3.5-flash",
    src=f"bq://{table_id}",
)

Per saperne di più, consulta Richiedi 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 tuo set di dati multimodale, ti viene addebitato il costo per l'archiviazione e l'esecuzione di query sui set di dati multimodali in BigQuery. In particolare, le seguenti operazioni utilizzano i servizi sottostanti:

Create set di dati
- I set di dati creati da una tabella BigQuery o un DataFrame esistente non comportano costi di archiviazione aggiuntivi. Questo perché utilizziamo una vista logica anziché archiviare un'altra copia dei dati.
- I set di dati creati da altre origini copiano i dati in una nuova tabella BigQuery, il che comporta costi di archiviazione in BigQuery. Ad esempio, l'archiviazione logica attiva costa 0,02 $per GiB al mese.
Assemble set di dati
- Questo metodo crea una nuova tabella BigQuery che contiene il set di dati completo nel formato della richiesta del modello, il 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 delle query in BigQuery. Ad esempio, il prezzo del computing on demand è di 6, 25 $ per TiB.
Assess legge il set di dati una volta, il che comporta costi di query in BigQuery. Ad esempio, il prezzo del computing on demand è di 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 allega 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