Crea un modello K-means per raggruppare il set di dati sui noleggi di biciclette a Londra

Questo tutorial ti insegna a utilizzare un modello k-means in BigQuery ML per identificare i cluster in un insieme di dati.

L'algoritmo k-means che raggruppa i dati in cluster è una forma di machine learning non supervisionato. A differenza del machine learning supervisionato, che si occupa di analisi predittiva, il machine learning non supervisionato si occupa di analisi descrittiva. L'apprendimento automatico non supervisionato può aiutarti a comprendere i tuoi dati in modo da poter prendere decisioni basate sui dati.

Le query di questo tutorial utilizzano le funzioni geografiche disponibili in geospatial analytics. Per saperne di più, consulta la pagina Introduzione all'analisi geospaziale.

Questo tutorial utilizza il set di dati pubblico London Bicycle Hires. I dati includono timestamp di inizio e fine, nomi delle stazioni e durata della corsa.

Crea un set di dati

Crea un set di dati BigQuery per archiviare il modello k-means:

1. Nella console Google Cloud , vai alla pagina BigQuery.

   Vai alla pagina BigQuery

2. Nel riquadro a sinistra, fai clic su Explorer:

   

   Se non vedi il riquadro a sinistra, fai clic su Espandi riquadro a sinistra per aprirlo.

3. Nel riquadro Explorer, fai clic sul nome del progetto.

4. Fai clic su Visualizza azioni > Crea set di dati.

   

5. Nella pagina Crea set di dati:

   • In ID set di dati, inserisci bqml_tutorial.

   • Per Tipo di località, seleziona Più regioni e poi UE (più regioni nell'Unione Europea).

     Il set di dati pubblico London Bicycle Hires è archiviato nella località con più regioni EU. Il set di dati deve trovarsi nella stessa località.

   • Lascia invariate le restanti impostazioni predefinite e fai clic su Crea set di dati.

     

Esaminare i dati di addestramento

Esamina i dati che utilizzerai per addestrare il modello k-means. In questo tutorial, raggruppi le stazioni di biciclette in base ai seguenti attributi:

• Durata dei noleggi
• Numero di viaggi al giorno
• Distanza dal centro città

SQL

Questa query estrae i dati sui noleggi di biciclette, incluse le colonne start_station_name e duration, e li unisce alle informazioni sulle stazioni. Ciò include la creazione di una colonna calcolata che contiene la distanza della stazione dal centro città. Poi calcola gli attributi della stazione in una colonna stationstats, inclusi la durata media delle corse e il numero di viaggi, e la colonna distance_from_city_center calcolata.

Per esaminare i dati di addestramento:

1. Nella console Google Cloud , vai alla pagina BigQuery.

   Vai a BigQuery

2. Nell'editor di query, incolla la seguente query e fai clic su Esegui:

   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;

I risultati dovrebbero essere simili ai seguenti:

BigQuery DataFrames

Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames nella guida rapida di BigQuery che utilizza BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, vedi Configurare ADC per un ambiente di sviluppo locale.

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

Crea un modello K-means

Crea un modello K-means utilizzando i dati di addestramento London Bicycle Hires.

SQL

Nella seguente query, l'istruzione CREATE MODEL specifica il numero di cluster da utilizzare, ovvero quattro. Nell'istruzione SELECT, la clausola EXCEPT esclude la colonna station_name perché non contiene una funzionalità. La query crea una riga univoca per station_name e solo le funzionalità sono menzionate nell'istruzione SELECT.

Per creare un modello K-means:

1. Nella console Google Cloud , vai alla pagina BigQuery.

   Vai a BigQuery

2. Nell'editor di query, incolla la seguente query e fai clic su Esegui:

   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

Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames nella guida rapida di BigQuery che utilizza BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, vedi Configurare ADC per un ambiente di sviluppo locale.

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,
)

Interpretare i cluster di dati

Le informazioni nella scheda Valutazione dei modelli possono aiutarti a interpretare i cluster prodotti dal modello.

Per visualizzare le informazioni sulla valutazione del modello:

1. Nella console Google Cloud , vai alla pagina BigQuery.

   Vai a BigQuery

2. Nel riquadro a sinistra, fai clic su Explorer:

   

3. Nel riquadro Explorer, espandi il progetto e fai clic su Set di dati.

4. Fai clic sul set di dati bqml_tutorial, quindi vai alla scheda Modelli.

5. Seleziona il modello london_station_clusters.

6. Seleziona la scheda Valutazione. Questa scheda mostra le visualizzazioni dei cluster identificati dal modello k-means. Nella sezione Funzionalità numeriche, i grafici a barre mostrano i valori delle funzionalità numeriche più importanti per ogni centroide. Ogni centroide rappresenta un determinato cluster di dati. Puoi selezionare le funzionalità da visualizzare dal menu a discesa.

   

   Questo modello crea i seguenti centroidi:

   • Il centroide 1 mostra una stazione della città meno trafficata, con noleggi di durata inferiore.
   • Il centroide 2 mostra la seconda stazione della città, meno trafficata e utilizzata per noleggi di durata più lunga.
   • Il centroide 3 mostra una stazione trafficata vicino al centro città.
   • Il centroide 4 mostra una stazione suburbana con viaggi più lunghi.

   Se gestissi l'attività di noleggio biciclette, potresti utilizzare queste informazioni per prendere decisioni aziendali. Ad esempio:

   • Supponiamo che tu debba sperimentare un nuovo tipo di lucchetto. Quale cluster di stazioni dovresti scegliere come soggetto per questo esperimento? Le stazioni nel centroide 1, nel centroide 2 o nel centroide 4 sembrano scelte logiche perché non sono le stazioni più trafficate.

   • Supponiamo che tu voglia rifornire alcune stazioni con biciclette da corsa. Quali stazioni dovresti scegliere? Il centroide 4 è il gruppo di stazioni lontane dal centro città e con i viaggi più lunghi. Questi sono i candidati ideali per le biciclette da corsa.

Utilizza la funzione ML.PREDICT per prevedere il cluster di una stazione

Identifica il cluster a cui appartiene una determinata stazione utilizzando la funzione SQL ML.PREDICT o la predictfunzione BigQuery DataFrames.

SQL

La seguente query utilizza la funzione REGEXP_CONTAINS per trovare tutte le voci nella colonna station_name che contengono la stringa Kennington. La funzione ML.PREDICT utilizza questi valori per prevedere quali cluster potrebbero contenere queste stazioni.

Segui questi passaggi per prevedere il cluster di ogni stazione che ha la stringa Kennington nel nome:

1. Nella console Google Cloud , vai alla pagina BigQuery.

   Vai a BigQuery

2. Nell'editor di query, incolla la seguente query e fai clic su Esegui:

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

I risultati dovrebbero essere simili ai seguenti.

BigQuery DataFrames

Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames nella guida rapida di BigQuery che utilizza BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, vedi Configurare ADC per un ambiente di sviluppo locale.

# 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