Questa pagina è stata tradotta dall'API Cloud Translation.

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 ulteriori informazioni, 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.

Obiettivi

Questo tutorial ti guida nel completamento 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 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, vedi Prezzi di BigQuery ML.

Prima di iniziare

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.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

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

Nella console Google Cloud , vai alla pagina BigQuery.

Vai alla pagina BigQuery
Nel riquadro Explorer, fai clic sul nome del progetto.
Fai clic su Visualizza azioni > Crea set di dati.
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:

Nella console Google Cloud , vai alla pagina BigQuery.

Vai a BigQuery

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:

Risultati delle query

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à vengono menzionate nell'istruzione SELECT.

Per creare un modello K-means:

Nella console Google Cloud , vai alla pagina BigQuery.

Vai a BigQuery

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

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:

Nella console Google Cloud , vai alla pagina BigQuery.

Vai a BigQuery
Nel riquadro Explorer, espandi il progetto, il set di dati bqml_tutorial e la cartella Modelli.
Seleziona il modello london_station_clusters.
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 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:

Nella console Google Cloud , vai alla pagina BigQuery.

Vai a BigQuery

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.

Risultati di ML.PREDICT

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

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:

Se necessario, apri la pagina BigQuery nella consoleGoogle Cloud .

Vai alla pagina BigQuery
Nella navigazione, fai clic sul set di dati bqml_tutorial che hai creato.
Fai clic su Elimina set di dati sul lato destro della finestra. Questa azione elimina il set di dati e il modello.
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 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.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
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 di modelli, consulta la pagina CREATE MODEL della sintassi.

Crea un modello K-means per raggruppare il set di dati sui noleggi di biciclette a Londra Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Obiettivi

Costi

Prima di iniziare

Autorizzazioni richieste

Crea un set di dati

Esaminare i dati di addestramento

SQL

BigQuery DataFrames

Crea un modello K-means

SQL

BigQuery DataFrames

Interpretare i cluster di dati

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

SQL

BigQuery DataFrames

Esegui la pulizia

Eliminare il set di dati

Elimina il progetto

Passaggi successivi

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

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