Se usó la API de Cloud Translation para traducir esta página.

Conjuntos de datos multimodales

Los conjuntos de datos multimodales en Vertex AI 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 fino 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 ayudará a detectar errores y estimar el costo antes de comenzar una tarea.

Puedes usar conjuntos de datos multimodales a través del SDK de Vertex AI para Python o la API de REST.

Los conjuntos de datos multimodales son un tipo de conjuntos de datos administrados en Vertex AI. 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 Vertex AI, 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 Vertex AI.
Los conjuntos de datos multimodales admiten métodos adicionales, como assemble y assess, 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

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.

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.

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

Instala e inicializa el SDK de Vertex AI 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 dataset multimodal 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
)

desde un DataFrame de BigQuery:

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

desde una tabla de BigQuery

my_dataset_from_bigquery = datasets.MultimodalDataset.from_bigquery(
    bigquery_uri=f"bq://projectId.datasetId.tableId"
)

desde 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"
      }
    }
  }
}'

desde 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,
)
```

de un conjunto de datos multimodales 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)

Cómo crear y adjuntar una plantilla

Una plantilla define cómo transformar el conjunto de datos multimodal en un formato que se pueda pasar al modelo. Este parámetro es obligatorio para ejecutar un trabajo de ajuste o de predicción por lotes.

SDK de Vertex AI para Python

Construye una plantilla. Existen dos formas de crear 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, lo que permite una mayor granularidad, como conversaciones de varios turnos. La siguiente muestra de código también incluye código opcional comentado para especificar un field_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"},
)

Adjúntalo 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:

Es el URI de la tabla de BigQuery. En el caso de los conjuntos de datos creados a partir de una tabla de BigQuery, esta es tu fuente bigquery_uri. En el caso de 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 que se pasen 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 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 ejemplo, supón 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 o errores del modelo.

SDK de Vertex AI para Python

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

(Opcional) Estima el uso de recursos

Evalúa el conjunto de datos para obtener el recuento de tokens y caracteres facturables de tu trabajo de ajuste.

SDK de Vertex AI para Python

Llama a 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

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

Ejecuta el trabajo de ajuste

SDK de 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,
)

Google Gen AI SDK

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 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 o errores del modelo.

SDK de Vertex AI para Python

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

(Opcional) Estima el uso de recursos

Evalúa el conjunto de datos para obtener el recuento de tokens de tu trabajo.

SDK de Vertex AI para Python

Llama a 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

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

Ejecuta el trabajo de predicción por lotes

Puedes usar tu conjunto de datos multimodales para realizar predicciones por lotes pasando el BigQuerytable_id del resultado ensamblado:

SDK de 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,
)

Google Gen AI SDK

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 obtener más información, consulta Cómo solicitar un trabajo de predicción por lotes.

Limitaciones

Los conjuntos de datos multimodales solo se pueden usar con funciones potenciadas por IA generativa. No se pueden usar con funciones de IA no generativas, 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 IA generativa y por consultar el conjunto de datos en BigQuery.

Cuando creas, ensamblas o evalúas tu conjunto de datos multimodales, se te factura por almacenar y consultar conjuntos de datos multimodales en BigQuery. Específicamente, las siguientes operaciones usan esos servicios subyacentes:

Create conjunto de datos
- Los conjuntos de datos creados a partir de una tabla o un 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 en una nueva tabla de BigQuery, lo que genera costos de almacenamiento en BigQuery. Por ejemplo, almacenamiento lógico activo por USD 0.02 por GiB al mes.
Assemble conjunto de datos
- Este método crea una tabla nueva de BigQuery que contiene el conjunto de datos completo en formato de solicitud del modelo, lo que genera costos de almacenamiento en BigQuery. Por ejemplo, almacenamiento lógico activo por USD 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, USD 6.25 por TiB. Validación del conjunto de datos y estimación de recursos
Assess 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, USD 6.25 por TiB.

Usa la calculadora de precios para generar una estimación de los costos según el uso previsto.

Conjuntos de datos multimodales Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Antes de comenzar

Crea un conjunto de datos

Cómo crear y adjuntar una plantilla

SDK de Vertex AI para Python

REST

(Opcional) Ensambla el conjunto de datos

SDK de Vertex AI para Python

REST

Ajusta tu modelo

(Opcional) Valida el conjunto de datos

SDK de Vertex AI para Python

REST

(Opcional) Estima el uso de recursos

SDK de Vertex AI para Python

REST

Ejecuta el trabajo de ajuste

SDK de Vertex AI para Python

Google Gen AI SDK

Predicción por lotes

(Opcional) Valida el conjunto de datos

SDK de Vertex AI para Python

REST

(Opcional) Estima el uso de recursos

SDK de Vertex AI para Python

REST

Ejecuta el trabajo de predicción por lotes

SDK de Vertex AI para Python

Google Gen AI SDK

Limitaciones

Precios

Conjuntos de datos multimodales