Créer un modèle de clustering en k-moyennes

BigQuery ML prend en charge avec l'apprentissage non supervisé. Vous pouvez appliquer l'algorithme k-moyennes pour regrouper les données en clusters. Contrairement au machine learning supervisé, qui permet d'effectuer des analyses prédictives, l'apprentissage non supervisé permet d'obtenir des analyses descriptives. L'objectif est de comprendre vos données afin de prendre des décisions en conséquence.

Dans ce tutoriel, vous allez utiliser un modèle de k-moyennes dans BigQuery ML pour créer des clusters de données dans l'ensemble de données public "London Bicycle Hires" (location de vélos à Londres). Les données de l'ensemble "London Bicycle Hires" contiennent le nombre de vélos loués en libre-service auprès du dispositif Santander Cycle de Londres, de 2011 à nos jours. Les données comprennent l'heure de début et de fin de la location, le nom des stations de retrait et la durée de l'emprunt.

Les requêtes figurant dans ce tutoriel utilisent les fonctions de géographie accessibles depuis les SIG BigQuery. Pour en savoir plus sur ces fonctions, reportez-vous à la page Présentation des SIG BigQuery.

Objectifs

Dans ce tutoriel, vous allez :

  • créer un modèle de clustering en k-moyennes ;
  • utiliser Google Data Studio pour visualiser votre modèle ;
  • prendre des décisions basées sur les données à partir de votre modèle.

Coûts

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

  • BigQuery
  • BigQuery ML

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

Pour plus d'informations sur le coût de BigQuery ML, consulter la page Tarifs de BigQuery ML.

Avant de commencer

  1. Connectez-vous à votre compte Google.

    Si vous n'en possédez pas déjà un, vous devez en créer un.

  2. Sélectionnez ou créez un projet Google Cloud Platform.

    Accéder à la page "Gérer les ressources"

  3. Assurez-vous que la facturation est activée pour votre projet Google Cloud Platform.

    Découvrir comment activer la facturation

  4. BigQuery est automatiquement activé dans les nouveaux projets. Pour activer BigQuery dans un projet existant, accédez à Activez BigQueryl'API requise.

    Activer l'API.

Présentation

Il est possible que vos données comprennent des regroupements naturels ou clusters de données. Identifier ces regroupements de manière descriptive pourrait vous aider à prendre des décisions basées sur les données. Par exemple, il peut être utile pour un marchand d'identifier des regroupements naturels de clients qui manifestent les mêmes comportements d'achat ou fréquentent les mêmes lieux. Ce processus est connu sous le nom de segmentation de la clientèle.

Les données que vous exploitez pour la segmentation de la clientèle peuvent inclure le magasin visité, les articles achetés, la somme dépensée, etc. Vous pouvez créer un modèle pour essayer de comprendre et d'identifier le profil de ces groupes de clients, et ainsi développer des articles qui susciteront leur intérêt.

Vous pouvez également distinguer des groupes de produits parmi les articles achetés. Dans ce cas, il suffirait de regrouper les articles en fonction de l'acheteur ainsi que du lieu et de la date d'achat, etc. Le modèle que vous pourriez créer servirait à déterminer les caractéristiques d'un groupe de produits dans le but de prendre des décisions avisées, pour optimiser la vente croisée, par exemple.

Dans ce tutoriel, vous allez créer un modèle de k-moyennes à l'aide de BigQuery ML pour regrouper les données de l'ensemble "London Bicycle Hires" en fonction des attributs des stations de vélos.

