O Google usa tecnologia de IA na tradução de conteúdos para seu idioma de preferência. As traduções com IA podem ter erros.

Conjuntos de dados multimodais

Os conjuntos de dados multimodais na Agent Platform permitem criar, gerenciar, compartilhar e usar conjuntos de dados multimodais para IA generativa. Os conjuntos de dados multimodais oferecem os seguintes recursos principais:

É possível carregar conjuntos de dados do BigQuery, DataFrames ou arquivos JSONL no Cloud Storage.
Crie seu conjunto de dados uma vez e use-o em diferentes tipos de serviço, como ajuste supervisionado e predição em lote, o que evita a duplicação de dados e problemas de formatação.
Mantenha todos os seus conjuntos de dados de IA generativa em um único local gerenciado.
Valide o esquema e a estrutura e quantifique os recursos necessários para as tarefas downstream, o que ajuda a detectar erros e estimar o custo antes de iniciar uma tarefa.

É possível usar conjuntos de dados multimodais com o SDK da Agent Platform ou a API REST.

Os conjuntos de dados multimodais são um tipo de conjunto de dados gerenciado na Agent Platform. Eles são diferentes de outros tipos de conjuntos de dados gerenciados das seguintes maneiras:

Os conjuntos de dados multimodais podem incluir dados de qualquer modalidade (texto, imagem, áudio, vídeo). Outros tipos de conjuntos de dados gerenciados são para apenas uma modalidade.
Os conjuntos de dados multimodais só podem ser usados para serviços de IA generativa na Agent Platform, como ajuste e predição em lote com modelos generativos. Outros tipos de conjuntos de dados gerenciados só podem ser usados para modelos preditivos da Agent Platform.
Os conjuntos de dados multimodais são compatíveis com outros métodos, como assemble e assess, que são usados para visualizar dados, validar solicitações e estimar custos.
Os conjuntos de dados multimodais são armazenados no BigQuery, que é otimizado para conjuntos de dados grandes.

Antes de começar

Faça login na sua conta do Google Cloud . Se você começou a usar o Google Cloudagora, crie uma conta para avaliar o desempenho dos nossos produtos em situações reais. Clientes novos também recebem US $300 em créditos para executar, testar e implantar cargas de trabalho sem custos financeiros.

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

Instalar e inicializar o SDK da Plataforma de Agentes para Python

Importe as seguintes bibliotecas e crie um cliente:

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

Criar um conjunto de dados

É possível criar um dataset multimodal de diferentes fontes:

de um DataFrame do Pandas.

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

de um BigQuery DataFrame:

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

de uma tabela do BigQuery

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

de uma tabela do BigQuery usando a 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"
      }
    }
  }
}'

de um arquivo JSONL no Cloud Storage. No exemplo a seguir, o arquivo JSONL contém solicitações que já estão formatadas para o Gemini, então não é necessário fazer nenhuma montagem.
```
my_dataset = client.datasets.create_from_gemini_request_jsonl(
  gcs_uri = gcs_uri_of_jsonl_file,
)
```

de um conjunto de dados multimodal atual

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

Criar e anexar uma configuração de leitura

Uma configuração de leitura (GeminiRequestReadConfig) define como transformar o conjunto de dados multimodal em um formato que pode ser transmitido ao modelo. Ele contém um modelo com marcadores de posição que são substituídos pelos valores das colunas correspondentes do conjunto de dados durante a montagem. Isso é necessário para executar um job de ajuste ou de predição em lote.

SDK da plataforma de agentes

Crie uma configuração de leitura. Há duas maneiras de criar um:

Use o método auxiliar 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.'
)

Crie manualmente uma configuração de leitura de um GeminiExample, o que permite uma granularidade mais refinada, como conversas em vários turnos. O exemplo de código a seguir também inclui um código comentado opcional para especificar um field_mapping, que permite usar um nome de marcador de posição diferente do nome da coluna do conjunto de dados. Exemplo:

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

Anexe-o ao conjunto de dados e mantenha a alteração:

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

REST

Chame o método patch e atualize o campo metadata com o seguinte:

O URI da tabela do BigQuery. Para conjuntos de dados criados com base em uma tabela do BigQuery, essa é a bigquery_uri de origem. Para conjuntos de dados criados de outras fontes, como JSONL ou DataFrame, essa é a tabela do BigQuery em que seus dados foram copiados.
Uma 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"

(Opcional) Montar o conjunto de dados

O método assemble aplica a configuração de leitura para transformar o conjunto de dados e armazena a saída em uma nova tabela do BigQuery. Isso permite que você visualize os dados antes que eles sejam transmitidos ao modelo.

Por padrão, a configuração de leitura anexada ao conjunto de dados é usada, mas é possível transmitir um gemini_request_read_config para modificar o comportamento padrão.

SDK da plataforma de agentes

O método assemble retorna uma tupla (table_id, dataframe). Transmita load_dataframe=True para também carregar a tabela montada como um DataFrame para inspeção.

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

Por exemplo, suponha que seu conjunto de dados multimodal contenha os seguintes dados:

Linha	image_uris	rótulos
1	gs://cloud-samples-data/ai-platform/flowers/daisy/1396526833_fb867165be_n.jpg	margarida

