Ensembles de données multimodaux

Les ensembles de données multimodales sur Agent Platform vous permettent de créer, de gérer, de partager et d'utiliser des ensembles de données multimodales pour l'IA générative. Les ensembles de données multimodaux offrent les principales fonctionnalités suivantes :

Vous pouvez charger des ensembles de données à partir de BigQuery, de DataFrames ou de fichiers JSONL dans Cloud Storage.
Créez votre ensemble de données une seule fois et utilisez-le pour différents types de jobs, tels que le fine-tuning supervisé et la prédiction par lot. Vous éviterez ainsi la duplication des données et les problèmes de mise en forme.
Conservez tous vos ensembles de données d'IA générative dans un emplacement unique et géré.
Validez votre schéma et votre structure, et quantifiez les ressources nécessaires pour les tâches en aval. Cela vous aidera à détecter les erreurs et à estimer les coûts avant de commencer une tâche.

Vous pouvez utiliser des ensembles de données multimodaux via le SDK Agent Platform ou l'API REST.

Les ensembles de données multimodaux sont un type d'ensembles de données gérés sur Agent Platform. Ils diffèrent des autres types de jeux de données gérés de plusieurs façons :

Les ensembles de données multimodaux peuvent inclure des données de n'importe quelle modalité (texte, image, audio, vidéo). D'autres types d'ensembles de données gérés ne concernent qu'une seule modalité.
Les ensembles de données multimodaux ne peuvent être utilisés que pour les services d'IA générative sur Agent Platform, tels que le réglage et la prédiction par lot avec des modèles génératifs. Les autres types d'ensembles de données gérés ne peuvent être utilisés que pour les modèles prédictifs Agent Platform.
Les ensembles de données multimodaux sont compatibles avec des méthodes supplémentaires, telles que assemble et assess, qui sont utilisées pour prévisualiser les données, valider les requêtes et estimer les coûts.
Les ensembles de données multimodaux sont stockés dans BigQuery, qui est optimisé pour les grands ensembles de données.

Avant de commencer

Connectez-vous à votre compte Google Cloud . Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $de crédits sans frais pour exécuter, tester et déployer des charges de travail.

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

Installer et initialiser le SDK Agent Platform pour Python

Importez les bibliothèques suivantes :

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

Créer un ensemble de données

Vous pouvez créer un dataset multimodal à partir de différentes sources :

à partir d'un DataFrame Pandas

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

à partir d'un DataFrame BigQuery :

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

à partir d'une table BigQuery

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

à partir d'une table BigQuery, à l'aide de l'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"
      }
    }
  }
}'

à partir d'un fichier JSONL dans Cloud Storage. Dans l'exemple suivant, le fichier JSONL contient des requêtes déjà formatées pour Gemini. Aucun assemblage n'est donc nécessaire.
```
my_dataset = datasets.MultimodalDataset.from_gemini_request_jsonl(
  gcs_uri = gcs_uri_of_jsonl_file,
)
```

à partir d'un ensemble de données multimodal existant

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

Créer et joindre un modèle

Un modèle définit la manière de transformer l'ensemble de données multimodal en un format pouvant être transmis au modèle. Cette valeur est requise pour exécuter un job d'optimisation ou de prédiction par lot.

SDK Agent Platform

Créez un modèle. Il existe deux façons de créer un modèle :

Utilisez la méthode d'assistance 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.'
)

Construisez manuellement un modèle à partir d'un GeminiExample, ce qui permet une granularité plus fine, comme les conversations multitours. L'exemple de code suivant inclut également du code commenté facultatif pour spécifier un field_mapping, ce qui vous permet d'utiliser un nom d'espace réservé différent du nom de colonne de l'ensemble de données. Exemple :

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

Associez-le à l'ensemble de données :

my_dataset.attach_template_config(template_config=template_config)

REST

Appelez la méthode patch et mettez à jour le champ metadata avec les informations suivantes :

URI de la table BigQuery. Pour les ensembles de données créés à partir d'une table BigQuery, il s'agit de votre source bigquery_uri. Pour les ensembles de données créés à partir d'autres sources, comme JSONL ou DataFrame, il s'agit de la table BigQuery dans laquelle vos données ont été copiées.
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"

(Facultatif) Assembler l'ensemble de données

La méthode assemble applique le modèle pour transformer votre ensemble de données et stocke le résultat dans une nouvelle table BigQuery. Cela vous permet de prévisualiser les données avant qu'elles ne soient transmises au modèle.

Par défaut, le template_config associé à l'ensemble de données est utilisé, mais vous pouvez spécifier un modèle pour remplacer le comportement par défaut.

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

Par exemple, supposons que votre ensemble de données multimodal contienne les données suivantes :

Ligne	image_uris	labels
1	gs://cloud-samples-data/ai-platform/flowers/daisy/1396526833_fb867165be_n.jpg	Marguerites

La méthode assemble crée ensuite une table BigQuery nommée table_id, où chaque ligne contient le corps de la requête. Exemple :

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

Régler votre modèle

Vous pouvez ajuster les modèles Gemini à l'aide d'un ensemble de données multimodal.

