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

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 o conjunto de dados uma vez e use-o em diferentes tipos de jobs, como ajuste supervisionado e previsão em lote, o que evita a duplicação de dados e problemas de formatação.
Mantenha todos os conjuntos de dados de IA generativa em um único local gerenciado.
Valide o esquema e a estrutura e quantifique os recursos necessários para tarefas downstream, ajudando a detectar erros e estimar o custo antes de iniciar uma tarefa.

É possível usar conjuntos de dados multimodais pelo SDK da Agent Platform ou pela API REST.

Os conjuntos de dados multimodais são um tipo de conjuntos de dados gerenciados 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 apenas para uma única modalidade.
Os conjuntos de dados multimodais só podem ser usados para serviços de IA generativa na Agent Platform, como ajuste e previsã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 oferecem suporte a 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 Google Cloud conta do. Se você começou a usar o Google Cloud, 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.

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 Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. 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

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

Instale e inicialize o SDK da Agent Platform para Python.

Importe as bibliotecas a seguir 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")

crie 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 DataFrame do BigQuery:

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. Portanto, nenhuma montagem é necessária.
```
my_dataset = client.datasets.create_from_gemini_request_jsonl(
  gcs_uri = gcs_uri_of_jsonl_file,
)
```

de um conjunto de dados multimodal existente

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

Construir 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 que são substituídos pelos valores das colunas do conjunto de dados correspondente durante a montagem. Isso é necessário para executar um job de ajuste ou previsão em lote.

SDK da plataforma de agentes

Construa uma configuração de leitura. Há duas maneiras de construir uma:

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

Construa manualmente uma configuração de leitura de um GeminiExample, que permite uma granularidade mais refinada, como conversas de várias rodadas. 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 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 persista a mudança:

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

REST

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

O URI da tabela do BigQuery. Para conjuntos de dados criados em uma tabela do BigQuery, esse é o bigquery_uri de origem. Para conjuntos de dados criados de outras fontes, como JSONL ou DataFrame, essa é a tabela do BigQuery em que os dados foram copiados.
Um 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 visualizar os dados antes que eles sejam transmitidos ao modelo.

Por padrão, a configuração de leitura anexada do conjunto de dados é usada, mas é possível transmitir um gemini_request_read_config para substituir 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 o 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 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 erros de modelo.

SDK da plataforma de agentes

Chame assess_tuning_validity(). Por padrão, a configuração de leitura anexada do conjunto de dados é usada, mas é possível transmitir um gemini_request_read_config para substituir 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-2.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-2.5-flash",
    "datasetUsage": "SFT_TRAINING"
  }
}'

(Opcional) Estimar o uso de recursos

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

SDK da plataforma de agentes

Chame 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

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

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

Previsão em lote

É possível receber previsõ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 erros de modelo.

SDK da plataforma de agentes

Chame assess_batch_prediction_validity(). Por padrão, a configuração de leitura anexada do conjunto de dados é usada, mas é possível transmitir um gemini_request_read_config para substituir 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-2.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-2.5-flash",
  }
}'

(Opcional) Estimar o uso de recursos

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

SDK da plataforma de agentes

Chame 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

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-2.5-flash"
  }
}'

Executar o job de previsão em lote

É possível usar o conjunto de dados multimodal para fazer a previsão 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-2.5-flash",
    src=f"bq://{table_id}",
)

Para mais informações, consulte Solicitar um job de previsã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 treinamento do AutoML e 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 previsão em lote, você recebe uma cobrança pelo uso da IA generativa e pela consulta do conjunto de dados no BigQuery.

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

Conjunto de dados Create
- Os conjuntos de dados criados em uma tabela ou 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.
Conjunto de dados Assemble
- Esse método cria uma nova tabela do BigQuery que contém o conjunto de dados completo no formato de solicitação do 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

crie um conjunto de dados

Construir 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 previsão em lote

SDK de IA Generativa do Google

Limitações

Preços

Conjuntos de dados multimodais