Créer un modèle de k-moyennes pour regrouper l'ensemble de données sur les locations de vélos à Londres

---

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 utilisez 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 de ce tutoriel utilisent les fonctions de géographie disponibles dans l'analyse géospatiale. Pour plus d'informations sur les analyses géospatiales, consultez la page Présentation des analyses géospatiales.

Objectifs

Dans ce tutoriel, vous allez :

• créer un modèle de clustering en k-moyennes ;
• Prenez des décisions basées sur les données à partir de la visualisation des clusters dans BigQuery ML.

Coûts

Ce tutoriel utilise des composants facturables de Google Cloud, y compris :

• BigQuery
• BigQuery ML

Pour en savoir plus sur le coût de BigQuery, consultez la page Tarifs de BigQuery.

Pour en savoir plus sur les coûts associés à BigQuery ML, consultez la page Tarifs de BigQuery ML.

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.

   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

Introduction

Vos données peuvent contenir des regroupements naturels ou des clusters de données, et il peut être intéressant de les identifier de manière descriptive afin de prendre des décisions en conséquence. Par exemple, si vous êtes un marchand, vous pouvez identifier des regroupements naturels de clients ayant des habitudes ou des lieux d'achat similaires. 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 et le montant payé. 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 clusters en fonction de l'acheteur, du lieu et de la date d'achat, ainsi que d'autres caractéristiques similaires. 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 clusters 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.

  Remarque : É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 : 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

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 Explorateur, 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 UE (plusieurs régions dans l'Union européenne).

     L'ensemble de données public "London Bicycle Hires" est stocké dans l'emplacement multirégional EU. Votre ensemble de données doit être stocké 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 : Examiner vos données d'entraînement

Ensuite, examinez les données utilisées pour entraîner 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
• Distance du centre-ville

SQL

La requête GoogleSQL suivante permet d'examiner les données utilisées pour entraîner votre modèle de k-moyennes.

#standardSQL
WITH
hs AS (
SELECT
  h.start_station_name AS station_name,
  IF
  (EXTRACT(DAYOFWEEK
    FROM
      h.start_date) = 1
    OR EXTRACT(DAYOFWEEK
    FROM
      h.start_date) = 7,
    "weekend",
    "weekday") AS isweekday,
  h.duration,
  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,
  isweekday,
  AVG(duration) AS duration,
  COUNT(duration) AS num_trips,
  MAX(distance_from_city_center) AS distance_from_city_center
FROM
  hs
GROUP BY
  station_name, isweekday )
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 distance-from-city-center. Elle calcule ensuite les attributs de la station dans stationstats, y compris la durée moyenne d'utilisation et le nombre de trajets, en passant par les attributs de la station distance_from_city_center.

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

Exécuter la requête

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

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

1. Accédez à la page BigQuery.

Accéder à BigQuery

1. Dans le volet de l'éditeur, exécutez l'instruction SQL suivante :

   
   WITH
     hs AS (
     SELECT
       h.start_station_name AS station_name,
       IF
       (EXTRACT(DAYOFWEEK
         FROM
           h.start_date) = 1
         OR EXTRACT(DAYOFWEEK
         FROM
           h.start_date) = 7,
         "weekend",
         "weekday") AS isweekday,
       h.duration,
       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,
       isweekday,
       AVG(duration) AS duration,
       COUNT(duration) AS num_trips,
       MAX(distance_from_city_center) AS distance_from_city_center
     FROM
       hs
     GROUP BY
       station_name, isweekday )
   SELECT
     *
   FROM
     stationstats
   ORDER BY
     distance_from_city_center ASC
   
   

2. 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, distance_from_city_center. Les résultats doivent se présenter sous la forme suivante.

BigQuery DataFrames

Avant d'essayer cet exemple, suivez les instructions de configuration pour BigQuery DataFrames du guide de démarrage rapide de BigQuery DataFrames. Pour en savoir plus, consultez la documentation de référence sur BigQuery DataFrames.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour un environnement de développement local.

import datetime

import pandas as pd

import bigframes
import bigframes.pandas as bpd

bigframes.options.bigquery.project = your_gcp_project_id
# Compute in the EU multi-region to query the London bicycles dataset.
bigframes.options.bigquery.location = "EU"

# Extract the information you'll need to train the k-means model in this
# tutorial. Use the read_gbq function to represent cycle hires
# data as a DataFrame.
h = bpd.read_gbq(
    "bigquery-public-data.london_bicycles.cycle_hire",
    col_order=["start_station_name", "start_station_id", "start_date", "duration"],
).rename(
    columns={
        "start_station_name": "station_name",
        "start_station_id": "station_id",
    }
)

s = bpd.read_gbq(
    # Use ST_GEOPOINT and ST_DISTANCE to analyze geographical
    # data. These functions determine spatial relationships between
    # geographical features.
    """
    SELECT
    id,
    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_stations` s
    """
)

# Define Python datetime objects in the UTC timezone for range comparison,
# because BigQuery stores timestamp data in the UTC timezone.
sample_time = datetime.datetime(2015, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc)
sample_time2 = datetime.datetime(2016, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc)

h = h.loc[(h["start_date"] >= sample_time) & (h["start_date"] <= sample_time2)]

# Replace each day-of-the-week number with the corresponding "weekday" or
# "weekend" label by using the Series.map method.
h = h.assign(
    isweekday=h.start_date.dt.dayofweek.map(
        {
            0: "weekday",
            1: "weekday",
            2: "weekday",
            3: "weekday",
            4: "weekday",
            5: "weekend",
            6: "weekend",
        }
    )
)

# Supplement each trip in "h" with the station distance information from
# "s" by merging the two DataFrames by station ID.
merged_df = h.merge(
    right=s,
    how="inner",
    left_on="station_id",
    right_on="id",
)

# Engineer features to cluster the stations. For each station, find the
# average trip duration, number of trips, and distance from city center.
stationstats = merged_df.groupby(["station_name", "isweekday"]).agg(
    {"duration": ["mean", "count"], "distance_from_city_center": "max"}
)
stationstats.columns = pd.Index(
    ["duration", "num_trips", "distance_from_city_center"]
)
stationstats = stationstats.sort_values(
    by="distance_from_city_center", ascending=True
).reset_index()

# Expected output results: >>> stationstats.head(3)
# station_name	isweekday duration  num_trips	distance_from_city_center
# Borough Road...	weekday	    1110	    5749	    0.12624
# Borough Road...	weekend	    2125	    1774	    0.12624
# Webber Street...	weekday	    795	        6517	    0.164021
#   3 rows × 5 columns

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

SQL

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.

Détails de la requête

L'instruction CREATE MODEL spécifie le nombre de clusters à utiliser, soit quatre. 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.

Si vous omettez l'option num_clusters, BigQuery ML choisit 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 Évaluation. Cet onglet affiche l'index de Davies-Bouldin.

Exécuter la requête

La requête suivante ajoute une instruction CREATE MODEL à la requête que vous avez utilisée pour examiner les données d'entraînement, et supprime également les champs id des données.

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

1. Accédez à la page BigQuery.

Accéder à BigQuery

1. Dans le volet de l'éditeur, exécutez l'instruction SQL suivante :

   
   CREATE OR REPLACE MODEL `bqml_tutorial.london_station_clusters`
     OPTIONS(model_type='kmeans', num_clusters=4) AS
   WITH
     hs AS (
     SELECT
       h.start_station_name AS station_name,
     IF
       (EXTRACT(DAYOFWEEK
         FROM
           h.start_date) = 1
         OR EXTRACT(DAYOFWEEK
         FROM
           h.start_date) = 7,
         "weekend",
         "weekday") AS isweekday,
       h.duration,
       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,
       isweekday,
       AVG(duration) AS duration,
       COUNT(duration) AS num_trips,
       MAX(distance_from_city_center) AS distance_from_city_center
     FROM
       hs
     GROUP BY
       station_name, isweekday)
   SELECT
     * EXCEPT(station_name, isweekday)
   FROM
     stationstats
    
   

2. Dans le panneau de navigation, dans la section Ressources, développez le nom de votre projet, cliquez sur bqml_tutorial, puis sur london_station_clusters.

3. 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 :

1. Cliquez sur l'onglet Évaluation. Cet onglet affiche les visualisations des clusters identifiés par le modèle de k-moyennes. Sous Caractéristiques numériques, les graphiques à barres affichent jusqu'à 10 caractéristiques numériques les plus importantes pour chaque centroïde. Le menu déroulant permet de sélectionner les caractéristiques à afficher.

BigQuery DataFrames

Avant d'essayer cet exemple, suivez les instructions de configuration pour BigQuery DataFrames du guide de démarrage rapide de BigQuery DataFrames. Pour en savoir plus, consultez la documentation de référence sur BigQuery DataFrames.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour un environnement de développement local.

from bigframes.ml.cluster import KMeans

# To determine an optimal number of clusters, construct and fit several
# K-Means objects with different values of num_clusters, find the error
# measure, and pick the point at which the error measure is at its minimum
# value.
cluster_model = KMeans(n_clusters=4)
cluster_model.fit(stationstats)
cluster_model.to_gbq(
    your_model_id,  # For example: "bqml_tutorial.london_station_clusters"
    replace=True,
)

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

Pour déterminer l'appartenance d'une station à un cluster, utilisez la fonction SQL ML.PREDICT ou la fonction DataFrames BigQuery predict.

SQL

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

La requête ci-dessous prédit le cluster de toutes les stations dont le nom contient la chaîne "Kennington".

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

1. Accédez à la page BigQuery.

Accéder à BigQuery

1. Dans le volet de l'éditeur, exécutez l'instruction SQL suivante :

   
   WITH
     hs AS (
     SELECT
       h.start_station_name AS station_name,
       IF
       (EXTRACT(DAYOFWEEK
         FROM
           h.start_date) = 1
         OR EXTRACT(DAYOFWEEK
         FROM
           h.start_date) = 7,
         "weekend",
         "weekday") AS isweekday,
       h.duration,
       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,
       isweekday,
       AVG(duration) AS duration,
       COUNT(duration) AS num_trips,
       MAX(distance_from_city_center) AS distance_from_city_center
     FROM
       hs
     GROUP BY
       station_name, isweekday )
   SELECT
     * EXCEPT(nearest_centroids_distance)
   FROM
     ML.PREDICT( MODEL `bqml_tutorial.london_station_clusters`,
       (
       SELECT
         *
       FROM
         stationstats
       WHERE
         REGEXP_CONTAINS(station_name, 'Kennington')))
   
   

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

   

BigQuery DataFrames

Avant d'essayer cet exemple, suivez les instructions de configuration pour BigQuery DataFrames du guide de démarrage rapide de BigQuery DataFrames. Pour en savoir plus, consultez la documentation de référence sur BigQuery DataFrames.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour un environnement de développement local.

# Select model you'll use for predictions. `read_gbq_model` loads model
# data from BigQuery, but you could also use the `cluster_model` object
# from previous steps.
cluster_model = bpd.read_gbq_model(
    your_model_id,
    # For example: "bqml_tutorial.london_station_clusters",
)

# Use 'contains' function to filter by stations containing the string
# "Kennington".
stationstats = stationstats.loc[
    stationstats["station_name"].str.contains("Kennington")
]

result = cluster_model.predict(stationstats)

# Expected output results:   >>>results.peek(3)
# CENTROID...	NEAREST...	station_name  isweekday	 duration num_trips dist...
# 	1	[{'CENTROID_ID'...	Borough...	  weekday	  1110	    5749	0.13
# 	2	[{'CENTROID_ID'...	Borough...	  weekend	  2125      1774	0.13
# 	1	[{'CENTROID_ID'...	Webber...	  weekday	  795	    6517	0.16
#   3 rows × 7 columns

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

Les résultats de l'évaluation peuvent vous aider à interpréter les différents clusters. Dans l'exemple suivant, le centroïde 3 montre une station urbaine très sollicitée proche du centre-ville. Le centroïde 2 indique la deuxième station urbaine, moins sollicitée et utilisée pour des durées de location plus longues. Le centroïde 1 indique une station urbaine moins sollicitée, avec des durées de location plus courtes. Le centroïde 4 indique une station de banlieue avec des trajets plus longs.

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 centroïde 1, du centroïde 2 ou du centroïde 4 semblent être des choix logiques, car ce ne sont pas les stations les plus sollicitées.

• Supposons que vous souhaitiez munir certaines stations de vélos de course. Quelles stations devriez-vous choisir ? Le centroïde 4 regroupe les stations les plus éloignées du centre-ville, avec les trajets les plus longs. Elles semblent appropriées pour proposer des vélos de course.

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

Étapes suivantes

• Pour obtenir plus d'informations sur BigQuery ML, consultez la page Présentation de BigQuery ML.
• Pour plus d'informations sur la création de modèles, consultez la page sur la syntaxe de CREATE MODEL.