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

BigQuery ML supporta l'apprendimento non supervisionato . Puoi applicare l'algoritmo k-means per raggruppare i dati in cluster. A differenza del machine learning supervisionato, che riguarda l'analisi predittiva, l'apprendimento non supervisionato riguarda l'analisi descrittiva. Si tratta di comprendere i tuoi dati in modo da poter prendere decisioni basate sui dati.

In questo tutorial userai un modello K-means in BigQuery ML per creare cluster di dati nel set di dati pubblico London Automated Hires. I dati di London Noleggio biciclette contengono il numero di assunzioni della Santander Cycle Hire Scheme di Londra dal 2011 a oggi. I dati includono timestamp di inizio e fine, nomi delle stazioni e durata della corsa.

Le query in questo tutorial utilizzano le funzioni geografiche disponibili nell'analisi geospaziale. Per maggiori informazioni sulle analisi geospaziali, consulta Introduzione all'analisi geospaziale.

Obiettivi

In questo tutorial imparerai a:

Crea un modello di clustering K-means.
Prendi decisioni basate sui dati in base alla visualizzazione dei cluster da parte di BigQuery ML.

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

Accedi al tuo account Google Cloud. 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 gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

Vai al selettore progetti

Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

Vai al selettore progetti

Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

BigQuery viene abilitato automaticamente nei nuovi progetti. Per attivare BigQuery in un progetto preesistente, vai a
Attiva l'API BigQuery.
Abilita l'API

Introduzione

I dati potrebbero contenere raggruppamenti naturali o cluster di dati; potresti voler identificare questi raggruppamenti in modo descrittivo per prendere decisioni basate sui dati. Ad esempio, se sei un rivenditore potresti voler identificare raggruppamenti naturali di clienti con abitudini di acquisto o località simili. Questo processo è noto come segmentazione dei clienti.

I dati utilizzati per eseguire la segmentazione dei clienti potrebbero includere il negozio visitato, gli articoli acquistati e l'importo pagato. Dovresti creare un modello per cercare di capire come sono questi gruppi di clienti tipo in modo da poter progettare elementi che risultino interessanti per i membri del gruppo.

Potresti anche trovare dei gruppi di prodotti tra gli articoli acquistati. In questo caso, potresti raggruppare gli articoli in base a chi li ha acquistati, al momento dell'acquisto, a dove sono stati acquistati e ad altre caratteristiche simili. Dovresti creare un modello per determinare le caratteristiche di un gruppo di prodotti in modo da poter prendere decisioni consapevoli, ad esempio come migliorare il cross-sell.

In questo tutorial userai BigQuery ML per creare un modello k-means che raggruppa i dati di London Noleggio Noleggio in base agli attributi delle stazioni per le biciclette.

La creazione del modello K-means prevede i seguenti passaggi.

Passaggio 1: crea un set di dati per archiviare il modello.

Il primo passaggio consiste nel creare un set di dati in cui viene archiviato il modello.

Nota: poiché il set di dati London Noleggio Noleggio è archiviato nella località EU con più regioni, il set di dati deve risiedere anche nella località EU.
Passaggio 2: esamina i dati di addestramento.

Il passaggio successivo consiste nell'esaminare i dati utilizzati per addestrare il modello di clustering eseguendo una query sulla tabella london_bicycles. Poiché k-means è una tecnica di apprendimento non supervisionato, l'addestramento di un modello non richiede etichette né di suddividere i dati in dati di addestramento e di valutazione.
Passaggio tre. Crea un modello K-means.

Il terzo passaggio consiste nel creare il modello K-means. Quando crei il modello, il campo di clustering è station_name e i dati vengono raggruppati in base all'attributo della stazione, ad esempio la distanza della stazione dal centro città.
Passaggio 4: utilizza la funzione ML.PREDICT per prevedere il cluster di una stazione.

Successivamente, utilizzerai la funzione ML.PREDICT per prevedere il cluster per un determinato insieme di stazioni. Puoi prevedere i cluster per tutti i nomi delle stazioni che contengono la stringa Kennington.
Passaggio cinque: utilizza il modello per prendere decisioni basate sui dati.

