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
etassess
, 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
- 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.
-
Verify that billing is enabled for your Google Cloud project.
-
Enable the Vertex AI, BigQuery, and Cloud Storage APIs.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Verify that billing is enabled for your Google Cloud project.
-
Enable the Vertex AI, BigQuery, and Cloud Storage APIs.
- Installer et initialiser le SDK Vertex AI 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
à 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é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 unfield_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"}, )
- Utilisez la méthode d'assistance
Associez-le à l'ensemble de données :
my_dataset.attach_template_config(template_config=template_config)
- 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
. 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.
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éesCette 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.
Créer un ensemble de données
Vous pouvez créer un dataset
multimodal à partir de différentes sources :
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
REST
Appelez la méthode patch
et mettez à jour le champ metadata
avec les informations suivantes :
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
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 :
Utilisez le simulateur de coût pour générer une estimation des coûts en fonction de votre utilisation prévue.