Creare un modello k-means per raggruppare un 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 dati analitici. Si tratta di comprendere i tuoi dati in modo da prendere decisioni basate sui dati.

In questo tutorial, utilizzerai un modello k-means in BigQuery ML per creare cluster di dati nel set di dati pubblico Hire di bicicletta di Londra. I dati di London Cycle Hires contengono il numero di aspirazioni del programma Santander Cycle Hire di Londra dal 2011 a oggi. I dati includono timestamp di inizio e di fine, nomi delle stazioni e durata delle corse.

Le query in questo tutorial utilizzano le funzioni geografiche disponibili in analisi geospaziali. Per ulteriori informazioni sull'analisi geospaziale, consulta la pagina Introduzione all'analisi geospaziale.

Obiettivi

In questo tutorial:

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

Costi

Questo tutorial utilizza i componenti fatturabili di Cloud Platform, tra cui:

  • BigQuery
  • BigQuery ML

Per informazioni sui costi di BigQuery, consulta la pagina dei prezzi di BigQuery.

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

Prima di iniziare

  1. 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.
  2. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  4. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  5. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  6. 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. Puoi identificare questi raggruppamenti in modo descrittivo per prendere decisioni basate sui dati. Ad esempio, un rivenditore potrebbe voler identificare raggruppamenti naturali di clienti che hanno abitudini di acquisto o sedi simili. Questa procedura è nota come segmentazione dei clienti.

I dati utilizzati per la segmentazione del cliente potrebbero includere il negozio che hanno visitato, gli articoli acquistati, l'importo pagato e così via. Potresti creare un modello per provare a capire l'aspetto di questi gruppi di utenti tipo, in modo da poter progettare elementi che attirano i membri del gruppo.

Puoi anche trovare gruppi di prodotti tra gli articoli acquistati. In questo caso, raggruppi gli elementi in base a chi li ha acquistati, quando sono stati acquistati, in cui sono stati acquistati e così via. 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, utilizzerai BigQuery ML per creare un modello k-means che raggruppa i dati delle locomotive per biciclette di Londra in base agli attributi della stazione delle 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 che memorizzi il tuo modello.
  • Passaggio 2: esamina i dati di addestramento.
    Il passaggio successivo consiste nell'analizzare i dati che utilizzi per addestrare il tuo modello di clustering eseguendo una query sulla tabella london_bicycles. Poiché k-means è una tecnica di apprendimento non supervisionato, l'addestramento del modello non richiede etichette né richiede che i dati vengano suddivisi in dati di addestramento e valutazione.
  • Passaggio 3: crea un modello k-means.
    Il passaggio 3 consiste nella creazione del modello k-means. Quando crei il modello, il campo del clustering è station_name e raggruppi i dati in base all'attributo della stazione, ad esempio la distanza della stazione dal centro città.
  • Passaggio 4: utilizza la funzione ML.PREDICT per prevedere un cluster di una stazione.
    Quindi, utilizzi la funzione ML.PREDICT per prevedere il cluster per un determinato insieme di stazioni. Prevedi i cluster per tutti i nomi delle stazioni che contengono la stringa Kennington.
  • Passaggio 5: 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 da una capacità aggiuntiva.

Passaggio 1: crea il set di dati

Il primo passaggio consiste nel creare un set di dati BigQuery per archiviare il tuo modello. Per creare il tuo set di dati:

  1. In Cloud Console, vai alla pagina BigQuery.

    Vai alla pagina BigQuery

  2. Nella sezione Risorse del pannello di navigazione, fai clic sul nome del progetto.

  3. Sul lato destro, fai clic su Crea set di dati nel riquadro dei dettagli.

    Crea set di dati

  4. Nella pagina Crea set di dati:

    • In ID set di dati, inserisci bqml_tutorial.
    • Per Località dei dati, scegli Unione europea (UE). Il set di dati pubblici di London Shoes è archiviato nella località con più aree geografiche EU. Il set di dati deve trovarsi nella stessa località.

      Crea pagina di set di dati

  5. Lascia invariate tutte le altre impostazioni predefinite e fai clic su Crea set di dati.

Passaggio 2: esamina i dati di addestramento

Poi esaminerai i dati utilizzati per addestrare il tuo modello k-means. In questo tutorial, clustererai le stazioni per biciclette in base ai seguenti attributi:

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

La query seguente compila i tuoi dati di addestramento. Questa query è inclusa nell'istruzione CREATE MODEL più avanti in questo tutorial.

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,
    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 )
SELECT
  *
FROM
  stationstats
ORDER BY
  distance_from_city_center ASC

Dettagli query

Questa query estrae i dati sui neoassunti, tra cui start_station_name, duration e li unisce alle informazioni sulle stazioni, tra cui distance-from-city-center. Calcola quindi gli attributi della stazione in stationstats, tra cui la durata media delle corse e il numero di corse, e trasmette 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 la sezione Funzioni geografiche. Per ulteriori informazioni sull'analisi geospaziale, vedi Introduzione all'analisi geospaziale.

Esegui la query

Per eseguire la query che compila i dati di addestramento per il modello:

  1. In Cloud Console, fai clic sul pulsante Crea nuova query.

  2. Inserisci la seguente query SQL standard nell'area di testo Editor query.

    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,
        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 )
    SELECT
      *
    FROM
      stationstats
    ORDER BY
      distance_from_city_center ASC
    
    
  3. Fai clic su Esegui.

  4. Una volta completata la query, fai clic sulla scheda Risultati sotto l'area di testo della query. La scheda dei risultati mostra le colonne che hai utilizzato per addestrare il tuo modello: station_name, duration, num_trips, distance_from_city_center. Il risultato dovrebbe essere simile all'esempio seguente.

    Risultati delle query

