Exécuter des inférences sur les tables d'objets image

Remarque : Cette fonctionnalité peut ne pas être disponible si vous utilisez des réservations créées avec certaines éditions BigQuery. Pour en savoir plus sur les fonctionnalités activées dans chaque édition, consultez la page Présentation des éditions BigQuery.

Ce document explique comment utiliser BigQuery ML pour exécuter des inférences sur des tables d'objets d'images.

Présentation

Vous pouvez exécuter des inférences sur les données d'image en utilisant une table d'objets comme entrée de la fonction ML.PREDICT.

Pour ce faire, vous devez d'abord choisir un modèle approprié, l'importer dans Cloud Storage, puis l'importer dans BigQuery en exécutant l'instruction CREATE MODEL. Vous pouvez créer votre propre modèle ou en télécharger un à partir de TensorFlow Hub.

Limites

• BigQuery ML pour les tables d'objets n'est compatible qu'avec la tarification basée sur la capacité, par l'intermédiaire des réservations. La tarification à la demande n'est pas disponible.
• Les fichiers image associés à la table d'objets doivent répondre aux exigences suivantes :
  • Leur taille est inférieure à 20 Mo.
  • Ils sont au format JPEG, PNG ou BMP.
• La taille combinée des fichiers image associés à la table d'objets doit être inférieure à 1 To.

• Le modèle doit être l'un des suivants :

  • Un modèle TensorFlow ou TensorFlow Lite (en preview) au format SavedModel.
  • Modèle PyTorch au format ONNX (en version preview).

• Le modèle doit répondre aux exigences et aux limites d'entrée décrites dans la section Entrées compatibles.

• La taille sérialisée du modèle doit être inférieure à 450 Mo.

• La taille du modèle désérialisé (en mémoire) doit être inférieure à 1 000 Mo.

• Le Tensor d'entrée du modèle doit remplir les critères suivants :

  • Le type de données doit être tf.float32 avec des valeurs dans [0, 1), ou le type de données doit être tf.uint8 avec des valeurs dans [0, 255).
  • Sa forme doit être [batch_size, weight, height, 3], où :
    • La valeur de batch_size doit être -1, None ou 1.
    • La valeur de width et height doit être supérieure à 0.

• Le modèle doit être entraîné avec des images dans l'un des espaces colorimétriques suivants :

  • RGB
  • HSV
  • YIQ
  • YUV
  • GRAYSCALE

  Vous pouvez utiliser la fonction ML.CONVERT_COLOR_SPACE pour convertir les images d'entrée dans l'espace colorimétrique avec lequel le modèle a été entraîné.

Exemples de modèles

Les modèles suivants sur TensorFlow Hub fonctionnent avec BigQuery ML et les tables d'objets image :

• ResNet 50. Pour essayer d'utiliser ce modèle, consultez le Tutoriel : Exécuter une inférence sur une table d'objets à l'aide d'un modèle de classification.
• MobileNet V3. Pour essayer d'utiliser ce modèle, consultez le Tutoriel : Exécuter une inférence sur une table d'objets à l'aide d'un modèle de vecteur de caractéristiques.

Autorisations requises

• Pour importer le modèle dans Cloud Storage, vous devez disposer des autorisations storage.objects.create et storage.objects.get.

• Pour charger le modèle dans BigQuery ML, vous devez disposer des autorisations suivantes :

  • bigquery.jobs.create
  • bigquery.models.create
  • bigquery.models.getData
  • bigquery.models.updateData

• Pour exécuter une inférence, vous devez disposer des autorisations suivantes :

  • bigquery.tables.getData sur la table d'objets
  • bigquery.models.getData sur le modèle
  • bigquery.jobs.create

Avant de commencer

1. 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 gratuits pour exécuter, tester et déployer des charges de travail.

2. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

   Remarque : Si vous ne comptez pas conserver les ressources créées dans cette procédure, créez un projet au lieu de sélectionner un projet existant. Après avoir suivi ces étapes, vous pouvez supprimer le projet. Cela entraîne la suppression de toutes les ressources qui lui sont associées.

   Accéder au sélecteur de projet

3. Vérifiez que la facturation est activée pour votre projet Google Cloud.

4. Activer les API BigQuery and BigQuery Connection API.

   Activer les API

5. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

   Remarque : Si vous ne comptez pas conserver les ressources créées dans cette procédure, créez un projet au lieu de sélectionner un projet existant. Après avoir suivi ces étapes, vous pouvez supprimer le projet. Cela entraîne la suppression de toutes les ressources qui lui sont associées.

   Accéder au sélecteur de projet

6. Vérifiez que la facturation est activée pour votre projet Google Cloud.

7. Activer les API BigQuery and BigQuery Connection API.

   Activer les API

Importer un modèle dans Cloud Storage

Pour importer un modèle, procédez comme suit :

1. Si vous avez créé votre propre modèle, enregistrez-le localement. Si vous utilisez un modèle de TensorFlow Hub, téléchargez-le sur votre ordinateur local. Si vous utilisez TensorFlow, vous devez obtenir un fichier saved_model.pb et un dossier variables pour le modèle.
2. Si nécessaire, créez un bucket Cloud Storage.
3. Importez les artefacts de modèle dans le bucket.

