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


O BigQuery ML oferece suporte ao aprendizado não supervisionado. É possível aplicar o algoritmo k-means para agrupar seus dados em clusters. Ao contrário do machine learning supervisionado, que tem a ver com análise preditiva, o aprendizado supervisionado tem a ver com análise descritiva. Trata-se de entender os dados para que seja possível tomar decisões orientadas a dados.

Neste tutorial, você usará um modelo k-means simples no BigQuery ML para identificar clusters de dados no conjunto de dados público de Locações de Bicicletas de Londres. Os dados de Locações de Bicicletas de Londres contêm o número de locações do Santander Cycle Hire Scheme de Londres de 2011 até o presente. Os dados incluem carimbos de data/hora iniciais e finais, nomes das estações e duração dos passeios.

As consultas neste tutorial usam Funções geográficas disponíveis na análise geoespacial. Para mais informações sobre análise geoespacial, consulte esta página.

Objetivos

Neste tutorial, você verá como realizar as seguintes ações:

  • Criar um modelo de agrupamento k-means.
  • Tomar decisões orientadas por dados usando como base a visualização de clusters do BigQuery ML.

Custos

Neste tutorial, há componentes faturáveis do Google Cloud, entre eles:

  • BigQuery
  • BigQuery ML

Para mais informações sobre os custos do BigQuery, consulte a página de preços do BigQuery.

Para mais sobre os custos do BigQuery ML, consulte Preços do BigQuery ML.

Antes de começar

  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.

    Go to project selector

  3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

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

    Go to project selector

  5. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

  6. O BigQuery é ativado automaticamente em novos projetos. Para ativar o BigQuery em um projeto preexistente, acesse

    Enable the BigQuery API.

    Enable the API

Introdução

Seus dados podem conter agrupamentos naturais ou clusters de dados, e convém identificar esses agrupamentos de maneira descritiva para tomar decisões baseadas em dados. Por exemplo, se você é um varejista, convém identificar agrupamentos naturais de clientes que têm hábitos de compra ou locais semelhantes. Esse processo é chamado de segmentação de clientes.

Os dados usados para realizar a segmentação de clientes podem incluir a loja que eles visitaram, quais itens compraram e quanto pagaram. Os modelos são criados para tentar entender como são esses grupos de perfis de clientes. Assim, é possível projetar itens atrativos para membros dos grupos.

Também é possível encontrar grupos de produtos entre os itens comprados. Nesse caso, você agruparia os itens com base em quem os comprou, quando foram comprados, onde foram comprados e outras características semelhantes. Os modelos são criados para determinar as características de um grupo de produtos. Assim, é possível tomar decisões informadas, como a melhor forma de melhorar a venda cruzada.

Neste tutorial, você usa o BigQuery ML para criar um modelo k-means que agrupa os dados de Locações de Bicicletas de Londres com base nos atributos das estações de bicicletas.

A criação do modelo k-means consiste nos passos a seguir.

  • Primeiro passo: criar um conjunto de dados para armazenar o modelo.
    O primeiro passo é criar um conjunto de dados que armazene o modelo.
  • Segundo passo: examinar os dados de treinamento.
    A próxima etapa é examinar os dados usados para treinar seu modelo de cluster executando uma consulta na tabela london_bicycles. Como k-means é uma técnica de aprendizado não supervisionado, o treinamento do modelo não requer rótulos ou a divisão de dados entre treinamento e avaliação.
  • Terceiro passo: criar um modelo k-means.
    O terceiro passo é criar o modelo k-means. Ao criar o modelo, o campo de clustering é station_name. É possível agrupar dados com base no atributo da estação como, por exemplo, a distância da estação do centro da cidade.
  • Etapa 4: usar a função ML.PREDICT para prever o cluster de uma estação.
    Em seguida, é possível usar a função ML.PREDICT para prever o cluster de um determinado conjunto de estações. A previsão de clusters é feita para todos os nomes de estação que contêm a string Kennington.
  • Etapa 5: usar o modelo para tomar decisões orientadas por dados.
    O último passo é usar o modelo para tomar decisões orientadas por dados. Por exemplo, com base nos resultados do modelo, é possível determinar quais estações se beneficiariam de capacidade adicional.

Etapa 1: criar conjunto de dados

Crie um conjunto de dados do BigQuery para armazenar o modelo de ML:

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

    Acesse a página do BigQuery

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

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

    Criar conjunto de dados.

  4. 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.

Etapa 2: examinar os dados de treinamento

Em seguida, são examinados os dados usados 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

A consulta GoogleSQL a seguir é usada para examinar os dados usados para treinar o modelo 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

Detalhes da consulta

Essa consulta extrai dados sobre locações de bicicletas, incluindo start_station_name e duration, e os associa às informações da estação, como distance-from-city-center. Em seguida, ela calcula os atributos da estação em stationstats, incluindo a duração média e o número de viagens, e passa pelo atributo da estação distance_from_city_center.

Essa consulta usa a cláusula WITH para definir subconsultas. A consulta também usa as funções de análise geoespacial ST_DISTANCE e ST_GEOGPOINT. Para mais informações sobre essas funções, consulte Funções geográficas. Para mais informações sobre a análise geoespacial, consulte esta página.