Passaggio 3: crea un modello k-means

Ora che hai esaminato i tuoi dati di addestramento, il passaggio successivo consiste nel creare un modello k-means utilizzando i dati.

Puoi creare e addestrare un modello k-means utilizzando l'istruzione CREATE MODEL con l'opzione model_type=kmeans. La query seguente aggiunge un'istruzione CREATE MODEL alla query precedente e rimuove i campi id nei dati.

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

Dettagli query

L'istruzione CREATE MODEL specifica il numero desiderato di cluster, ovvero 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 ogni nome stazione e solo le caratteristiche sono menzionate nell'istruzione SELECT.

Se ometti l'opzione num_clusters, BigQuery ML sceglierà un valore predefinito ragionevole in base al numero totale di righe nei dati di addestramento. Puoi anche eseguire l'ottimizzazione degli iperparametri per trovare un buon numero. Per determinare un numero ottimale di cluster, dovresti eseguire la query CREATE MODEL per diversi valori di num_clusters, trovare la misura di errore e scegliere il punto in cui la misura di errore è al suo valore minimo. Per ottenere la misurazione degli errori, seleziona il modello e fai clic sulla scheda Valutazione. Questa scheda mostra l'indice Davies-Bouldin.

Scheda Formazione

Esegui la query CREATE MODEL

Per eseguire la query che crea il tuo modello k-means:

  1. In Cloud Console, fai clic sul pulsante Crea nuova query.

  2. Inserisci la seguente query SQL standard nell'area di testo Editor query.

    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
    
  3. Fai clic su Esegui.

  4. Nel riquadro di navigazione, nella sezione Risorse, espandi il nome del progetto, fai clic su bqml_tutorial e poi su london_station_clusters.

  5. Fai clic sulla scheda Schema. Lo schema del modello elenca i quattro attributi di stazione utilizzati da BigQuery ML per eseguire il clustering. Lo schema dovrebbe avere il seguente aspetto.

    Informazioni sullo schema del cluster

  6. Fai clic sulla scheda Valutazione. Questa scheda mostra le visualizzazioni dei cluster identificati dal modello k-means. Nella sezione Funzionalità numeriche, i grafici a barre mostrano fino a 10 dei più importanti valori delle caratteristiche numeriche per ogni centroide. Puoi selezionare le funzionalità da visualizzare dal menu a discesa.

    Grafici delle caratteristiche numeriche

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

Per identificare il cluster a cui appartiene una determinata stazione, utilizza la funzione ML.PREDICT. La seguente query prevede il cluster di ogni stazione che contiene la stringa "Kennington" nel nome.

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,
    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 )
SELECT
  * EXCEPT(nearest_centroids_distance)
FROM
  ML.PREDICT( MODEL bqml_tutorial.london_station_clusters,
    (
    SELECT
      *
    FROM
      stationstats
    WHERE
      REGEXP_CONTAINS(station_name, 'Kennington')))

Dettagli query

Questa query utilizza la funzione REGEXP_CONTAINS per trovare tutte le voci della colonna station_name che contengono la stringa "Kennington". La funzione ML.PREDICT utilizza questi valori per prevedere quali cluster conterranno tali stazioni.

Esegui la query ML.PREDICT

Per eseguire la query ML.PREDICT:

  1. In Cloud Console, fai clic sul pulsante Crea nuova query.

  2. Inserisci la seguente query SQL standard nell'area di testo Editor query.

    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,
        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 )
    SELECT
      * EXCEPT(nearest_centroids_distance)
    FROM
      ML.PREDICT( MODEL bqml_tutorial.london_station_clusters,
        (
        SELECT
          *
        FROM
          stationstats
        WHERE
          REGEXP_CONTAINS(station_name, 'Kennington')))
    
    
  3. Fai clic su Esegui.

  4. Una volta completata la query, fai clic sulla scheda Risultati sotto l'area di testo della query. Il risultato dovrebbe essere simile all'esempio seguente.

    Risultati ML.PREDICT

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

I risultati della valutazione possono aiutarti a interpretare i diversi cluster.

Grafici delle caratteristiche numeriche

In questo esempio, Cluster#3 mostra una stazione animata vicina al centro. Cluster#2 mostra la seconda stazione della città più affollata. Cluster#1 mostra una stazione suburbana meno affollata, con noleggi di durata maggiore. Cluster#4 mostra un'altra stazione suburbana con corse più brevi. Sulla base di questi risultati, puoi utilizzare i dati per prendere decisioni più consapevoli. Ad esempio:

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

  • Supponiamo che tu voglia allestire alcune stazioni con biciclette da corsa. Quali stazioni dovresti scegliere? Cluster#1 è il gruppo di stazioni distanti dal centro città e hanno 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 creato.
  • In alternativa, puoi mantenere il progetto ed eliminare il set di dati.

Eliminazione del set di dati

L'eliminazione del progetto comporta la rimozione di tutti i set di dati e di tutte le tabelle al suo interno. Se preferisci riutilizzare il progetto, puoi eliminare il set di dati che hai creato in questo tutorial:

  1. Se necessario, apri la pagina BigQuery in 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, conferma il comando Elimina digitando il nome del tuo set di dati (bqml_tutorial) e fai clic su Elimina.

Eliminazione del progetto

Per eliminare il progetto:

  1. In Cloud Console, vai alla pagina Gestisci risorse.

    Vai a Gestisci risorse

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

Passaggi successivi