Charger le modèle dans BigQuery ML

Le chargement d'un modèle fonctionnant avec des tables d'objets d'images revient à charger un modèle qui fonctionne avec des données structurées. Pour charger un modèle dans BigQuery ML, procédez comme suit :

CREATE MODEL `PROJECT_ID.DATASET_ID.MODEL_NAME`
OPTIONS(
  model_type = 'MODEL_TYPE',
  model_path = 'BUCKET_PATH');

Remplacez les éléments suivants :

• PROJECT_ID : ID de votre projet.
• DATASET_ID : ID de l'ensemble de données pour contenir le modèle.
• MODEL_NAME : nom du modèle
• MODEL_TYPE : utilisez l'une des valeurs suivantes :
  • TENSORFLOW pour un modèle TensorFlow
  • ONNX pour un modèle PyTorch au format ONNX
• BUCKET_PATH : chemin d'accès au bucket Cloud Storage contenant le modèle, au format [gs://bucket_name/[folder_name/]*].

L'exemple suivant utilise le projet par défaut et charge un modèle dans BigQuery ML en tant que my_vision_model, à l'aide du fichier saved_model.pb et du dossier variables de gs://my_bucket/my_model_folder :

CREATE MODEL `my_dataset.my_vision_model`
OPTIONS(
  model_type = 'TENSORFLOW',
  model_path = 'gs://my_bucket/my_model_folder/*');

Inspecter le modèle

Vous pouvez inspecter le modèle importé pour afficher ses champs d'entrée et de sortie. Vous devez référencer ces champs lorsque vous exécutez l'inférence sur la table d'objets.

Pour inspecter un modèle, procédez comme suit :

1. Accédez à la page BigQuery.

   Accéder à BigQuery

2. Dans le volet Explorateur, développez votre projet, développez l'ensemble de données contenant le modèle, puis développez le nœud Modèles.

3. Cliquez sur le modèle.

4. Dans le volet du modèle qui s'affiche, cliquez sur l'onglet Schéma.

5. Consultez la section Étiquettes. Cela permet d'identifier les champs générés par le modèle.

6. Examinez la section Caractéristiques. Cela permet d'identifier les champs qui doivent être saisis dans le modèle. Vous les référencez dans l'instruction SELECT pour la fonction ML.DECODE_IMAGE.

Pour une inspection plus détaillée d'un modèle, par exemple pour déterminer la forme de l'entrée du modèle, installez TensorFlow et utilisez la fonction saved_model_cli show.

Prétraiter des images

Vous devez utiliser la fonction ML.DECODE_IMAGE pour convertir les octets de l'image en une représentation ARRAY multidimensionnelle. Vous pouvez utiliser la sortie ML.DECODE_IMAGE directement dans une fonction ML.PREDICT, ou écrire les résultats de ML.DECODE_IMAGE dans une colonne de table et la référencer lorsque vous appelez ML.PREDICT.

L'exemple suivant écrit le résultat de la fonction ML.DECODE_IMAGE dans une table :

CREATE OR REPLACE TABLE mydataset.mytable AS (
  SELECT ML.DECODE_IMAGE(data) AS decoded_image FROM mydataset.object_table
  );

Utilisez les fonctions suivantes pour affiner le traitement des images afin qu'elles fonctionnent avec votre modèle :

• La fonction ML.CONVERT_COLOR_SPACE convertit les images ayant un espace colorimétrique RGB en espace colorimétrique différent.
• La fonction ML.CONVERT_IMAGE_TYPE convertit en entiers le résultat des valeurs de pixels générées par la fonction ML.DECODE_IMAGE à partir des nombres à virgule flottante, selon une plage de [0, 255).
• La fonction ML.RESIZE_IMAGE redimensionne les images.

Vous pouvez les utiliser dans le cadre de la fonction ML.PREDICT, ou les exécuter sur une colonne de table contenant le résultat des données d'image traitées par ML.DECODE_IMAGE.

Exécuter une inférence

Une fois qu'un modèle approprié est chargé et que les données d'image ont été prétraitées, le cas échéant, vous pouvez exécuter une inférence sur les données d'image.

Pour exécuter l'inférence :

SELECT *
FROM ML.PREDICT(
  MODEL `PROJECT_ID.DATASET_ID.MODEL_NAME`,
  (SELECT [other columns from the object table,] IMAGE_DATA AS MODEL_INPUT
  FROM PROJECT_ID.DATASET_ID.TABLE_NAME)
);

Remplacez les éléments suivants :

• PROJECT_ID : ID du projet contenant le modèle et la table d'objets.
• DATASET_ID : ID de l'ensemble de données contenant le modèle et la table d'objets.
• MODEL_NAME : nom du modèle
• IMAGE_DATA : données d'image, représentées par le résultat de la fonction ML.DECODE_IMAGE, ou par une colonne de table contenant un résultat de données d'image traitées par ML.DECODE_IMAGE ou d'autres fonctions de traitement d'image.
• MODEL_INPUT : nom d'un champ de saisie du modèle. Vous trouverez cette information en inspectant le modèle et en examinant les noms de champs dans la section Caractéristiques.
• TABLE_NAME : nom de la table d'objets.

