Los conjuntos de datos multimodales en Agent Platform te permiten crear, administrar, compartir y usar conjuntos de datos multimodales para la IA generativa. Los conjuntos de datos multimodales proporcionan las siguientes funciones clave:
Puedes cargar conjuntos de datos desde BigQuery, DataFrames o archivos JSONL en Cloud Storage.
Crea tu conjunto de datos una vez y úsalo en diferentes tipos de trabajos, como el ajuste supervisado y la predicción por lotes, lo que evita la duplicación de datos y los problemas de formato.
Mantén todos tus conjuntos de datos de IA generativa en una sola ubicación administrada.
Valida tu esquema y estructura, y cuantifica los recursos necesarios para las tareas posteriores, lo que te ayuda a detectar errores y estimar el costo antes de comenzar una tarea.
Puedes usar conjuntos de datos multimodales a través del SDK de Agent Platform o la API de REST.
Los conjuntos de datos multimodales son un tipo de conjuntos de datos administrados en Agent Platform. Se diferencian de otros tipos de conjuntos de datos administrados de las siguientes maneras:
- Los conjuntos de datos multimodales pueden incluir datos de cualquier modalidad (texto, imagen, audio, video). Otros tipos de conjuntos de datos administrados son solo para una sola modalidad.
- Los conjuntos de datos multimodales solo se pueden usar para los servicios de IA generativa en Agent Platform, como el ajuste y la predicción por lotes con modelos generativos. Otros tipos de conjuntos de datos administrados solo se pueden usar para los modelos predictivos de Agent Platform.
- Los conjuntos de datos multimodales admiten métodos adicionales, como
assembleyassess, que se usan para obtener una vista previa de los datos, validar solicitudes y estimar costos. - Los conjuntos de datos multimodales se almacenan en BigQuery, que está optimizado para conjuntos de datos grandes.
Antes de comenzar
- Accede a tu Google Cloud cuenta de. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.
-
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 theresourcemanager.projects.createpermission. Learn how to grant roles.
-
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 theserviceusage.services.enablepermission. Learn how to grant roles.-
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 theresourcemanager.projects.createpermission. Learn how to grant roles.
-
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 theserviceusage.services.enablepermission. Learn how to grant roles.- Instala e inicializa el SDK de Agent Platform para Python.
- Importa las siguientes bibliotecas:
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
Crea un conjunto de datos
Puedes crear un multimodal dataset a partir de diferentes fuentes:
a partir de un DataFrame de Pandas
my_dataset = datasets.MultimodalDataset.from_pandas( dataframe=my_dataframe, target_table_id=table_id # optional )a partir de un DataFrame de BigQuery:
my_dataset = datasets.MultimodalDataset.from_bigframes( dataframe=my_dataframe, target_table_id=table_id # optional )a partir de una tabla de BigQuery
my_dataset_from_bigquery = datasets.MultimodalDataset.from_bigquery( bigquery_uri=f"bq://projectId.datasetId.tableId" )a partir de una tabla de BigQuery, con la API de 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" } } } }'a partir de un archivo JSONL en Cloud Storage. En el siguiente ejemplo, el archivo JSONL contiene solicitudes que ya están formateadas para Gemini, por lo que no se requiere ningún ensamblaje.
my_dataset = datasets.MultimodalDataset.from_gemini_request_jsonl( gcs_uri = gcs_uri_of_jsonl_file, )a partir de un conjunto de datos multimodal existente
# 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)
Construye y adjunta una plantilla
Una plantilla define cómo transformar el conjunto de datos multimodal a un formato que se puede pasar al modelo. Esto es necesario para ejecutar un trabajo de ajuste o de predicción por lotes.
SDK de Agent Platform
Construye una plantilla. Existen dos formas de construir una plantilla:
- Usa el 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.' )- Construye manualmente una plantilla a partir de un
GeminiExample, que permite una granularidad más precisa, como conversaciones de varios turnos. En la siguiente muestra de código, también se incluye código comentado opcional para especificar unfield_mapping, que te permite usar un nombre de marcador de posición diferente del nombre de la columna del conjunto de datos. Por ejemplo:
# 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"}, )- Usa el método auxiliar
Adjúntala al conjunto de datos:
my_dataset.attach_template_config(template_config=template_config)
REST
Llama al método patch y actualiza el campo metadata con lo siguiente:
- El URI de la tabla de BigQuery. Para los conjuntos de datos creados a partir de una tabla de BigQuery, esta es tu
bigquery_uride origen. Para los conjuntos de datos creados a partir de otras fuentes, como JSONL o DataFrame, esta es la tabla de BigQuery en la que se copiaron tus datos. - 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"
(Opcional) Ensambla el conjunto de datos
El método assemble aplica la plantilla para transformar tu conjunto de datos y almacena el resultado en una tabla nueva de BigQuery. Esto te permite obtener una vista previa de los datos antes de pasarlos al modelo.
De forma predeterminada, se usa el template_config adjunto del conjunto de datos, pero puedes especificar una plantilla para anular el comportamiento predeterminado.
SDK de Agent Platform
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 ejemplo, supongamos que tu conjunto de datos multimodal contiene los siguientes datos:
| Fila | image_uris | etiquetas |
|---|---|---|
| 1 | gs://cloud-samples-data/ai-platform/flowers/daisy/1396526833_fb867165be_n.jpg | daisy |
Luego, el método assemble crea una tabla nueva de BigQuery con el nombre table_id, en la que cada fila contiene el cuerpo de la solicitud. Por ejemplo:
{
"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."
}
]
}
}
Ajusta tu modelo
Puedes ajustar los modelos de Gemini con un conjunto de datos multimodal.
(Opcional) Valida el conjunto de datos
Evalúa el conjunto de datos para verificar si contiene errores, como errores de formato del conjunto de datos o errores del modelo.
SDK de Agent Platform
Llama a assess_tuning_validity(). De forma predeterminada, se usa el template_config adjunto del conjunto de datos, pero puedes especificar una plantilla para anular el comportamiento predeterminado.
# Attach template
my_dataset.attach_template_config(template_config=template_config)
# Validation for tuning
validation = my_dataset.assess_tuning_validity(
model_name="gemini-2.5-flash",
dataset_usage="SFT_TRAINING"
)
# Inspect validation result
validation.errors
REST
Llama al método assess y proporciona 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"
}
}'
(Opcional) Estima el uso de recursos
Evalúa el conjunto de datos para obtener el recuento de tokens y caracteres facturables para tu trabajo de ajuste.
SDK de Agent Platform
Llama a assess_tuning_resources().
# Resource estimation for tuning.
tuning_resources = my_dataset.assess_tuning_resources(
model_name="gemini-2.5-flash"
)
print(tuning_resources)
# For example, TuningResourceUsageAssessmentResult(token_count=362688, billable_character_count=122000)
REST
Llama al método assess y proporciona 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"
}
}'
Ejecuta el trabajo de ajuste
SDK de Agent Platform
from vertexai.tuning import sft
sft_tuning_job = sft.train(
source_model="gemini-2.5-flash",
# Pass the Vertex Multimodal Datasets directly
train_dataset=my_multimodal_dataset,
validation_dataset=my_multimodal_validation_dataset,
)
SDK de IA generativa de Google
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.5-flash",
# Pass the resource name of the 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 obtener más información, consulta Crea un trabajo de ajuste.
Predicción por lotes
Puedes obtener predicciones por lotes con un conjunto de datos multimodal.
(Opcional) Valida el conjunto de datos
Evalúa el conjunto de datos para verificar si contiene errores, como errores de formato del conjunto de datos o errores del modelo.
SDK de Agent Platform
Llama a assess_batch_prediction_validity(). De forma predeterminada, se usa el template_config adjunto del conjunto de datos, pero puedes especificar una plantilla para anular el comportamiento predeterminado.
# 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.5-flash",
dataset_usage="SFT_TRAINING"
)
# Inspect validation result
validation.errors
REST
Llama al método assess y proporciona 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",
}
}'
(Opcional) Estima el uso de recursos
Evalúa el conjunto de datos para obtener el recuento de tokens para tu trabajo.
SDK de Agent Platform
Llama a assess_batch_prediction_resources().
batch_prediction_resources = my_dataset.assess_batch_prediction_resources(
model_name="gemini-2.5-flash"
)
print(batch_prediction_resources)
# For example, BatchPredictionResourceUsageAssessmentResult(token_count=362688, audio_token_count=122000)
REST
Llama al método assess y proporciona 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"
}
}'
Ejecuta el trabajo de predicción por lotes
Puedes usar tu conjunto de datos multimodal para realizar la predicción por lotes pasando el table_id de BigQuery del resultado ensamblado:
SDK de Agent Platform
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.5-flash",
input_dataset=assembly_table_id,
)
SDK de IA generativa de Google
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.5-flash",
src=assembly_table_id,
)
Para obtener más información, consulta Solicita un trabajo de predicción por lotes.
Limitaciones
Los conjuntos de datos multimodales solo se pueden usar con funciones de IA generativa. No se pueden usar con funciones de IA no generativa, como el entrenamiento de AutoML y el entrenamiento personalizado.
Los conjuntos de datos multimodales solo se pueden usar con modelos de Google, como Gemini. No se pueden usar con modelos de terceros.
Precios
Cuando ajustas un modelo o ejecutas un trabajo de predicción por lotes, se te factura por el uso de la IA generativa y por consultar el conjunto de datos en BigQuery.
Cuando creas, ensamblas o evalúas tu conjunto de datos multimodal, se te factura por almacenar y consultar conjuntos de datos multimodales en BigQuery. En específico, las siguientes operaciones usan esos servicios subyacentes:
Conjunto de datos
Create- Los conjuntos de datos creados a partir de una tabla o DataFrame de BigQuery existentes no generan costos de almacenamiento adicionales. Esto se debe a que usamos una vista lógica en lugar de almacenar otra copia de los datos.
- Los conjuntos de datos creados a partir de otras fuentes copian los datos a una tabla nueva de BigQuery, lo que genera costos de almacenamiento en BigQuery. Por ejemplo, el almacenamiento lógico activo por $0.02 por GiB al mes.
Conjunto de datos
AssembleEste método crea una tabla nueva de BigQuery que contiene el conjunto de datos completo en formato de solicitud de modelo, lo que genera costos de almacenamiento en BigQuery. Por ejemplo, el almacenamiento lógico activo por $0.02 por GiB al mes.
Este método también lee el conjunto de datos una vez, lo que genera costos de consulta en BigQuery. Por ejemplo, el procesamiento según demanda en los precios, $6.25 por TiB.
Assesslee el conjunto de datos una vez, lo que genera costos de consulta en BigQuery. Por ejemplo, el procesamiento según demanda en los precios, $6.25 por TiB.
Usa la calculadora de precios para generar una estimación de los costos según el uso previsto.