Effectuer une ingénierie des caractéristiques avec la clause TRANSFORM

---

Ce tutoriel présente BigQuery ML aux analystes de données. BigQuery ML permet aux utilisateurs de créer et d'exécuter des modèles de machine learning dans BigQuery à l'aide de requêtes SQL. Ce tutoriel présente l'ingénierie des caractéristiques à l'aide de la clause TRANSFORM. La clause TRANSFORM vous permet de spécifier toutes les fonctions de prétraitement lors de la création du modèle. Le prétraitement est automatiquement appliqué pendant les phases de prédiction et d'évaluation du machine learning.

Dans ce tutoriel, vous vous appuyez sur un exemple de table natality pour créer un modèle capable de prédire le poids de naissance d'un enfant en fonction de son genre, de la durée de la grossesse et des données démographiques segmentées de la mère. L'exemple de table natality contient des informations sur chaque naissance enregistrée aux États-Unis sur une période de 40 ans.

Objectifs

Dans ce tutoriel, vous allez utiliser :

• BigQuery ML pour créer un modèle de régression linéaire à l'aide de l'instruction CREATE MODEL avec la clause TRANSFORM ;
• les fonctions de prétraitement ML.FEATURE_CROSS et ML.QUANTILE_BUCKETIZE ;
• la fonction ML.EVALUATE pour évaluer le modèle de ML ;
• la fonction ML.PREDICT pour effectuer des prédictions à l'aide du modèle de ML.

Coûts

Ce tutoriel utilise des composants facturables de Google Cloud, dont :

• BigQuery
• BigQuery ML

Pour plus d'informations sur les coûts de BigQuery, consultez la page Tarifs de BigQuery.

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

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

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

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

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

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

6. BigQuery est automatiquement activé dans les nouveaux projets. Pour activer BigQuery dans un projet préexistant, accédez à .

   Enable the BigQuery API.

   Enable the API

Étape 1 : Créer un ensemble de données

Vous allez créer un ensemble de données BigQuery pour stocker votre modèle de ML :

1. Dans la console Google Cloud, accédez à la page "BigQuery".

   Accéder à la page "BigQuery"

2. Dans le volet Explorer, cliquez sur le nom de votre projet.

3. Cliquez sur Afficher les actions > Créer un ensemble de données.

   

4. Sur la page Créer un ensemble de données, procédez comme suit :

   • Dans le champ ID de l'ensemble de données, saisissez bqml_tutorial.

   • Pour Type d'emplacement, sélectionnez Multirégional, puis sélectionnez US (plusieurs régions aux États-Unis).

     Les ensembles de données publics sont stockés dans l'emplacement multirégional US. Par souci de simplicité, stockez votre ensemble de données dans le même emplacement.

   • Conservez les autres paramètres par défaut, puis cliquez sur Créer un ensemble de données.

     

Étape 2 : Créer un modèle

Ensuite, créez un modèle de régression linéaire à l'aide de l'exemple de table de natalité pour BigQuery. La requête GoogleSQL présentée ci-dessous permet de créer le modèle dont vous vous servez pour prédire le poids de naissance d'un enfant.

#standardSQL
CREATE MODEL `bqml_tutorial.natality_model`
TRANSFORM(weight_pounds,
    is_male,
    gestation_weeks,
    ML.QUANTILE_BUCKETIZE(mother_age,
      5) OVER() AS bucketized_mother_age,
    CAST(mother_race AS string) AS mother_race,
    ML.FEATURE_CROSS(STRUCT(is_male,
        CAST(mother_race AS STRING) AS mother_race)) is_male_mother_race)
OPTIONS
  (model_type='linear_reg',
    input_label_cols=['weight_pounds']) AS
SELECT
  *
FROM
  `bigquery-public-data.samples.natality`
WHERE
  weight_pounds IS NOT NULL
  AND RAND() < 0.001

En plus de créer le modèle, l'exécution de la commande CREATE MODEL entraîne le modèle que vous créez.