La création d'un modèle de k-moyennes comprend les étapes suivantes :

  • Étape 1 : Créer un ensemble de données dans lequel stocker votre modèle
    La première étape consiste à créer un ensemble de données pour y stocker votre modèle. Étant donné que l'ensemble de données "London Bicycle Hires" est stocké dans l'emplacement multirégional EU, votre ensemble de données doit également résider dans l'emplacement EU.
  • Étape 2 : Examiner vos données d'entraînement
    La deuxième étape consiste à examiner les données permettant d'entraîner le modèle de clustering en interrogeant la table london_bicycles. L'algorithme k-moyennes étant une technique d'apprentissage non supervisée, l'entraînement du modèle ne nécessite pas d'étiquettes ni de fractionnement des données en données d'entraînement et d'évaluation.
  • Étape 3 : Créer un modèle de k-moyennes
    La troisième étape consiste à créer un modèle de k-moyennes. Lors de la création du modèle, le champ de clustering est station_name. Vous regroupez les données en fonction des attributs des stations, tels que le nombre de range-vélos et la distance séparant la station du centre-ville.
  • Étape 4 : Prédire le cluster d'une station à l'aide de la fonction ML.PREDICT
    Vous allez ensuite prédire le cluster pour un ensemble de stations donné à l'aide de la fonction ML.PREDICT. Vous allez prédire les clusters pour toutes les stations dont le nom contient la chaîne Kennington.
  • Étape 5 : Visualiser votre modèle
    La cinquième étape consiste à examiner les caractéristiques de chaque cluster à l'aide d'un outil de visualisation. Dans ce tutoriel, vous allez visualiser les clusters à l'aide de Google Data Studio.
  • Étape 6 : Prendre des décisions basées sur les données à l'aide de votre modèle
    La dernière étape consiste à prendre des décisions basées sur les données à partir de votre modèle. Par exemple, le modèle va pouvoir vous aider à identifier les stations qui pourraient bénéficier de capacité supplémentaire.

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

