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 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, l'apprentissage non supervisé permet d'obtenir des analyses descriptives. Le machine learning non supervisé peut vous aider à comprendre vos données afin de 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 en savoir plus, consultez la section 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 guide à travers les tâches suivantes:

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

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

Autorisations requises

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

• Pour créer la ressource de connexion, vous devez disposer des autorisations suivantes :

  • bigquery.connections.create
  • bigquery.connections.get

• Pour créer le modèle, vous avez besoin des autorisations suivantes :

  • bigquery.jobs.create
  • bigquery.models.create
  • bigquery.models.getData
  • bigquery.models.updateData
  • bigquery.connections.delegate

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

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.

     

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 distance_from_city_center calculée.

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

1. Dans la console Google Cloud, 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 l'ADC 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

Créer un modèle de k-moyennes

Créez un modèle de k-moyennes à l'aide des données d'entraînement de 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 console Google Cloud, 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 l'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 des modèles 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 console Google Cloud, accédez à la page BigQuery.

   Accéder à BigQuery

2. Dans le volet Explorateur, développez votre projet, développez l'ensemble de données bqml_tutorial, puis développez le dossier Modèles.

3. Sélectionnez le modèle london_station_clusters.

4. 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éristique numérique les plus importantes pour chaque centroïde. Chaque centroid 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 centroids 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 étiez à la tête de cette entreprise de location de vélos, vous pourriez utiliser ces informations pour prendre des décisions commerciales éclairé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.

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

Identifiez le cluster auquel une station donnée appartient à l'aide de la fonction SQL ML.PREDICT ou de la fonction BigQuery DataFrames predict.

SQL

La requête suivante utilise 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 pourraient comprendre ces stations.

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

1. Dans la console Google Cloud, 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')
     ));

Les résultats doivent 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 l'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

Effectuer un nettoyage

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