Détails de la requête

La clause CREATE MODEL permet de créer et d'entraîner le modèle nommé bqml_tutorial.natality_model.

La clause OPTIONS(model_type='linear_reg', input_label_cols=['weight_pounds']) indique que vous créez un modèle de régression linéaire. Une régression linéaire est un type de modèle de régression qui génère une valeur continue à partir d'une combinaison linéaire de caractéristiques en entrée. La colonne weight_pounds correspond à la colonne de l'étiquette d'entrée. Pour les modèles de régression linéaire, la colonne d'étiquette doit être renseignée avec des valeurs réelles (les valeurs de colonne doivent être des nombres réels).

La clause TRANSFORM de cette requête utilise les colonnes suivantes de l'instruction SELECT :

• weight_pounds : poids de l'enfant, en livres (FLOAT64).
• is_male : genre de l'enfant. VRAI si l'enfant est un garçon, FAUX s'il s'agit d'une fille (BOOL).
• gestation_weeks : nombre de semaines de grossesse (INT64).
• mother_age : âge de la mère lors de l'accouchement (INT64).
• mother_race : origine ethnique de la mère (INT64). Cette valeur entière est identique à la valeur child_race dans le schéma de la table. Pour forcer BigQuery ML à traiter mother_race comme une caractéristique non numérique, avec une valeur distincte pour chaque catégorie, la requête convertit mother_race en CHAÎNE. C'est un point important, car l'origine ethnique a plus de sens en tant que catégorie qu'en tant que nombre entier (qui a un ordre et une échelle).

Grâce à la clause TRANSFORM, les caractéristiques d'origine sont prétraitées pour alimenter l'entraînement. Les colonnes générées sont les suivantes :

• weight_pounds : transmis tel quel, sans aucune modification.
• is_male : transmis pour alimenter l'entraînement.
• gestation_weeks : transmis pour alimenter l'entraînement.
• bucketized_mother_age : généré à partir de mother_age en segmentant mother_age sur la base de quantiles à l'aide de la fonction d'analyse ML.QUANTILE_BUCKETIZE().
• mother_race : format de chaîne de la colonne mother_race initiale.
• is_male_mother_race : généré à partir de is_male et de mother_race via la fonction ML.FEATURE_CROSS.

L'instruction SELECT de la requête fournit des colonnes que vous pouvez utiliser dans la clause TRANSFORM. Toutefois, vous n'avez pas besoin d'utiliser toutes les colonnes de la clause TRANSFORM. Par conséquent, vous pouvez effectuer à la fois la sélection de caractéristiques et le prétraitement dans la clause TRANSFORM.

La clause FROM – bigquery-public-data.samples.natality – indique que vous interrogez l'exemple de table de natalité dans l'ensemble de données d'échantillons. Cet ensemble de données se trouve dans le projet bigquery-public-data.

La clause WHERE – WHERE weight_pounds IS NOT NULL AND RAND() < 0.001 – exclut les lignes dont le poids est NULL et utilise la fonction RAND pour extraire un échantillon de données aléatoire.

Exécuter la requête CREATE MODEL

Pour exécuter la requête CREATE MODEL qui permet de créer et d'entraîner votre modèle, procédez comme suit :

1. Dans la console Google Cloud, cliquez sur le bouton Saisir une nouvelle requête.

2. Saisissez la requête GoogleSQL suivante dans la zone de texte Éditeur de requête.

   #standardSQL
   CREATE MODEL `bqml_tutorial.natality_model`
   TRANSFORM(weight_pounds,
       is_male,
       gestation_weeks,
       ML.QUANTILE_BUCKETIZE(mother_age,
         5) OVER() AS bucketized_mother_age,
       CAST(mother_race AS string) AS mother_race,
       ML.FEATURE_CROSS(STRUCT(is_male,
           CAST(mother_race AS STRING) AS mother_race)) is_male_mother_race)
   OPTIONS
     (model_type='linear_reg',
       input_label_cols=['weight_pounds']) AS
   SELECT
     *
   FROM
     `bigquery-public-data.samples.natality`
   WHERE
     weight_pounds IS NOT NULL
     AND RAND() < 0.001
   