Il passaggio finale consiste nell'utilizzare il modello per prendere decisioni basate sui dati. Ad esempio, in base ai risultati del modello, puoi determinare quali stazioni potrebbero trarre vantaggio dalla capacità extra.

Passaggio 1: crea il set di dati

Crea un set di dati BigQuery per archiviare il tuo modello ML:

Nella console Google Cloud, vai alla pagina BigQuery.

Vai alla pagina di 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, segui questi passaggi:
- In ID set di dati, inserisci bqml_tutorial.
- Per Tipo di località, seleziona Più regioni, quindi seleziona UE (più regioni nell'Unione Europea).
  
  Il set di dati pubblico London Noleggio Noleggio di Biciclette viene archiviato in EU più regioni. Il set di dati deve trovarsi nella stessa posizione.
- Lascia invariate le restanti impostazioni predefinite e fai clic su Crea set di dati.

Passaggio 2: esamina i dati di addestramento

Quindi, esamina i dati utilizzati per addestrare il modello K-means. In questo tutorial, raggruppa le stazioni ciclabili in base ai seguenti attributi:

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

SQL

La seguente query GoogleSQL viene utilizzata per esaminare i dati utilizzati per addestrare il modello K-means.

#standardSQL
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

Dettagli query

Questa query estrae i dati sui noleggi, inclusi start_station_name e duration, e li unisce alle informazioni delle stazioni, tra cui distance-from-city-center. Quindi, calcola gli attributi della stazione in stationstats, tra cui la durata media delle corse e il numero di corse, e passa attraverso l'attributo della stazione distance_from_city_center.

Questa query utilizza la clausola WITH per definire le sottoquery. La query utilizza anche le funzioni di analisi geospaziale ST_DISTANCE e ST_GEOGPOINT. Per ulteriori informazioni su queste funzioni, consulta Funzioni geografiche. Per ulteriori informazioni sull'analisi geospaziale, consulta Introduzione all'analisi geospaziale.

Esegui la query

La seguente query compila i tuoi dati di addestramento e viene utilizzata anche nell'istruzione CREATE MODEL più avanti in questo tutorial.

Per eseguire la query:

Vai alla pagina BigQuery.

Vai a BigQuery

Nel riquadro dell'editor, esegui la seguente istruzione SQL:


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

Quando la query è completa, fai clic sulla scheda Risultati sotto l'area di testo della query. La scheda Risultati mostra le colonne sottoposte a query e utilizzate per addestrare il modello: station_name, duration, num_trips, distance_from_city_center. I risultati dovrebbero essere simili ai seguenti.

Risultati delle query

DataFrame BigQuery

Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames riportate nella guida rapida di BigQuery sull'utilizzo di BigQuery DataFrames. Per saperne di più, consulta la documentazione di riferimento di BigQuery DataFrames.

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

import datetime

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 = ["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

Passaggio 3: crea un modello K-means

Ora che hai esaminato i dati di addestramento, il passaggio successivo è creare un modello K-means utilizzando tali dati.

SQL

Puoi creare e addestrare un modello K-means utilizzando l'istruzione CREATE MODEL con l'opzione model_type=kmeans.

Dettagli query

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

Se ometti l'opzione num_clusters, BigQuery ML sceglie un valore predefinito ragionevole in base al numero totale di righe nei dati di addestramento. Potresti anche eseguire l'ottimizzazione degli iperparametri per trovare un buon numero. Per determinare un numero ottimale di cluster, devi eseguire la query CREATE MODEL per diversi valori di num_clusters, trovare la misura dell'errore e scegliere il punto in cui la misura dell'errore raggiunge il valore minimo. Puoi ottenere la misura di errore selezionando il modello e facendo clic sulla scheda Valutazione. Questa scheda mostra l'indice Davies-Bouldin.

Scheda Addestramento

Esegui la query

La seguente query aggiunge un'istruzione CREATE MODEL alla query utilizzata per esaminare i dati di addestramento e rimuove anche i campi id nei dati.

Per eseguire la query e creare un modello K-means:

Vai alla pagina BigQuery.

Vai a BigQuery

Nel riquadro dell'editor, esegui la seguente istruzione SQL:


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

Nella sezione Risorse del pannello di navigazione, espandi il nome del progetto, fai clic su bqml_tutorial e poi su london_station_clusters.
Fai clic sulla scheda Schema. Lo schema del modello elenca i quattro attributi delle stazioni che BigQuery ML ha usato per eseguire il clustering. Lo schema dovrebbe avere l'aspetto seguente.

Informazioni sullo schema del cluster

Fai clic sulla scheda Valutazione. Questa scheda mostra le visualizzazioni dei cluster identificati dal modello K-means. In Caratteristiche numeriche, i grafici a barre mostrano fino a 10 dei valori delle caratteristiche numeriche più importanti per ciascun baricentro. Puoi selezionare le funzionalità da visualizzare dal menu a discesa.

Grafici delle funzionalità numeriche

DataFrame BigQuery

Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta 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,
)

Passaggio 4: utilizza la funzione `ML.PREDICT` per prevedere il cluster di una stazione

Per identificare il cluster a cui appartiene una determinata stazione, utilizza la funzione SQL ML.PREDICT o la funzione predict DataFrames BigQuery

SQL

Dettagli query

Questa 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 conterranno quelle stazioni.

Esegui la query

La seguente query prevede il cluster di ogni stazione che contiene la stringa "Kennington" nel nome.

Per eseguire la query ML.PREDICT:

Vai alla pagina BigQuery.

Vai a BigQuery

Nel riquadro dell'editor, esegui la seguente istruzione SQL:


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

Quando la query è completa, fai clic sulla scheda Risultati sotto l'area di testo della query. I risultati dovrebbero essere simili ai seguenti.

DataFrame BigQuery

Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta 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

Passaggio 5: utilizza il modello per prendere decisioni basate sui dati

I risultati della valutazione possono aiutarti a interpretare i diversi cluster. Nell'esempio seguente, il baricentro 3 mostra una stazione urbana affollata vicina al centro città. Centroid 2 mostra la seconda stazione della città, meno trafficata e utilizzata per noleggi di maggiore durata. Centroid 1 mostra una stazione urbana meno frequentata, con noleggi di durata inferiore. Centroid 4 mostra una stazione periferica con corse più lunghe.

Grafici delle funzionalità numeriche

In base a questi risultati, puoi utilizzare i dati per prendere decisioni consapevoli. Ad esempio:

Supponi di dover provare un nuovo tipo di blocco. Quale cluster di stazioni dovresti scegliere come oggetto di 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 raccogliere alcune stazioni con biciclette da corsa. Quali stazioni dovresti scegliere? Il centroide 4 è il gruppo di stazioni distanti dal centro città, con le corse più lunghe. Questi sono probabilmente candidati per le bici da corsa.

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 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 che hai creato in questo tutorial:

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

Vai alla pagina di BigQuery
Nella barra di 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), 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à in questo documento, quando lo elimini elimini anche qualsiasi altro 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 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.

Nella console Google Cloud, vai alla pagina Gestisci risorse.
Vai a Gestisci risorse
Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
Nella finestra di dialogo, digita l'ID del progetto e 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 pagina della sintassi CREATE MODEL.

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

Obiettivi

Costi

Prima di iniziare

Introduzione

Passaggio 1: crea il set di dati

Passaggio 2: esamina i dati di addestramento

SQL

DataFrame BigQuery

Passaggio 3: crea un modello K-means

SQL

DataFrame BigQuery

Passaggio 4: utilizza la funzione ML.PREDICT per prevedere il cluster di una stazione

SQL

DataFrame BigQuery

Passaggio 5: utilizza il modello per prendere decisioni basate sui dati

Esegui la pulizia

Elimina il set di dati

Elimina il progetto

Passaggi successivi

Passaggio 4: utilizza la funzione `ML.PREDICT` per prevedere il cluster di una stazione