Em seguida, o método assemble cria uma nova tabela do BigQuery com o nome table_id, em que cada linha contém o corpo da solicitação. Exemplo:

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

Ajustar o modelo

É possível ajustar os modelos do Gemini usando um conjunto de dados multimodal.

(Opcional) Validar o conjunto de dados

Avalie o conjunto de dados para verificar se ele contém erros, como erros de formatação ou de modelo.

SDK da plataforma de agentes

Ligue para assess_tuning_validity(). Por padrão, a configuração de leitura anexada ao conjunto de dados é usada, mas é possível transmitir um gemini_request_read_config para modificar o comportamento padrão.

# 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

Chame o método assess e forneça um 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"
  }
}'

(Opcional) Estimar o uso de recursos

Avalie o conjunto de dados para conferir a contagem de tokens e caracteres faturáveis do job de ajuste.

SDK da plataforma de agentes

Ligue para 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

Chame o método assess e forneça um 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"
  }
}'

Executar o job de ajuste

Use o SDK de IA generativa do Google para iniciar um job de ajuste, transmitindo o nome do recurso do conjunto de dados multimodal. O conjunto de dados precisa ter uma configuração de leitura anexada.

SDK de IA Generativa do Google

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

Para mais informações, consulte Criar um job de ajuste.

Previsão em lote

É possível receber predições em lote usando um conjunto de dados multimodal.

(Opcional) Validar o conjunto de dados

Avalie o conjunto de dados para verificar se ele contém erros, como erros de formatação ou de modelo.

SDK da plataforma de agentes

Ligue para assess_batch_prediction_validity(). Por padrão, a configuração de leitura anexada ao conjunto de dados é usada, mas é possível transmitir um gemini_request_read_config para modificar o comportamento padrão.

# 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

Chame o método assess e forneça um 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",
  }
}'

(Opcional) Estimar o uso de recursos

Avalie o conjunto de dados para conferir a contagem de tokens do job.

SDK da plataforma de agentes

Ligue para 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

Chame o método assess e forneça um 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"
  }
}'

Executar o job de predição em lote

É possível usar o conjunto de dados multimodal para fazer predições em lote transmitindo o table_id do BigQuery da saída montada:

SDK de IA Generativa do Google

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

Para mais informações, consulte Solicitar um job de predição em lote.

Limitações

Os conjuntos de dados multimodais só podem ser usados com recursos de IA generativa. Eles não podem ser usados com recursos de IA não generativa, como o treinamento do AutoML e o treinamento personalizado.
Os conjuntos de dados multimodais só podem ser usados com modelos do Google, como o Gemini. Eles não podem ser usados com modelos de terceiros.

Preços

Ao ajustar um modelo ou executar um job de predição em lote, você recebe uma cobrança pelo uso da IA generativa e pela consulta ao conjunto de dados no BigQuery.

Ao criar, montar ou avaliar seu conjunto de dados multimodal, você recebe uma cobrança pelo armazenamento e pela consulta de conjuntos de dados multimodais no BigQuery. Especificamente, as seguintes operações usam esses serviços:

Create conjunto de dados
- Os conjuntos de dados criados com base em uma tabela ou um DataFrame do BigQuery não geram custos de armazenamento adicionais. Isso ocorre porque usamos uma visualização lógica em vez de armazenar outra cópia dos dados.
- Os conjuntos de dados criados de outras fontes copiam os dados para uma nova tabela do BigQuery, o que gera custos de armazenamento no BigQuery. Por exemplo, armazenamento lógico ativo por US $0,02 por GiB por mês.
Assemble conjunto de dados
- Esse método cria uma nova tabela do BigQuery que contém o conjunto de dados completo no formato de solicitação de modelo, o que gera custos de armazenamento no BigQuery. Por exemplo, armazenamento lógico ativo por US $0,02 por GiB por mês.
- Esse método também lê o conjunto de dados uma vez, o que gera custos de consulta no BigQuery. Por exemplo, computação sob demanda em preços, US$ 6,25 por TiB.
Assess lê o conjunto de dados uma vez, o que gera custos de consulta no BigQuery. Por exemplo, computação sob demanda em preços, US$ 6,25 por TiB.

Use a calculadora de preços para gerar uma estimativa de custo com base no uso previsto.

Conjuntos de dados multimodais Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Antes de começar

Criar um conjunto de dados

Criar e anexar uma configuração de leitura

SDK da plataforma de agentes

REST

(Opcional) Montar o conjunto de dados

SDK da plataforma de agentes

REST

Ajustar o modelo

(Opcional) Validar o conjunto de dados

SDK da plataforma de agentes

REST

(Opcional) Estimar o uso de recursos

SDK da plataforma de agentes

REST

Executar o job de ajuste

SDK de IA Generativa do Google

Previsão em lote

(Opcional) Validar o conjunto de dados

SDK da plataforma de agentes

REST

(Opcional) Estimar o uso de recursos

SDK da plataforma de agentes

REST

Executar o job de predição em lote

SDK de IA Generativa do Google

Limitações

Preços

Conjuntos de dados multimodais