3. Cliquez sur Exécuter.

   L'exécution de la requête prend environ 30 secondes, puis votre modèle (natality_model) s'affiche dans le panneau de navigation. Étant donné que la requête utilise une instruction CREATE MODEL pour créer une table, les résultats de la requête ne sont pas affichés.

Étape 3 (facultative) : Obtenir des statistiques d'entraînement

Pour afficher les résultats de l'entraînement du modèle, vous pouvez utiliser la fonction ML.TRAINING_INFO ou afficher les statistiques dans la console Google Cloud. Dans ce tutoriel, vous utilisez la console Google Cloud.

Pour créer un modèle, un algorithme de machine learning examine de nombreux exemples et essaie de trouver un modèle qui minimise la perte. Ce processus est appelé minimisation du risque empirique.

La perte est la pénalité associée à une mauvaise prédiction. Ce nombre indique à quel point la prédiction du modèle est fausse pour un exemple donné. Si la prédiction du modèle est parfaite, la perte est nulle. Sinon, la perte est supérieure à zéro. L'objectif de l'entraînement d'un modèle est de trouver un ensemble de pondérations et de biais présentant une faible perte pour tous les exemples (en moyenne).

Pour afficher les statistiques d'entraînement du modèle qui ont été générées lors de l'exécution de la requête CREATE MODEL, procédez comme suit :

1. Dans le panneau de navigation de la console Google Cloud, dans la section Ressources, développez project-name > bqml_tutorial, puis cliquez sur natality_model

