Ensembles de données multimodaux

Les ensembles de données multimodaux sur Vertex AI vous permettent de créer, de gérer, de partager et d'utiliser des ensembles de données multimodaux pour l'IA générative. Les ensembles de données multimodaux offrent les fonctionnalités clé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 avec le SDK Vertex AI pour Python ou l'API REST.

Les ensembles de données multimodaux sont un type d'ensembles de données gérés sur Vertex AI. 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). Les autres types de jeux 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 Vertex AI, tels que l'ajustement 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 Vertex AI.
  • 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

  1. 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.
  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

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

    Enable the APIs

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

    Go to project selector

  6. Verify that billing is enabled for your Google Cloud project.

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

    Enable the APIs

  8. Installer et initialiser le SDK Vertex AI pour Python
  9. 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
    
  10. 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 associer 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 Vertex AI pour Python

    1. 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"},
      )
      
    2. 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, telles que 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 Vertex AI pour 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 '{}'
    

    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, telles que des erreurs de mise en forme ou de modèle.

    SDK Vertex AI pour Python

    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.0-flash-001",
        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.0-flash-001",
        "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 Vertex AI pour Python

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

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

    Exécuter le job de réglage

    SDK Vertex AI pour 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 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"),
    )
    

    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, telles que des erreurs de mise en forme ou de modèle.

    SDK Vertex AI pour Python

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

    (Facultatif) Estimer l'utilisation des ressources

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

    SDK Vertex AI pour Python

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

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

    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 Vertex AI pour 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 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,
    )
    

    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 complet 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. Validation de l'ensemble de données et estimation des ressources

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