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

Ce tutoriel vous explique comment utiliser un modèle de k-moyennes dans BigQuery ML pour identifier des clusters dans un ensemble de données.

L'algorithme de k-moyennes qui regroupe vos données en clusters est une forme de machine learning non supervisé. Contrairement au machine learning supervisé, qui permet d'effectuer des analyses prédictives, le machine learning non supervisé permet d'obtenir des analyses descriptives. Le machine learning non supervisé peut vous aider à comprendre vos données afin que vous puissiez prendre des décisions basées sur les données.

Les requêtes de ce tutoriel utilisent les fonctions de géographie disponibles dans l'analyse géospatiale. Pour plus d'informations, consultez la page Présentation des analyses géospatiales.

Ce tutoriel utilise l' ensemble de données public "London Bicycle Hires". 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.

Objectifs

Ce tutoriel vous explique comment effectuer les tâches suivantes :

• Examiner les données utilisées pour entraîner le modèle.
• Créer un modèle de clustering en k-moyennes.
• Interpréter les clusters de données produits à l'aide de la visualisation des clusters de BigQuery ML.
• Exécuter la ML.PREDICT fonction sur le modèle de k-moyennes pour prédire le cluster probable d'un ensemble de stations de location de vélos.

Coûts

Ce tutoriel fait appel à des composants payants de Google Cloud, y compris les suivants :

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

   Roles required to select or create a project

   • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
   • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
   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

2. Verify that billing is enabled for your Google Cloud project.

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

   Activez l'API BigQuery.

   Rôles requis pour activer les API

   Pour activer les API, vous avez besoin de l'autorisation serviceusage.services.enable. Si vous avez créé le projet, vous disposez probablement déjà de cette autorisation via le rôle Propriétaire (roles/owner). Sinon, vous pouvez obtenir cette autorisation via le rôle Administrateur d'utilisation du service (roles/serviceusage.serviceUsageAdmin). Découvrez comment attribuer des rôles.

   Activer l'API

Autorisations requises

• Pour créer l'ensemble de données, vous devez disposer de l'autorisation IAM bigquery.datasets.create.

• Pour créer le modèle, vous avez besoin 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.models.getData
  • bigquery.jobs.create

Pour plus d'informations sur les rôles et les autorisations IAM dans BigQuery, consultez la page Présentation d'IAM.

Créer un ensemble de données

Créez un ensemble de données BigQuery pour stocker votre modèle de k-moyennes :

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

   Accéder à la page "BigQuery"

2. Dans le volet de gauche, cliquez sur Explorateur:

   

   Si le volet de gauche ne s'affiche pas, cliquez sur Développer le volet de gauche pour l'ouvrir.

3. Dans le volet Explorateur, cliquez sur le nom de votre projet.

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

   

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

     

Examiner les données d'entraînement

Examinez les données que vous utiliserez 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

Cette requête extrait les données spécifiques à la location de vélos, y compris les colonnes start_station_name et duration, puis les fusionne avec les informations de la station. Cela inclut la création d'une colonne de calcul contenant la distance de la station par rapport au centre-ville. Elle calcule ensuite les attributs de la station dans une colonne stationstats, y compris la durée moyenne d'utilisation et le nombre de trajets, ainsi que la colonne calculée distance_from_city_center.

Pour examiner les données d'entraînement, procédez comme suit :

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

   Accéder à BigQuery

2. Dans l'éditeur de requête, collez la requête suivante, puis cliquez sur Exécuter :

   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;

Le résultat doit ressembler à ce qui suit :

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 Configurer les ADC pour un environnement de développement local.

import datetime
import typing

import pandas as pd
from shapely.geometry import Point

import bigframes
import bigframes.bigquery as bbq
import bigframes.geopandas
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",
    }
)

# Use GeoSeries.from_xy and BigQuery.st_distance to analyze geographical
# data. These functions determine spatial relationships between
# geographical features.
cycle_stations = bpd.read_gbq("bigquery-public-data.london_bicycles.cycle_stations")
s = bpd.DataFrame(
    {
        "id": cycle_stations["id"],
        "xy": bigframes.geopandas.GeoSeries.from_xy(
            cycle_stations["longitude"], cycle_stations["latitude"]
        ),
    }
)
s_distance = bbq.st_distance(s["xy"], Point(-0.1, 51.5), use_spheroid=False) / 1000
s = bpd.DataFrame({"id": s["id"], "distance_from_city_center": s_distance})

# 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 = typing.cast(
    bpd.DataFrame,
    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

Créer un modèle de k-moyennes

Créez un modèle de k-moyennes à l'aide des données d'entraînement "London Bicycle Hires".

SQL

Dans la requête suivante, 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 cette colonne ne contient pas de 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.

Pour créer un modèle de k-moyennes, procédez comme suit :

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

   Accéder à BigQuery

2. Dans l'éditeur de requête, collez la requête suivante, puis cliquez sur Exécuter :

   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;

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 Configurer les ADC 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,
)

Interpréter les clusters de données

Les informations de l'onglet Évaluation du modèle peuvent vous aider à interpréter les clusters produits par le modèle.

Pour afficher les informations d'évaluation du modèle, procédez comme suit :

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

   Accéder à BigQuery

2. Dans le volet de gauche, cliquez sur Explorateur:

   

3. Dans le volet Explorateur, développez votre projet et cliquez sur Ensembles de données.

4. Cliquez sur l'ensemble de données bqml_tutorial, puis accédez à l'onglet Modèles.

5. Sélectionnez le modèle london_station_clusters.

6. Sélectionnez l'onglet Évaluation. Cet onglet affiche les visualisations des clusters identifiés par le modèle de k-moyennes. Dans la section Caractéristiques numériques, les graphiques à barres affichent les valeurs de caractéristiques numériques les plus importantes pour chaque centroïde. Chaque centroïde représente un cluster de données donné. Le menu déroulant permet de sélectionner les caractéristiques à afficher.

   

   Ce modèle crée les centroïdes suivants :

   • Le centroïde 1 indique une station urbaine moins sollicitée, avec des durées de location plus courtes.
   • 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 3 montre une station urbaine très sollicitée proche du centre-ville.
   • Le centroïde 4 indique une station de banlieue avec des trajets plus longs.

   Si vous gériez une entreprise de location de vélos, vous pourriez utiliser ces informations pour prendre des décisions commerciales. 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.

Utiliser la fonction ML.PREDICT pour prédire le cluster d'une station

Déterminez le cluster auquel appartient une station particulière à l'aide de la ML.PREDICT fonction SQL ou de la predict fonction BigQuery DataFrames.

SQL

La requête suivante utilise la REGEXP_CONTAINS fonction 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.

Pour prédire le cluster de toutes les stations dont le nom contient la chaîne Kennington, procédez comme suit :

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

   Accéder à BigQuery

2. Dans l'éditeur de requête, collez la requête suivante, puis cliquez sur Exécuter :

   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')
     ));

Le résultat doit ressembler à ce qui suit.

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 Configurer les ADC 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

Libérer de l'espace

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

Si vous supprimez votre projet, tous les ensembles de données et toutes les tables qui lui sont associés sont également supprimé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 la Google Cloud console.

   Accéder à la page "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 aura les effets suivants :

• 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. Dans la Google Cloud console, accédez à la page Gérer les ressources.

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

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

Étape suivante

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