Crea un modello K-means per raggruppare il set di dati relativo ai 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 descrittive. 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 funzioni geografiche disponibili in Dati geospaziali. Per ulteriori informazioni, consulta la pagina Introduzione all'analisi geospaziale.

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

Obiettivi

Questo tutorial ti guida nella realizzazione delle seguenti attività:

• Esamina i dati utilizzati per addestrare il modello.
• Crea un modello di clustering K-means.
• Interpreta i cluster di dati prodotti utilizzando la visualizzazione dei cluster di BigQuery ML.
• Esegui la funzione ML.PREDICT sul modello K-means per prevedere il probabile cluster per un insieme di stazioni di noleggio biciclette.

Costi

Questo tutorial utilizza i 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

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 viene attivato automaticamente nei nuovi progetti. Per attivare BigQuery in un progetto preesistente, vai a

   Enable the BigQuery API.

   Enable the API

Autorizzazioni richieste

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

• Per creare la risorsa di connessione, devi disporre delle seguenti autorizzazioni:

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

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

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

• 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 console Google Cloud, vai alla pagina BigQuery.

   Vai alla pagina BigQuery

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

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

   

4. 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 Noleggio biciclette a Londra è archiviato nella regione EU. Il set di dati deve essere nella stessa posizione.

   • 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, raggruppi le stazioni di ricarica per biciclette in base ai seguenti attributi:

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

SQL

Questa query estrae i dati sulle prenotazioni 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 contenente 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 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 riportate nella guida introduttiva di BigQuery che utilizza BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

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

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

Creare un modello K-means

Crea un modello K-means utilizzando i dati di addestramento delle biciclette a noleggio di Londra.

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 riportate nella guida introduttiva di BigQuery che utilizza BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

Per autenticarti in BigQuery, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configurare l'autenticazione 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 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 Explorer, espandi il progetto, il set di dati bqml_tutorial e la cartella Modelli.

3. Seleziona il modello london_station_clusters.

4. 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 ciascun 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 di città meno frequentata, con affitti di durata inferiore.
   • Il baricentro 2 mostra la seconda stazione della città, meno frequentata e utilizzata per i noleggi di durata più lunga.
   • Il centroide 3 mostra una stazione cittadina trafficata vicino al centro città.
   • Il baricentro 4 mostra una stazione di periferia con viaggi più lunghi.

   Se gestisci un'attività di noleggio biciclette, puoi utilizzare queste informazioni per prendere decisioni aziendali. Ad esempio:

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

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

Utilizzare 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 funzione predict DataFrames di BigQuery.

SQL

La seguente query utilizza la funzione REGEXP_CONTAINS per trovare tutte le voci nella colonna station_name contenenti 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 che contiene 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 al seguente.

BigQuery DataFrames

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

Per autenticarti in BigQuery, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configurare l'autenticazione 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

Esegui la pulizia

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 conservare il progetto ed eliminare il set di dati.

Eliminare 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 console Google Cloud.

   Vai alla pagina BigQuery

2. Nella barra di 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, conferma il comando di eliminazione digitando il nome del set di dati (bqml_tutorial) e poi 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, quando lo elimini elimini anche tutto il lavoro 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 appspot.com URL, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, il riuso dei progetti può aiutarti a non superare i limiti di quota.

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.

Passaggi successivi

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