2. Cliquez sur l'onglet Training (Entraînement). Dans View as (Afficher en tant que), sélectionnez l'option Table. Les résultats doivent se présenter sous la forme suivante :

   +-----------+--------------------+----------------------+--------------------+
   | Iteration | Training data loss | Evaluation data loss | Duration (seconds) |
   +-----------+--------------------+----------------------+--------------------+
   | 0         | 1.6640             | 1.7352               | 6.27               |
   +-----------+--------------------+----------------------+--------------------+
   

   La colonne Training Data Loss (Perte de données d'entraînement) représente la métrique de perte calculée après entraînement du modèle dans l'ensemble de données d'entraînement. Étant donné que vous avez effectué une régression linéaire, cette colonne correspond à l'erreur quadratique moyenne.

   La colonne Evaluation Data Loss (Perte de données d'évaluation) représente la même métrique de perte calculée sur l'ensemble de données exclues (données bloquées lors de l'entraînement pour valider le modèle). La stratégie d'optimisation par défaut utilisée ici pour l'entraînement est "normal_equation". Par conséquent, une seule itération suffit pour converger vers le modèle final.

   Pour plus d'informations sur l'option optimize_strategy, consultez l'instruction CREATE MODEL.

   Pour plus d'informations sur la fonction ML.TRAINING_INFO et l'option d'entraînement "optimize_strategy", consultez la documentation de référence sur la syntaxe de BigQuery ML.

Étape 4 : Évaluer le modèle

Après avoir créé votre modèle, vous évaluez les performances du classificateur à l'aide de la fonction ML.EVALUATE. La fonction ML.EVALUATE compare les valeurs estimées aux données réelles.

La requête permettant d'évaluer le modèle est la suivante :

#standardSQL
SELECT
  *
FROM
  ML.EVALUATE(MODEL `bqml_tutorial.natality_model`,
    (
    SELECT
      *
    FROM
      `bigquery-public-data.samples.natality`
    WHERE
      weight_pounds IS NOT NULL))

Détails des requêtes

La toute première instruction SELECT récupère les colonnes de votre modèle.

La clause FROM utilise la fonction ML.EVALUATE basée sur votre modèle : bqml_tutorial.natality_model.

L'instruction SELECT et la clause FROM imbriquées de cette requête sont identiques à celles de la requête CREATE MODEL. La clause TRANSFORM étant utilisée lors de l'entraînement, vous n'avez pas besoin de spécifier les colonnes et les transformations spécifiques. Celles-ci sont automatiquement restaurées.

La clause WHERE – WHERE weight_pounds IS NOT NULL – exclut les lignes dont le poids est NULL.

Remarque : Vous pouvez également appeler la fonction ML.EVALUATE sans fournir les données d'entrée. La fonction utilise les statistiques d'évaluation calculées pendant l'entraînement :

#standardSQL
SELECT
  *
FROM
  ML.EVALUATE(MODEL `bqml_tutorial.natality_model`)

Exécuter la requête ML.EVALUATE

Pour exécuter la requête ML.EVALUATE permettant d'évaluer le modèle, procédez comme suit :

1. Dans la console Google Cloud, cliquez sur le bouton Saisir une nouvelle requête.

2. Saisissez la requête GoogleSQL suivante dans la zone de texte Éditeur de requête.

   #standardSQL
   SELECT
     *
   FROM
     ML.EVALUATE(MODEL `bqml_tutorial.natality_model`,
       (
       SELECT
         *
       FROM
         `bigquery-public-data.samples.natality`
       WHERE
         weight_pounds IS NOT NULL))
   

3. (Facultatif) Pour définir l'emplacement de traitement, dans la liste déroulante More (Plus), cliquez sur Query settings (Paramètres de requête). Dans le champ Emplacement de traitement, sélectionnez États-Unis (US). Cette étape est facultative, car la zone de traitement est automatiquement détectée selon l'emplacement de l'ensemble de données.

   

4. Cliquez sur Run (Exécuter).

5. Lorsque la requête est terminée, cliquez sur l'onglet Results (Résultats) sous la zone de texte de la requête. Les résultats doivent se présenter sous la forme suivante :

   +---------------------+--------------------+------------------------+---------------------+---------------------+----------------------+
   | mean_absolute_error | mean_squared_error | mean_squared_log_error | mean_absolute_error | r2_score            | explained_variance   |
   +---------------------+--------------------+------------------------+---------------------+---------------------+----------------------+
   | 0.9566580179970666  | 1.6756289722442677 | 0.034241471462096516   | 0.7385590721661188  | 0.04650972930257946 | 0.046516832131241026 |
   +---------------------+--------------------+------------------------+---------------------+---------------------+----------------------+
   

   Étant donné que vous avez effectué une régression linéaire, les résultats incluent les colonnes suivantes :

   • mean_absolute_error
   • mean_squared_error
   • mean_squared_log_error
   • median_absolute_error
   • r2_score
   • explained_variance

Le score R² est une métrique importante dans les résultats de l'évaluation. Le score R² est une mesure statistique qui détermine si les prédictions de régression linéaire se rapprochent des données réelles. Une valeur 0 indique que le modèle n'apporte aucune explication sur la variabilité des données de réponse autour de la moyenne. Une valeur 1 indique que le modèle explique toute la variabilité des données de réponse autour de la moyenne.

Étape 5 : Prédire des résultats à l'aide du modèle

Maintenant que vous avez évalué le modèle, l'étape suivante consiste à vous en servir pour prédire un résultat. Vous pouvez utiliser le modèle pour prédire le poids de naissance de tous les bébés nés dans le Wyoming.

La requête exécutée pour prédire le résultat est la suivante :

#standardSQL
SELECT
  predicted_weight_pounds
FROM
  ML.PREDICT(MODEL `bqml_tutorial.natality_model`,
    (
    SELECT
      *
    FROM
      `bigquery-public-data.samples.natality`
    WHERE
      state = "WY"))

Détails des requêtes

La toute première instruction SELECT récupère la colonne predicted_weight_pounds. Cette colonne est générée par la fonction ML.PREDICT. Lorsque vous utilisez la fonction ML.PREDICT, le nom de la colonne de résultats pour le modèle est predicted_label_column_name. Pour les modèles de régression linéaire, predicted_label est la valeur estimée de label. Pour les modèles de régression logistique, predicted_label est l'une des deux étiquettes d'entrée, selon celle qui dispose de la probabilité prédite la plus élevée.

La fonction ML.PREDICT sert à prédire les résultats à l'aide de votre modèle : bqml_tutorial.natality_model.

L'instruction SELECT et la clause FROM imbriquées de cette requête sont identiques à celles de la requête CREATE MODEL. Notez qu'il n'est pas nécessaire de transmettre toutes les colonnes comme dans l'entraînement. Seules celles utilisées dans la clause TRANSFORM sont obligatoires. De même que ML.EVALUATE, les transformations effectuées dans TRANSFORM sont automatiquement restaurées.

La clause WHERE – WHERE state = "WY" – indique que vous limitez la prédiction à l'état du Wyoming.

Exécuter la requête ML.PREDICT

Pour exécuter la requête permettant de prédire un résultat à l'aide votre modèle, procédez comme suit :

1. Dans la console Google Cloud, cliquez sur le bouton Saisir une nouvelle requête.

2. Saisissez la requête GoogleSQL suivante dans la zone de texte Éditeur de requête.

   #standardSQL
   SELECT
     predicted_weight_pounds
   FROM
     ML.PREDICT(MODEL `bqml_tutorial.natality_model`,
       (
       SELECT
         *
       FROM
         `bigquery-public-data.samples.natality`
       WHERE
         state = "WY"))
   

3. (Facultatif) Pour définir l'emplacement de traitement, dans la liste déroulante More (Plus), cliquez sur Query settings (Paramètres de requête). Dans le champ Emplacement de traitement, sélectionnez États-Unis (US). Cette étape est facultative, car la zone de traitement est automatiquement détectée selon l'emplacement de l'ensemble de données.

   

4. Cliquez sur Run (Exécuter).

5. Lorsque la requête est terminée, cliquez sur l'onglet Results (Résultats) sous la zone de texte de la requête. Les résultats doivent se présenter sous la forme suivante :

   +----------------------------+
   | predicted_weight_pounds    |
   +----------------------------+
   |  7.735962399307027         |
   +----------------------------+
   |  7.728855793480761         |
   +----------------------------+
   |  7.383850250400428         |
   +----------------------------+
   | 7.4132677633242565         |
   +----------------------------+
   |  7.734971309702814         |
   +----------------------------+
   

Nettoyer

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

• Supprimez le projet que vous avez créé.
• Ou conservez le projet et supprimez l'ensemble de données.

Supprimer l'ensemble de données

La suppression de votre projet entraîne celle de tous les ensembles de données et de toutes les tables qui lui sont associés. Si vous préférez réutiliser le projet, vous pouvez supprimer l'ensemble de données que vous avez créé dans ce tutoriel :

1. Si nécessaire, ouvrez la page BigQuery dans Cloud Console.

   Accéder à BigQuery

2. Dans le panneau de navigation, cliquez sur l'ensemble de données bqml_tutorial que vous avez créé.

3. À droite de la fenêtre, cliquez sur Supprimer l'ensemble de données. Cette action supprime l'ensemble de données, la table et toutes les données.

4. Dans la boîte de dialogue Supprimer l'ensemble de données, confirmez la commande de suppression en saisissant le nom de votre ensemble de données (bqml_tutorial), puis cliquez sur Supprimer.

Supprimer votre projet

Pour supprimer le projet :

Attention : La suppression d'un projet entraîne les effets décrits ci-dessous :

• Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
• Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

Étape suivante

• Pour en savoir plus sur le machine learning, consultez le Cours d'initiation au Machine Learning.
• Pour obtenir plus d'informations sur BigQuery ML, consultez la page Présentation de BigQuery ML.
• Pour en savoir plus sur la console Google Cloud, consultez la page Utiliser la console Google Cloud.