Examples

Exemple 1

L'exemple suivant utilise la fonction ML.DECODE_IMAGE directement dans la fonction ML.PREDICT. La méthode renvoie les résultats d'inférence pour toutes les images de la table d'objets, pour un modèle avec un champ de saisie input et un champ de sortie feature :

SELECT * FROM
ML.PREDICT(
  MODEL `my_dataset.vision_model`,
  (SELECT uri, ML.RESIZE_IMAGE(ML.DECODE_IMAGE(data), 480, 480, FALSE) AS input
  FROM `my_dataset.object_table`)
);

Exemple 2

L'exemple suivant utilise la fonction ML.DECODE_IMAGE directement dans la fonction ML.PREDICT et la fonction ML.CONVERT_COLOR_SPACE dans la fonction ML.PREDICT pour convertir l'espace colorimétrique de l'image de RBG à YIQ. Il montre également comment utiliser les champs de table d'objets pour filtrer les objets inclus dans l'inférence. La méthode renvoie les résultats d'inférence pour toutes les images JPG de la table d'objets, pour un modèle avec un champ de saisie input et un champ de sortie feature :

SELECT * FROM
  ML.PREDICT(
    MODEL `my_dataset.vision_model`,
    (SELECT uri, ML.CONVERT_COLOR_SPACE(ML.RESIZE_IMAGE(ML.DECODE_IMAGE(data), 224, 280, TRUE), 'YIQ') AS input
    FROM `my_dataset.object_table`
    WHERE content_type = 'image/jpeg')
  );

Exemple 3

L'exemple suivant utilise les résultats de ML.DECODE_IMAGE qui ont été écrits dans une colonne de table, mais qui n'ont pas été traités. Il utilise ML.RESIZE_IMAGE et ML.CONVERT_IMAGE_TYPE dans la fonction ML.PREDICT pour traiter les données d'image. Il renvoie les résultats de toutes les images dans la table des images décodées, pour un modèle avec un champ de saisie input et un champ de sortie feature.

Créez la table d'images décodées :

CREATE OR REPLACE TABLE `my_dataset.decoded_images`
  AS (SELECT ML.DECODE_IMAGE(data) AS decoded_image
  FROM `my_dataset.object_table`);

Exécutez l'inférence sur la table des images décodées :

SELECT * FROM
ML.PREDICT(
  MODEL`my_dataset.vision_model`,
  (SELECT uri, ML.CONVERT_IMAGE_TYPE(ML.RESIZE_IMAGE(decoded_image, 480, 480, FALSE)) AS input
  FROM `my_dataset.decoded_images`)
);

Exemple 4

L'exemple suivant utilise les résultats de ML.DECODE_IMAGE qui ont été écrits dans une colonne de table et prétraités à l'aide de ML.RESIZE_IMAGE. Il renvoie les résultats de toutes les images dans la table des images décodées, pour un modèle avec un champ de saisie input et un champ de sortie feature.

Créez la table :

CREATE OR REPLACE TABLE `my_dataset.decoded_images`
  AS (SELECT ML.RESIZE_IMAGE(ML.DECODE_IMAGE(data) 480, 480, FALSE) AS decoded_image
  FROM `my_dataset.object_table`);

Exécutez l'inférence sur la table des images décodées :

SELECT * FROM
ML.PREDICT(
  MODEL `my_dataset.vision_model`,
  (SELECT uri, decoded_image AS input
  FROM `my_dataset.decoded_images`)
);

Exemple 5

L'exemple suivant utilise la fonction ML.DECODE_IMAGE directement dans la fonction ML.PREDICT. Dans l'exemple suivant, le modèle comporte un champ de sortie embeddings et deux champs de saisie : l'un qui attend une image, f_img et l'autre qui attend une chaîne, f_txt. L'entrée image provient de la table d'objets et l'entrée chaîne provient d'une table BigQuery standard qui est jointe à la table d'objets à l'aide de la colonne uri.

SELECT * FROM
  ML.PREDICT(
    MODEL `my_dataset.mixed_model`,
    (SELECT uri, ML.RESIZE_IMAGE(ML.DECODE_IMAGE(my_dataset.my_object_table.data), 224, 224, FALSE) AS f_img,
      my_dataset.image_description.description AS f_txt
    FROM `my_dataset.object_table`
    JOIN `my_dataset.image_description`
    ON object_table.uri = image_description.uri)
  );

Étapes suivantes

• Apprenez à analyser des tables d'objets à l'aide de fonctions à distance.
• Essayez d'exécuter une inférence sur une table d'objets à l'aide d'un modèle de vecteur de caractéristiques.
• Essayez d'exécuter l'inférence sur une table d'objets à l'aide d'un modèle de classification.
• Essayez d'analyser une table d'objets à l'aide d'une fonction distante.
• Effectuez des prédictions à l'aide de modèles distants sur Vertex AI.