Executar a consulta

A consulta a seguir compila os dados de treinamento e também é usada na instrução CREATE MODEL posteriormente neste tutorial.

Para executar a consulta, faça o seguinte:

  1. Acessar a página do BigQuery.

Acessar o BigQuery

  1. No painel Editor, execute a seguinte instrução 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
    
    
  2. Após concluir a consulta, clique na guia Resultados abaixo da área de texto da consulta. A guia Resultados mostra as colunas consultada que são usadas para treinar o modelo: station_name, duration, num_trips, distance_from_city_center. Os resultados terão a aparência abaixo.

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 a autenticação para um ambiente de desenvolvimento local.

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

Etapa 3: criar um modelo k-means

Agora que você examinou os dados de treinamento, o próximo passo será criar um modelo k-means usando os dados.

SQL

É possível criar e treinar um modelo k-means usando o CREATE MODEL com a opção model_type=kmeans.

Detalhes da consulta

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 station_name não é um recurso. A consulta cria uma linha única por station_name, e somente os recursos são mencionados na instrução SELECT.

Se a opção num_clusters for omitida, o BigQuery ML escolherá um padrão razoável com base no número total de linhas dos dados de treinamento. Também é possível realizar o ajuste de hiperparâmetros para encontrar um bom número. Para determinar um número ideal de clusters, execute a consulta CREATE MODEL para obter valores diferentes de num_clusters, localize a medida de erro e escolha o ponto em que a medida de erro está no valor mínimo. A medida de erro pode ser extraída selecionando o modelo e clicando na guia Avaliação. Essa guia mostra o índice Davies–Bouldin (em inglês).

Guia Treinamento

Executar a consulta

A consulta a seguir adiciona uma instrução CREATE MODEL à consulta usada para examinar os dados de treinamento e também remove os campos id dos dados.

Para executar a consulta e criar um modelo k-means:

  1. Acessar a página do BigQuery.

Acessar o BigQuery

  1. No painel Editor, execute a seguinte instrução 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
     
    
  2. No painel de navegação, na seção Recursos, expanda o nome do projeto, clique em bqml_tutorial e, depois, em london_station_clusters.

  3. Clique na guia Esquema. O esquema do modelo lista os quatro atributos de estação que o BigQuery ML usou para realizar o clustering. O esquema será semelhante a este:

Informações do esquema de clusters

  1. Clique na guia Avaliação. Essa guia mostra visualizações dos clusters identificados pelo modelo k-means. Em Recursos numéricos, os gráficos de barras exibem até 10 dos valores de atributos numéricos mais importantes para cada centroide. É possível selecionar quais recursos visualizar no menu suspenso.

Gráficos de recursos numéricos

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 a autenticação 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,
)

Etapa 4: usar a função ML.PREDICT para prever o cluster de uma estação

Para identificar o cluster ao qual uma estação específica pertence, use a função ML.PREDICT SQL ou a função predict DataFrames do BigQuery

SQL

Detalhes da consulta

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

Executar a consulta

A consulta a seguir prevê o cluster de todas as estações que têm a string "Kennington" no nome.

Para executar a consulta ML.PREDICT:

  1. Acessar a página do BigQuery.

Acessar o BigQuery

  1. No painel Editor, execute a seguinte instrução 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')))
    
    
  2. Após concluir a consulta, clique na guia Resultados abaixo da área de texto da consulta. Os resultados terão a aparência abaixo.

    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 a autenticação 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

Etapa 5: usar o modelo para tomar decisões orientadas por dados

Os resultados da avaliação podem ajudá-lo a interpretar os diferentes clusters. No exemplo a seguir, o centroide 3 mostra uma estação de cidade movimentada perto do centro da cidade. O Centroide 2 mostra a segunda estação da cidade, que é menos movimentada e usada para aluguéis por mais tempo. O Centroide 1 mostra uma estação menos movimentada, com aluguéis de menor duração. O Centroide 4 mostra uma estação suburbana com viagens mais longas.

Gráficos de recursos numéricos

Com base nesses resultados, é possível usar os dados para informar as suas decisões. 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.

Limpeza

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

  • exclua o projeto que você criou; ou
  • Mantenha o projeto e exclua o conjunto de dados.

Excluir o conjunto de dados

A exclusão do seu projeto removerá todos os conjuntos de dados e tabelas no projeto. Caso prefira reutilizá-lo, exclua o conjunto de dados criado neste tutorial:

  1. Se necessário, abra a página do BigQuery no console do Google Cloud.

    Acesse a página do BigQuery

  2. Na navegação, clique no conjunto de dados bqml_tutorial criado.

  3. Clique em Excluir conjunto de dados no lado direito da janela. Essa ação exclui o conjunto de dados e o modelo.

  4. Na caixa de diálogo Excluir conjunto de dados, confirme o comando de exclusão digitando o nome do seu conjunto de dados (bqml_tutorial). Em seguida, clique em Excluir.

Excluir o projeto

Para excluir o projeto:

  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.

A seguir