Conjuntos de dados multimodais

Para conferir um exemplo de conjuntos de dados multimodais, execute o notebook "Prévia do conjunto de dados multimodal da Vertex AI" em um dos seguintes ambientes:

Abrir no Colab | Abrir no Colab Enterprise | Abrir no Vertex AI Workbench | Ver no GitHub

Pré-lançamento

Este recurso está sujeito aos Termos das Soluções Pré-GA na seção Termos Gerais de Serviço dos Termos Específicos de Serviço. Os recursos pré-GA estão disponíveis no estado em que se encontram e podem ter suporte limitado. Você encontra mais detalhes nas descrições das fases de lançamento.

Com os conjuntos de dados multimodais na Vertex AI, é possível criar, gerenciar, compartilhar e usar conjuntos de dados multimodais para a 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 jobs, como ajuste fino supervisionado e previsão em lote, o que evita problemas de duplicação e formatação de dados.

• Mantenha todos os seus conjuntos de dados de IA generativa em um único local gerenciado.

• Valide seu esquema e estrutura e quantifique os recursos necessários para tarefas downstream, ajudando você a detectar erros e estimar o custo antes de iniciar uma tarefa.

É possível usar conjuntos de dados multimodais com o SDK da Vertex AI para Python ou a API REST.

Os conjuntos de dados multimodais são um tipo de conjuntos de dados gerenciados na Vertex AI. 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 Vertex AI, 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 Vertex AI.
• 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

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Vertex AI, BigQuery, and Cloud Storage APIs.

Enable the APIs

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

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Vertex AI, BigQuery, and Cloud Storage APIs.

Enable the APIs

1. Instalar e inicializar o SDK da Vertex AI para Python
2. Importe as bibliotecas a seguir:

   from google.cloud.aiplatform.preview import datasets
   
   # To use related features, you may also need to import some of the following features:
   from vertexai.preview.tuning import sft
   from vertexai.batch_prediction import BatchPredictionJob
   
   from vertexai.generative_models import Content, Part, Tool, ToolConfig, SafetySetting, GenerationConfig, FunctionDeclaration
   

crie um conjunto de dados

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

• de um DataFrame do Pandas

  my_dataset = datasets.MultimodalDataset.from_pandas(
      dataframe=my_dataframe,
      target_table_id=table_id    # optional
  )
  

• de um DataFrame do BigQuery:

  my_dataset = datasets.MultimodalDataset.from_bigframes(
      dataframe=my_dataframe,
      target_table_id=table_id    # optional
  )
  

