Criar um modelo k-means para agrupar o conjunto de dados de locações de bicicletas de Londres

Neste tutorial, você vai aprender a usar um modelo k-means no BigQuery ML para identificar clusters em um conjunto de dados.

O algoritmo k-means, que agrupa seus dados em clusters, é uma forma de machine learning não supervisionado. Ao contrário do machine learning supervisionado, que tem a ver com análise preditiva, o machine learning não supervisionado tem a ver com análise descritiva. O aprendizado de máquina não supervisionado pode ajudar você a entender seus dados para tomar decisões com base neles.

As consultas neste tutorial usam funções geográficas disponíveis na análise geoespacial. Para mais informações, consulte Introdução à análise geoespacial.

Este tutorial usa o conjunto de dados público London Bicycle Hires. Os dados incluem carimbos de data/hora iniciais e finais, nomes das estações e duração dos passeios.

crie um conjunto de dados

Crie um conjunto de dados do BigQuery para armazenar o modelo de k-means:

  1. No Google Cloud console, acesse a página BigQuery.

    Acessar a página do BigQuery

  2. No painel à esquerda, clique em Explorer:

    Botão destacado para o painel "Explorer".

    Se o painel esquerdo não aparecer, clique em Expandir painel esquerdo para abrir.

  3. No painel Explorer, clique no nome do seu projeto.

  4. Clique em Conferir ações > Criar conjunto de dados.

    Criar conjunto de dados.

  5. Na página Criar conjunto de dados, faça o seguinte:

    • Para o código do conjunto de dados, insira bqml_tutorial.

    • Em Tipo de local, selecione Multirregional e selecione UE (várias regiões na União Europeia).

      O conjunto de dados público de Locações de Bicicletas de Londres é armazenado na multirregião EU. O conjunto de dados precisa estar no mesmo local.

    • Mantenha as configurações padrão restantes e clique em Criar conjunto de dados.

      Página Criar conjunto de dados.

Analisar os dados de treinamento

Examine os dados que você vai usar para treinar o modelo k-means. Neste tutorial, as estações de bicicletas são agrupadas com base nos seguintes atributos:

  • Duração das locações
  • Número de viagens por dia
  • Distância do centro da cidade

SQL

Essa consulta extrai dados sobre locações de bicicletas, incluindo as colunas start_station_name e duration, e associa esses dados às informações da estação. Isso inclui a criação de uma coluna calculada que contém a distância da estação do centro da cidade. Em seguida, ela calcula os atributos da estação em uma coluna stationstats, incluindo a duração média dos passeios e o número de viagens, e a coluna distance_from_city_center calculada.

Siga estas etapas para examinar os dados de treinamento:

  1. No console do Google Cloud , acesse a página BigQuery.

    Acessar o BigQuery

  2. No Editor de consultas, cole a consulta a seguir e clique em Executar:

    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;

A resposta deve ficar assim:

Resultados da consulta

BigQuery DataFrames

Antes de testar esta amostra, siga as instruções de configuração dos BigQuery DataFrames no Guia de início rápido do BigQuery: como usar os BigQuery DataFrames. Para mais informações, consulte a documentação de referência do BigQuery DataFrames.

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar o ADC para um ambiente de desenvolvimento local. 

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

Criar um modelo k-means

Crie um modelo k-means usando os dados de treinamento de locações de bicicletas de Londres.

SQL

Na consulta a seguir, a instrução CREATE MODEL especifica o número de clusters a serem usados: quatro. Na instrução SELECT, a cláusula EXCEPT exclui a coluna station_name porque ela não contém um recurso. A consulta cria uma linha única por station_name, e somente os recursos são mencionados na instrução SELECT.

Siga estas etapas para criar um modelo k-means:

  1. No console do Google Cloud , acesse a página BigQuery.

    Acessar o BigQuery

  2. No Editor de consultas, cole a consulta a seguir e clique em Executar:

    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

Antes de testar esta amostra, siga as instruções de configuração dos BigQuery DataFrames no Guia de início rápido do BigQuery: como usar os BigQuery DataFrames. Para mais informações, consulte a documentação de referência do BigQuery DataFrames.

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar o ADC para um ambiente de desenvolvimento local. 


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

Interpretar os clusters de dados

As informações na guia Avaliação dos modelos podem ajudar você a interpretar os clusters produzidos pelo modelo.

Siga estas etapas para conferir as informações de avaliação do modelo:

  1. No console do Google Cloud , acesse a página BigQuery.

    Acessar o BigQuery

  2. No painel à esquerda, clique em Explorer:

    Botão destacado para o painel &quot;Explorer&quot;.

  3. No painel Explorer, expanda o projeto e clique em Conjuntos de dados.

  4. Clique no conjunto de dados bqml_tutorial e acesse a guia Modelos.

  5. Selecione o modelo london_station_clusters.

  6. Selecione a guia Avaliação. Essa guia mostra visualizações dos clusters identificados pelo modelo k-means. Na seção Recursos numéricos, os gráficos de barras mostram os valores de atributos numéricos mais importantes para cada centroide. Cada centroide representa um determinado cluster de dados. É possível selecionar quais recursos visualizar no menu suspenso.

    Gráficos de recursos numéricos

    Esse modelo cria os seguintes centroides:

    • O Centroide 1 mostra uma estação menos movimentada, com aluguéis de menor duração.
    • O Centroide 2 mostra a segunda estação da cidade, que é menos movimentada e usada para aluguéis por mais tempo.
    • O centroide 3 mostra uma estação de cidade movimentada perto do centro da cidade.
    • O Centroide 4 mostra uma estação suburbana com viagens mais longas.

    Se você tivesse uma empresa de aluguel de bicicletas, poderia usar essas informações para tomar decisões de negócios. Exemplo:

    • Vamos supor que você precise experimentar um novo tipo de trava. Qual cluster de estações precisa ser escolhido como tema desse experimento? As estações no centroide 1, no centroide 2 ou no centroide 4 parecem ser escolhas lógicas, porque não são as estações mais movimentadas.

    • Vamos supor que você queira abastecer algumas estações com bicicletas de corrida. Quais estações deve escolher? Centroide 4 é o grupo de estações que estão longe do centro da cidade, cujas viagens são as mais longas. Elas são as candidatas mais prováveis a bicicletas de corrida.

Usar a função ML.PREDICT para prever o cluster de uma estação

Identifique o cluster a que uma estação específica pertence usando a função SQL ML.PREDICT ou a função predict do BigQuery DataFrames.

SQL

A consulta a seguir usa a função REGEXP_CONTAINS para encontrar todas as entradas na coluna station_name que contêm a string Kennington. A função ML.PREDICT usa esses valores para prever quais clusters podem conter essas estações.

Siga estas etapas para prever o cluster de todas as estações que têm a string Kennington no nome:

  1. No console do Google Cloud , acesse a página BigQuery.

    Acessar o BigQuery

  2. No Editor de consultas, cole a consulta a seguir e clique em Executar:

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

Os resultados serão semelhantes a este:

Resultados de ML.PREDICT

BigQuery DataFrames

Antes de testar esta amostra, siga as instruções de configuração dos BigQuery DataFrames no Guia de início rápido do BigQuery: como usar os BigQuery DataFrames. Para mais informações, consulte a documentação de referência do BigQuery DataFrames.

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar o ADC para um ambiente de desenvolvimento local. 


# 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