La première étape consiste à créer un ensemble de données BigQuery dans lequel stocker votre modèle. Procédez comme suit :

  1. Accédez à l'UI Web de BigQuery dans la console GCP.

    Accéder à l'UI Web de BigQuery

  2. Dans la section Ressources du panneau de navigation, cliquez sur le nom du projet.

  3. Dans le panneau "Détails" situé à droite, cliquez sur Créer un ensemble de données.

    Créer un ensemble de données

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

    • Dans le champ Dataset ID (ID de l'ensemble de données), saisissez bqml_tutorial.
    • Pour Data location (Emplacement des données), sélectionnez Union européenne (EU). L'ensemble de données "London Bicycle Hires" est stocké dans l'emplacement multirégional EU. Votre ensemble de données doit être stocké dans le même emplacement.

      Créer une page d'ensemble de données

  5. Ne modifiez aucun autre paramètre par défaut et cliquez sur Create dataset (Créer un ensemble de données).

Étape 2 : Examiner vos données d'entraînement

Vous allez ensuite examiner les données ayant servi à l'entraînement de votre modèle de k-moyennes. Dans ce tutoriel, vous allez regrouper les stations de vélos en fonction des attributs suivants :

  • Durée de la location
  • Nombre de trajets par jour
  • Nombre de porte-vélos
  • Distance du centre-ville

La requête ci-dessous permet de compiler vos données d'entraînement. Cette requête est comprise dans l'instruction CREATE MODEL décrite plus loin dans ce tutoriel.

WITH
  hs AS (
  SELECT
    h.start_station_name AS station_name,
    h.duration,
    s.bikes_count,
    ST_DISTANCE(ST_GEOGPOINT(s.longitude,
        s.latitude),
      ST_GEOGPOINT(-0.1,
        51.5))/1000 AS distance_from_city_center
  FROM
    `bigquery-public-data.london_bicycles.cycle_hire` AS h
  JOIN
    `bigquery-public-data.london_bicycles.cycle_stations` AS s
  ON
    h.start_station_id = s.id
  WHERE
    h.start_date BETWEEN CAST('2015-01-01 00:00:00' AS TIMESTAMP)
    AND CAST('2016-01-01 00:00:00' AS TIMESTAMP) ),
  stationstats AS (
  SELECT
    station_name,
    AVG(duration) AS duration,
    COUNT(duration) AS num_trips,
    MAX(bikes_count) AS bikes_count,
    MAX(distance_from_city_center) AS distance_from_city_center
  FROM
    hs
  GROUP BY
    station_name )
SELECT
  *
FROM
  stationstats
ORDER BY
  distance_from_city_center ASC

Détails de la requête

Cette requête extrait les données spécifiques à la location de vélos, telles que start_station_name et duration, puis les fusionne avec les informations de la station, telles que bike_count et distance-from-city-center. Elle calcule ensuite les attributs de la station dans stationstats, y compris la durée moyenne des emprunts et le nombre de trajets, en passant par les attributs de la station bike_count et distance_from_city_center.

Cette requête définit les sous-requêtes à l'aide de la clause WITH. Elle utilise également les fonctions SIG BigQuery ST_DISTANCE et ST_GEOGPOINT. Pour en savoir plus sur ces fonctions, consultez la page Fonctions de géographie. Pour en savoir plus sur les fonctions SIG BigQuery, reportez-vous à la page Présentation des SIG BigQuery.

Exécuter la requête

Pour exécuter la requête permettant de compiler les données d'entraînement pour votre modèle, procédez comme suit :

  1. Dans l'interface utilisateur Web de BigQuery, cliquez sur le bouton Saisir une nouvelle requête.

  2. Saisissez la requête suivante en SQL standard dans la zone de texte Éditeur de requête.

    WITH
      hs AS (
      SELECT
        h.start_station_name AS station_name,
        h.duration,
        s.bikes_count,
        ST_DISTANCE(ST_GEOGPOINT(s.longitude,
            s.latitude),
          ST_GEOGPOINT(-0.1,
            51.5))/1000 AS distance_from_city_center
      FROM
        `bigquery-public-data.london_bicycles.cycle_hire` AS h
      JOIN
        `bigquery-public-data.london_bicycles.cycle_stations` AS s
      ON
        h.start_station_id = s.id
      WHERE
        h.start_date BETWEEN CAST('2015-01-01 00:00:00' AS TIMESTAMP)
        AND CAST('2016-01-01 00:00:00' AS TIMESTAMP) ),
      stationstats AS (
      SELECT
        station_name,
        AVG(duration) AS duration,
        COUNT(duration) AS num_trips,
        MAX(bikes_count) AS bikes_count,
        MAX(distance_from_city_center) AS distance_from_city_center
      FROM
        hs
      GROUP BY
        station_name )
    SELECT
      *
    FROM
      stationstats
    ORDER BY
      distance_from_city_center ASC
    
  3. Cliquez sur Exécuter.

  4. Lorsque la requête est terminée, cliquez sur l'onglet Results (Résultats) sous la zone de texte de la requête. L'onglet des résultats affiche les colonnes interrogées ayant servi à l'entraînement de votre modèle : station_name, duration, num_trips, bikes_count, distance_from_city_center. Les résultats doivent se présenter sous la forme suivante.

    Résultats de la requête

Étape 3 : Créer un modèle de k-moyennes

Après avoir examiné vos données d'entraînement, l'étape suivante consiste à créer un modèle de k-moyennes à l'aide des données.

Vous pouvez créer et entraîner un modèle de k-moyennes à l'aide de l'instruction CREATE MODEL avec l'option model_type=kmeans. La requête ci-dessous ajoute une instruction CREATE MODEL à la requête précédente et supprime les champs id des données.

CREATE OR REPLACE MODEL
  bqml_tutorial.london_station_clusters
OPTIONS
  (model_type='kmeans',
    num_clusters=4,
    standardize_features = TRUE) AS
WITH
  hs AS (
  SELECT
    h.start_station_name AS station_name,
    h.duration,
    s.bikes_count,
    ST_DISTANCE(ST_GEOGPOINT(s.longitude,
        s.latitude),
      ST_GEOGPOINT(-0.1,
        51.5))/1000 AS distance_from_city_center
  FROM
    `bigquery-public-data.london_bicycles.cycle_hire` AS h
  JOIN
    `bigquery-public-data.london_bicycles.cycle_stations` AS s
  ON
    h.start_station_id = s.id
  WHERE
    h.start_date BETWEEN CAST('2015-01-01 00:00:00' AS TIMESTAMP)
    AND CAST('2016-01-01 00:00:00' AS TIMESTAMP) ),
  stationstats AS (
  SELECT
    station_name,
    AVG(duration) AS duration,
    COUNT(duration) AS num_trips,
    MAX(bikes_count) AS bikes_count,
    MAX(distance_from_city_center) AS distance_from_city_center
  FROM
    hs
  GROUP BY
    station_name )
SELECT
  * EXCEPT(station_name,
    isweekday)
FROM
  stationstats

Détails de la requête

L'instruction CREATE MODEL spécifie le nombre de clusters souhaité. Dans l'instruction SELECT, la clause EXCEPT exclut la colonne station_name, car station_name n'est pas une caractéristique. La requête crée une ligne unique par "station_name", et seules les caractéristiques sont mentionnées dans l'instruction SELECT.

Il est recommandé de normaliser les caractéristiques si elles sont associées à des plages dynamiques différentes. Ici, bikes_count se situe dans la plage 10-50, alors que num_trips se compte en milliers. Ainsi, l'option standardize_features est définie sur true. Cette opération est facultative, car l'option standardize_features est définie sur true par défaut.

Si vous omettez de spécifier l'option num_clusters, BigQuery ML choisira une valeur par défaut raisonnable en fonction du nombre total de lignes compris dans les données d'entraînement. Vous pouvez également effectuer un réglage des hyperparamètres pour trouver une valeur adéquate. Pour déterminer le nombre optimal de clusters, vous devez exécuter la requête CREATE MODEL pour obtenir différentes valeurs de num_clusters, trouver la mesure d'erreur, puis sélectionner le point où la mesure d'erreur atteint sa valeur minimale. Pour obtenir la mesure d'erreur, sélectionnez votre modèle et cliquez sur l'onglet Training (Entraînement). Celui-ci affiche l'indice de Davies-Bouldin.

Onglet "Entraînement"

Exécuter la requête CREATE MODEL

Pour exécuter la requête permettant de créer votre modèle de k-moyennes, procédez comme suit :

  1. Dans l'interface utilisateur Web de BigQuery, cliquez sur le bouton Saisir une nouvelle requête.

  2. Saisissez la requête suivante en SQL standard dans la zone de texte Éditeur de requête.

    CREATE OR REPLACE MODEL
      bqml_tutorial.london_station_clusters
    OPTIONS
      (model_type='kmeans',
        num_clusters=4,
        standardize_features = TRUE) AS
    WITH
      hs AS (
      SELECT
        h.start_station_name AS station_name,
        h.duration,
        s.bikes_count,
        ST_DISTANCE(ST_GEOGPOINT(s.longitude,
            s.latitude),
          ST_GEOGPOINT(-0.1,
            51.5))/1000 AS distance_from_city_center
      FROM
        `bigquery-public-data.london_bicycles.cycle_hire` AS h
      JOIN
        `bigquery-public-data.london_bicycles.cycle_stations` AS s
      ON
        h.start_station_id = s.id
      WHERE
        h.start_date BETWEEN CAST('2015-01-01 00:00:00' AS TIMESTAMP)
        AND CAST('2016-01-01 00:00:00' AS TIMESTAMP) ),
      stationstats AS (
      SELECT
        station_name,
        AVG(duration) AS duration,
        COUNT(duration) AS num_trips,
        MAX(bikes_count) AS bikes_count,
        MAX(distance_from_city_center) AS distance_from_city_center
      FROM
        hs
      GROUP BY
        station_name )
    SELECT
      * EXCEPT(station_name)
    FROM
      stationstats
    
  3. Cliquez sur Exécuter.

  4. Dans la section Ressources de l'interface utilisateur Web de BigQuery, développez [ID_PROJET] > bqml_tutorial puis cliquez sur london_station_clusters.

  5. Cliquez sur l'onglet Schema (Schéma). Le schéma de modèle répertorie les quatre attributs de station permettant à BigQuery ML de procéder au clustering. Le fichier doit se présenter comme suit :

    Informations sur le schéma du cluster

Étape 4 : Prédire le cluster d'une station à l'aide de la fonction ML.PREDICT

Exécutez la fonction ML.PREDICT pour déterminer l'appartenance d'un cluster à une station. La requête ci-dessous prédit le cluster de toutes les stations dont le nom contient la chaîne "Kennington".

WITH
  hs AS (
  SELECT
    h.start_station_name AS station_name,
    h.duration,
    s.bikes_count,
    ST_DISTANCE(ST_GEOGPOINT(s.longitude,
        s.latitude),
      ST_GEOGPOINT(-0.1,
        51.5))/1000 AS distance_from_city_center
  FROM
    `bigquery-public-data.london_bicycles.cycle_hire` AS h
  JOIN
    `bigquery-public-data.london_bicycles.cycle_stations` AS s
  ON
    h.start_station_id = s.id
  WHERE
    h.start_date BETWEEN CAST('2015-01-01 00:00:00' AS TIMESTAMP)
    AND CAST('2016-01-01 00:00:00' AS TIMESTAMP) ),
  stationstats AS (
  SELECT
    station_name,
    AVG(duration) AS duration,
    COUNT(duration) AS num_trips,
    MAX(bikes_count) AS bikes_count,
    MAX(distance_from_city_center) AS distance_from_city_center
  FROM
    hs
  GROUP BY
    station_name )
SELECT
  * EXCEPT(nearest_centroids_distance)
FROM
  ML.PREDICT( MODEL bqml_tutorial.london_station_clusters,
    (
    SELECT
      *
    FROM
      stationstats
    WHERE
      REGEXP_CONTAINS(station_name, 'Kennington')))

Détails de la requête

Cette requête se sert de la fonction REGEXP_CONTAINS pour trouver toutes les entrées de la colonne station_name contenant la chaîne "Kennington". Ces valeurs permettent à la fonction ML.PREDICT d'identifier les clusters qui comprennent ces stations.

Exécuter la requête ML.PREDICT

Pour exécuter la requête ML.PREDICT, procédez comme suit :

  1. Dans l'interface utilisateur Web de BigQuery, cliquez sur le bouton Saisir une nouvelle requête.

  2. Saisissez la requête suivante en SQL standard dans la zone de texte Éditeur de requête.

    WITH
      hs AS (
      SELECT
        h.start_station_name AS station_name,
        h.duration,
        s.bikes_count,
        ST_DISTANCE(ST_GEOGPOINT(s.longitude,
            s.latitude),
          ST_GEOGPOINT(-0.1,
            51.5))/1000 AS distance_from_city_center
      FROM
        `bigquery-public-data.london_bicycles.cycle_hire` AS h
      JOIN
        `bigquery-public-data.london_bicycles.cycle_stations` AS s
      ON
        h.start_station_id = s.id
      WHERE
        h.start_date BETWEEN CAST('2015-01-01 00:00:00' AS TIMESTAMP)
        AND CAST('2016-01-01 00:00:00' AS TIMESTAMP) ),
      stationstats AS (
      SELECT
        station_name,
        AVG(duration) AS duration,
        COUNT(duration) AS num_trips,
        MAX(bikes_count) AS bikes_count,
        MAX(distance_from_city_center) AS distance_from_city_center
      FROM
        hs
      GROUP BY
        station_name )
    SELECT
      * EXCEPT(nearest_centroids_distance)
    FROM
      ML.PREDICT( MODEL bqml_tutorial.london_station_clusters,
        (
        SELECT
          *
        FROM
          stationstats
        WHERE
          REGEXP_CONTAINS(station_name, 'Kennington')))
    
  3. Cliquez sur Exécuter.

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

    Résultats de ML.PREDICT

Étape 5 : Visualiser votre modèle

Chaque cluster possède une valeur pour chacune des colonnes utilisées comme entrée. Pour récupérer ces valeurs, exécutez la fonction ML.CENTROIDS, comme dans la requête SQL standard suivante.

SELECT
  *
FROM
  ML.CENTROIDS(MODEL bqml_tutorial.london_station_clusters)
ORDER BY
  centroid_id

Pour exécuter la requête ML.CENTROIDS, procédez comme suit :

  1. Dans l'interface utilisateur Web de BigQuery, cliquez sur le bouton Saisir une nouvelle requête.

  2. Saisissez la requête suivante en SQL standard dans la zone de texte Éditeur de requête.

    SELECT
      *
    FROM
      ML.CENTROIDS(MODEL bqml_tutorial.london_station_clusters)
    ORDER BY
      centroid_id
    
  3. 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.

    Résultats de ML.CENTROIDS

  4. Pour comparer plus facilement les valeurs respectives pour chaque cluster, réorganisez les résultats de la requête ci-dessus à l'aide de l'opérateur UNNEST. Saisissez la requête suivante en SQL standard dans la zone de texte Éditeur de requête.

    WITH
      T AS (
      SELECT
        centroid_id,
        ARRAY_AGG(STRUCT(feature AS name,
            ROUND(numerical_value,1) AS value)
        ORDER BY
          centroid_id) AS cluster
      FROM
        ML.CENTROIDS(MODEL bqml_tutorial.london_station_clusters)
      GROUP BY
        centroid_id )
    SELECT
      CONCAT('Cluster#', CAST(centroid_id AS STRING)) AS centroid,
      (
      SELECT
        value
      FROM
        UNNEST(cluster)
      WHERE
        name = 'duration') AS duration,
      (
      SELECT
        value
      FROM
        UNNEST(cluster)
      WHERE
        name = 'num_trips') AS num_trips,
      (
      SELECT
        value
      FROM
        UNNEST(cluster)
      WHERE
        name = 'bikes_count') AS bikes_count,
      (
      SELECT
        value
      FROM
        UNNEST(cluster)
      WHERE
        name = 'distance_from_city_center') AS distance_from_city_center
    FROM
      T
    ORDER BY
      duration DESC
    
  5. Cliquez sur Exécuter.

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

    Réorganiser les résultats

Visualiser les résultats dans Google Data Studio

Pour visualiser les résultats dans Google Data Studio, procédez comme suit :

  1. Cliquez sur Explorer dans Data Studio au-dessus des résultats de la requête.

  2. Cliquez sur Premiers pas pour accepter les conditions d'utilisation. Si vous avez déjà utilisé Google Data Studio, cette boîte de dialogue ne s'affichera peut-être pas.

  3. Dans l'outil de sélection de graphiques, cliquez sur Table with bars (Tableaux à barres).

    Icône de graphique à barres dans l'outil de sélection des graphiques

  4. Dans l'onglet Data (Données), vérifiez que l'option Dimension est définie sur la colonne centroid.

    Section "Dimension" de Google Data Studio

  5. Dans la section Métrique, passez la souris sur la métrique par défaut, probablement Record Count, puis cliquez sur le signe "X" pour la supprimer.

  6. Faites glisser les éléments suivants depuis la section Champs disponibles vers la zone Ajouter une métrique : bikes_count, distance_from_city_center, duration et num_trips. Le graphique doit se présenter sous la forme suivante :

    Graphique terminé

Pour obtenir de l'aide concernant la configuration des composants de graphique dans Google Data Studio, reportez-vous à la page Ajouter et configurer des composants du centre d'aide Google Data Studio.

Étape 6 : Prendre des décisions basées sur les données à l'aide de votre modèle

La visualisation des résultats peut vous aider à interpréter les différents clusters. Dans cet exemple, Cluster#4 indique un nombre d'emprunts relativement faible, une distance modérée du centre-ville et des trajets longs. On peut en conclure que les stations comprises dans Cluster#4 sont des stations de banlieue avec une sollicitation plus faible.

Cluster#1 indique une distance élevée du centre-ville et des trajets longs, mais un nombre d'emprunts plus faible. On peut en conclure qu'il s'agit d'autres stations de banlieue peu sollicitées.

Cluster#2 indique un plus grand nombre de trajets et une distance plus proche du centre-ville. On peut en conclure qu'il s'agit de stations urbaines relativement sollicitées.

Cluster#3 indique une distance proche du centre-ville et un très grand nombre de trajets. On peut en conclure qu'il s'agit de stations urbaines très sollicitées.

En fonction de ces résultats, vous pouvez exploiter les données pour prendre des décisions avisées. Exemple :

  • Supposons que vous souhaitiez essayer un nouveau type d'antivol. Quel cluster de stations choisir pour cette expérience ? Les stations du Cluster#4 constituent un choix logique puisqu'elles comportent un nombre élevé de vélos, ce qui semble propice à l'exécution d'un test A/B.

  • Supposons que vous souhaitiez munir certaines stations de vélos de course. Quelles stations devriez-vous choisir ? Cluster#1 regroupe les stations les plus éloignées du centre-ville et affichant les trajets les plus longs. Elles semblent aptes à proposer des vélos de course.

  • Vous avez reçu des fonds supplémentaires et souhaitez améliorer la capacité d'une station. Quelles stations pourraient bénéficier de vélos supplémentaires ? Cluster#2 enregistre le plus faible nombre de vélos et le deuxième plus grand nombre de trajets. Ainsi, ces stations semblent de bonnes candidates pour recevoir des vélos supplémentaires.

Effectuer un nettoyage

Afin d'éviter que des frais ne soient facturés sur votre compte Google Cloud Platform pour les ressources utilisées dans ce tutoriel, procédez comme suit :

  • 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 l'UI Web de BigQuery.

    Accéder à l'UI Web de BigQuery

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

  3. Cliquez sur Delete dataset (Supprimer l'ensemble de données) dans la partie droite de la fenêtre. Cette action supprime l'ensemble de données et le modèle.

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

Supprimer le projet

Pour supprimer le projet, procédez comme suit :

  1. Dans la console GCP, accédez à la page "Projets".

    Accéder à la page Projets

  2. Dans la liste des projets, sélectionnez celui que vous souhaitez supprimer, puis cliquez sur Supprimer.
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Étapes suivantes

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Documentation sur BigQuery ML