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 set 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 riguarda l'analisi predittiva, il machine learning non supervisionato riguarda l'analisi descrittiva. Il machine learning non supervisionato può aiutarti a comprendere i tuoi dati in modo da poter prendere decisioni basate sui dati.

Le query in questo tutorial utilizzano le funzioni geografiche disponibili in Geospatial Analytics. Per saperne di più, consulta Introduzione a Geospatial Analytics.

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.

Obiettivi

Questo tutorial ti guida nel completamento delle seguenti attività:

• Esaminare i dati utilizzati per addestrare il modello.
• Creare un modello di clustering k-means.
• Interpretare i cluster di dati prodotti utilizzando la visualizzazione dei cluster di BigQuery ML.
• Eseguire la ML.PREDICT funzione sul modello k-means per prevedere il cluster probabile per un insieme di stazioni di noleggio biciclette.

Costi

Questo tutorial utilizza componenti fatturabili di Google Cloud, tra cui:

• BigQuery
• BigQuery ML

Per informazioni sui costi di BigQuery, consulta la pagina Prezzi di BigQuery.

Per informazioni sui costi di BigQuery ML, consulta Prezzi di BigQuery ML.

Prima di iniziare

Accedi al tuo Google Cloud account. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti senza costi per l'esecuzione, il test e il deployment dei carichi di lavoro.

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

Verify that billing is enabled for your Google Cloud project.

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

Verify that billing is enabled for your Google Cloud project.

1. BigQuery è abilitato automaticamente nei nuovi progetti. Per attivare BigQuery in un progetto preesistente, vai a

   Abilita l'API BigQuery.

   Ruoli richiesti per abilitare le API

   Per abilitare le API, devi disporre dell'autorizzazione serviceusage.services.enable. Se hai creato il progetto, probabilmente hai già questa autorizzazione tramite il ruolo Proprietario (roles/owner). In caso contrario, puoi ottenere questa autorizzazione tramite il ruolo Amministratore Service Usage (roles/serviceusage.serviceUsageAdmin). Scopri come assegnare i ruoli.

   Abilitare l'API

Autorizzazioni richieste

• Per creare il set di dati, devi disporre dell'autorizzazione IAM bigquery.datasets.create.

• Per creare il modello, devi disporre delle seguenti autorizzazioni:

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

• Per eseguire l'inferenza, devi disporre delle seguenti autorizzazioni:

  • bigquery.models.getData
  • bigquery.jobs.create

Per saperne di più sui ruoli e sulle autorizzazioni IAM in BigQuery, consulta Introduzione a IAM.

Crea un set di dati

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

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

   Vai alla pagina BigQuery

2. Nel riquadro a sinistra, fai clic su Spazio di esplorazione:

   

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

3. Nel riquadro Spazio di esplorazione, fai clic sul nome del progetto.

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

   

5. Nella pagina Crea set di dati, segui questi passaggi:

   • 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 EU multi-regione. Il set di dati deve trovarsi nella stessa località.

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

     

Esamina i dati di addestramento

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

• Durata dei noleggi
• Numero di corse 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 sulla stazione. Ciò include la creazione di una colonna calcolata che contiene la distanza della stazione dal centro città. Quindi, calcola gli attributi della stazione in una colonna stationstats, inclusa la durata media delle corse e il numero di corse, nonché la colonna distance_from_city_center calcolata.

Per esaminare i dati di addestramento:

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

   Vai a BigQuery

2. Nell'editor di query, incolla la query seguente 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 utilizzando BigQuery DataFrames. Per saperne di più, consulta la documentazione di riferimento di BigQuery DataFrames.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 di London Bicycle Hires.

SQL

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

Per creare un modello k-means:

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

   Vai a BigQuery

2. Nell'editor di query, incolla la query seguente 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 utilizzando BigQuery DataFrames. Per saperne di più, consulta la documentazione di riferimento di BigQuery DataFrames.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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,
)

Interpreta i cluster di dati

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

Per visualizzare le informazioni di valutazione del modello:

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

   Vai a BigQuery

2. Nel riquadro a sinistra, fai clic su Spazio di esplorazione:

   

3. Nel riquadro Spazio di esplorazione, 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 cittadina meno trafficata, con noleggi di durata inferiore.
   • Il centroide 2 mostra la seconda stazione cittadina, meno trafficata e utilizzata per noleggi di durata maggiore.
   • Il centroide 3 mostra una stazione cittadina trafficata vicino al centro città.
   • Il centroide 4 mostra una stazione suburbana con corse più lunghe.

   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 blocco. 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 le corse più lunghe. Questi sono i candidati probabili 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 ML.PREDICT funzione SQL o la predict funzione di BigQuery DataFrames.

SQL

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

Per prevedere il cluster di ogni stazione il cui nome contiene la stringa Kennington:

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

   Vai a BigQuery

2. Nell'editor di query, incolla la query seguente 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 utilizzando BigQuery DataFrames. Per saperne di più, consulta la documentazione di riferimento di BigQuery DataFrames.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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

Libera spazio

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

• Puoi eliminare il progetto che hai creato.
• In alternativa, puoi mantenere il progetto ed eliminare il set di dati.

Elimina il set di dati

L'eliminazione del progetto rimuove tutti i set di dati e tutte le tabelle nel progetto. Se preferisci riutilizzare il progetto, puoi eliminare il set di dati creato in questo tutorial:

1. Se necessario, apri la pagina BigQuery nella Google Cloud console.

   Vai alla pagina BigQuery

2. Nella navigazione, fai clic sul set di dati bqml_tutorial che hai creato.

3. Fai clic su Elimina set di dati sul lato destro della finestra. Questa azione elimina il set di dati e il modello.

4. Nella finestra di dialogo Elimina set di dati , digita il nome del set di dati (bqml_tutorial) per confermare il comando di eliminazione, quindi fai clic su Elimina.

Elimina il progetto

Per eliminare il progetto:

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

• L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per, le attività descritte in questo documento, eliminerai anche tutto il lavoro che hai svolto nel progetto.
• Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

1. Nella Google Cloud console, vai alla pagina Gestisci risorse.

   Vai a Gestisci risorse

2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
3. Nella finestra di dialogo, digita l'ID progetto, quindi fai clic su Chiudi per eliminare il progetto.

Passaggi successivi

• Per una panoramica di BigQuery ML, consulta Introduzione a BigQuery ML.
• Per informazioni sulla creazione di modelli, consulta la CREATE MODEL pagina della sintassi.