(Facultatif) Valider l'ensemble de données

Évaluez l'ensemble de données pour vérifier s'il contient des erreurs, comme des erreurs de mise en forme ou de modèle.

SDK Agent Platform

Appelez le assess_tuning_validity(). Par défaut, le template_config associé à l'ensemble de données est utilisé, mais vous pouvez spécifier un modèle pour remplacer le comportement par défaut.

# 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

Appelez la méthode assess et fournissez 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"
  }
}'

(Facultatif) Estimer l'utilisation des ressources

Évaluez l'ensemble de données pour obtenir le nombre de jetons et de caractères facturables pour votre job de réglage.

SDK Agent Platform

Appelez le 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

Appelez la méthode assess et fournissez 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"
  }
}'

Exécuter le job de réglage

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

Pour en savoir plus, consultez Créer une tâche de réglage.

Prédiction par lot

Vous pouvez obtenir des prédictions par lot à l'aide d'un ensemble de données multimodal.

(Facultatif) Valider l'ensemble de données

Évaluez l'ensemble de données pour vérifier s'il contient des erreurs, comme des erreurs de mise en forme ou de modèle.

SDK Agent Platform

Appelez le assess_batch_prediction_validity(). Par défaut, le template_config associé à l'ensemble de données est utilisé, mais vous pouvez spécifier un modèle pour remplacer le comportement par défaut.

# 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

Appelez la méthode assess et fournissez 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",
  }
}'

(Facultatif) Estimer l'utilisation des ressources

Évaluez l'ensemble de données pour obtenir le nombre de jetons pour votre tâche.

SDK Agent Platform

Appelez le 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

Appelez la méthode assess et fournissez 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"
  }
}'

Exécuter le job de prédiction par lot

Vous pouvez utiliser votre ensemble de données multimodal pour effectuer des prédictions par lot en transmettant le BigQuerytable_id de la sortie assemblée :

SDK 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 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.5-flash",
    src=assembly_table_id,
)

Pour en savoir plus, consultez Demander un job de prédiction par lot.

Limites

Les ensembles de données multimodaux ne peuvent être utilisés qu'avec des fonctionnalités d'IA générative. Elles ne peuvent pas être utilisées avec des fonctionnalités d'IA non générative telles que l'entraînement AutoML et l'entraînement personnalisé.
Les ensembles de données multimodaux ne peuvent être utilisés qu'avec des modèles Google tels que Gemini. Ils ne peuvent pas être utilisés avec des modèles tiers.

Tarifs

Lorsque vous ajustez un modèle ou exécutez un job de prédiction par lot, l'utilisation de l'IA générative et l'interrogation de l'ensemble de données dans BigQuery vous sont facturées.

Lorsque vous créez, assemblez ou évaluez votre ensemble de données multimodal, vous êtes facturé pour le stockage et l'interrogation des ensembles de données multimodaux dans BigQuery. Plus précisément, les opérations suivantes utilisent ces services sous-jacents :

Create ensemble de données
- Les ensembles de données créés à partir d'une table ou d'un DataFrame BigQuery existants n'entraînent aucun coût de stockage supplémentaire. En effet, nous utilisons une vue logique au lieu de stocker une autre copie des données.
- Les ensembles de données créés à partir d'autres sources copient les données dans une nouvelle table BigQuery, ce qui entraîne des frais de stockage dans BigQuery. Par exemple, le stockage logique actif est facturé 0,02 $par Gio et par mois.
Assemble ensemble de données
- Cette méthode crée une table BigQuery contenant l'ensemble de données au format de requête de modèle, ce qui entraîne des coûts de stockage dans BigQuery. Par exemple, le stockage logique actif est facturé 0,02 $par Gio et par mois.
- Cette méthode lit également l'ensemble de données une seule fois, ce qui entraîne des coûts de requête dans BigQuery. Par exemple, le calcul à la demande est facturé 6, 25 $ par Tio.
Assess lit l'ensemble de données une seule fois, ce qui entraîne des coûts de requête dans BigQuery. Par exemple, le calcul à la demande est facturé 6, 25 $ par Tio.

Utilisez le simulateur de coût pour générer une estimation des coûts en fonction de votre utilisation prévue.

Ensembles de données multimodaux Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Avant de commencer

Créer un ensemble de données

Créer et joindre un modèle

SDK Agent Platform

REST

(Facultatif) Assembler l'ensemble de données

SDK Agent Platform

REST

Régler votre modèle

(Facultatif) Valider l'ensemble de données

SDK Agent Platform

REST

(Facultatif) Estimer l'utilisation des ressources

SDK Agent Platform

REST

Exécuter le job de réglage

SDK Agent Platform

SDK Google Gen AI

Prédiction par lot

(Facultatif) Valider l'ensemble de données

SDK Agent Platform

REST

(Facultatif) Estimer l'utilisation des ressources

SDK Agent Platform

REST

Exécuter le job de prédiction par lot

SDK Agent Platform

SDK Google Gen AI

Limites

Tarifs

Ensembles de données multimodaux