• de uma tabela do BigQuery

  my_dataset_from_bigquery = datasets.MultimodalDataset.from_bigquery(
      bigquery_uri=f"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 já formatadas para o Gemini, então não é necessário fazer a montagem.

  my_dataset = datasets.MultimodalDataset.from_gemini_request_jsonl(
    gcs_uri = gcs_uri_of_jsonl_file,
  )
  

• de um conjunto de dados multimodais

  # Get the most recently created dataset
  first_dataset = datasets.MultimodalDataset.list()[0]
  
  # Load dataset based on its name
  same_dataset = datasets.MultimodalDataset(first_dataset.name)
  

Criar e anexar um modelo

Um modelo define como transformar o conjunto de dados multimodal em um formato que pode ser transmitido ao modelo. Isso é necessário para executar um job de ajuste ou previsão em lote.

SDK da Vertex AI para Python

1. Construa um modelo. Há duas maneiras de criar um modelo:

   • Use o método auxiliar construct_single_turn_template:

   template_config = datasets.construct_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 um modelo usando 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 = datasets.GeminiExample(
       contents=[
           Content(role="user", parts=[Part.from_text("This is the image: {image_uris}")]),
           Content(role="model", parts=[Part.from_text("This is the flower class: {label}.")]),
         Content(role="user", parts=[Part.from_text("Your response should only contain the class label.")]),
         Content(role="model", parts=[Part.from_text("{label}")]),
   
         # Optional: If you specify a field_mapping, you can use different placeholder values. For example:
         # Content(role="user", parts=[Part.from_text("This is the image: {uri_placeholder}")]),
         # Content(role="model", parts=[Part.from_text("This is the flower class: {flower_placeholder}.")]),
         # Content(role="user", parts=[Part.from_text("Your response should only contain the class label.")]),
         # Content(role="model", parts=[Part.from_text("{flower_placeholder}")]),
       ],
       system_instruction=Content(
           parts=[
               Part.from_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 template, specifying a map for the placeholder
   template_config = datasets.GeminiTemplateConfig(
       gemini_example=gemini_example,
   
       # Optional: Map the template placeholders to the column names of your dataset.
       # Not required if the template placesholders are column names of the dataset.
       # field_mapping={"uri_placeholder": "image_uris", "flower_placeholder": "labels"},
   )
   

2. Anexe ao conjunto de dados:

   my_dataset.attach_template_config(template_config=template_config)
   

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 é sua origem bigquery_uri. 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 o modelo para transformar seu conjunto de dados e armazena a saída em uma nova tabela do BigQuery. Assim, você pode visualizar os dados antes que eles sejam transmitidos ao modelo.

Por padrão, o template_config anexado ao conjunto de dados é usado, mas é possível especificar um modelo para substituir o comportamento padrão.

SDK da Vertex AI para Python

table_id, assembly = my_dataset.assemble(template_config=template_config)

# 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 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 Vertex AI para Python

Ligue para assess_tuning_validity(). Por padrão, o template_config anexado ao conjunto de dados é usado, mas é possível especificar um modelo para substituir o comportamento padrão.

# Attach template
my_dataset.attach_template_config(template_config=template_config)

# Validation for tuning
validation = my_dataset.assess_tuning_validity(
    model_name="gemini-2.0-flash-001",
    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.0-flash-001",
    "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 seu job de ajuste.

SDK da Vertex AI para Python

Ligue para assess_tuning_resources().

# Resource estimation for tuning.
tuning_resources = my_dataset.assess_tuning_resources(
    model_name="gemini-2.0-flash-001"
)

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.0-flash-001"
  }
}'

Executar o job de ajuste

SDK da Vertex AI para Python

from vertexai.tuning import sft

sft_tuning_job = sft.train(
  source_model="gemini-2.0-flash-001",
  # Pass the Vertex Multimodal Datasets directly
  train_dataset=my_multimodal_dataset,
  validation_dataset=my_multimodal_validation_dataset,
)

SDK do Google Gen AI

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

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

tuning_job = client.tunings.tune(
  base_model="gemini-2.0-flash-001",
  # Pass the resource name of the Vertex Multimodal Dataset, not the dataset object
  training_dataset={
      "vertex_dataset_resource": my_multimodal_dataset.resource_name
  },
  # Optional
  config=CreateTuningJobConfig(
      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 de modelo.

SDK da Vertex AI para Python

Ligue para assess_batch_prediction_validity(). Por padrão, o template_config anexado ao conjunto de dados é usado, mas é possível especificar um modelo para substituir o comportamento padrão.

# Attach template
my_dataset.attach_template_config(template_config=template_config)

# Validation for batch prediction
validation = my_dataset.assess_batch_prediction_validity(
    model_name="gemini-2.0-flash-001",
    dataset_usage="SFT_TRAINING"
)

# 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.0-flash-001",
  }
}'

(Opcional) Estimar o uso de recursos

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

SDK da Vertex AI para Python

Ligue para assess_batch_prediction_resources().

batch_prediction_resources = my_dataset.assess_batch_prediction_resources(
    model_name="gemini-2.0-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.0-flash-001"
  }
}'

Executar o job de previsão em lote

Você pode usar seu conjunto de dados multimodal para fazer previsões em lote transmitindo o BigQuerytable_id da saída montada:

SDK da Vertex AI para Python

from vertexai.batch_prediction import BatchPredictionJob

# Dataset needs to have an attached template_config to batch prediction
my_dataset.attach_template_config(template_config=template_config)

# assemble dataset to get assembly table id
assembly_table_id, _ = my_dataset.assemble()

batch_prediction_job = BatchPredictionJob.submit(
    source_model="gemini-2.0-flash-001",
    input_dataset=assembly_table_id,
)

SDK do Google Gen AI

from google import genai

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

# Attach template_config and assemble dataset
my_dataset.attach_template_config(template_config=template_config)
assembly_table_id, _ = my_dataset.assemble()

job = client.batches.create(
    model="gemini-2.0-flash-001",
    src=assembly_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. 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. 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 cobranças pelo uso da IA generativa e pela consulta do conjunto de dados no BigQuery.

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

• Create conjunto de dados

  • Os conjuntos de dados criados com base 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.

• Assemble conjunto de dados

  • Esse método cria uma 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. Validação de conjuntos de dados e estimativa de recursos

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