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

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

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

  • L'utilisation de modèles importés BigQuery ML avec des tables d'objets n'est possible que si vous utilisez la tarification basée sur la capacité via 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 :

  • Le modèle doit répondre aux exigences et aux limites d'entrée décrites dans l'instruction CREATE MODEL pour importer des modèles TensorFlow.

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

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. 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. Make sure that billing is enabled for your Google Cloud project.

  4. Enable the BigQuery and BigQuery Connection API APIs.

    Enable the APIs

    5.

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

    Go to project selector

  6. Make sure that billing is enabled for your Google Cloud project.

  7. Enable the BigQuery and BigQuery Connection API APIs.

    Enable the APIs

    8.

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 faire référence à ces champs lorsque vous exécutez une 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 :

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