Como 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 tutoria 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 clustering 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 informações sobre os custos do BigQuery ML, consulte a página de preços do BigQuery ML.

Antes de começar

1. Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

2. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar o seletor de projetos

3. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como verificar se o faturamento está ativado em um projeto.

4. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar o seletor de projetos

5. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como verificar se o faturamento está ativado em um projeto.

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

   Ative a API BigQuery.

   Ative a API

Introdução

Os seus dados podem conter agrupamentos naturais ou clusters de dados. Talvez seja uma boa ideia identificar esses agrupamentos de forma descritiva para tomar decisões orientadas a dados. Por exemplo, talvez um varejista queira identificar agrupamentos naturais de clientes que têm hábitos ou locais de compras 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, os itens que compraram, o quanto pagaram, e assim por diante. 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, os itens seriam agrupados com base em quem os comprou, quando foram comprados, onde foram comprados, etc. 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.

  Observação: como o conjunto de dados de Locações de Bicicletas de Londres é armazenado no local multirregional EU, seu conjunto de dados também deve estar em EU.

• 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 um conjunto de dados

O primeiro passo é criar um conjunto de dados do BigQuery para armazenar o modelo. Para criar o conjunto de dados:

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

   Acesse a página do BigQuery

2. Na seção Recursos do painel de navegação, clique no nome do projeto.

3. No painel de detalhes, à direita, clique em 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 Data location, selecione European Union (EU). O conjunto de dados público de Locações de Bicicletas de Londres é armazenado no local multirregional EU. O conjunto de dados precisa estar no mesmo local.

     

5. Mantenha todas as outras configurações padrão e clique em 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

A consulta a seguir compila os dados de treinamento. Esta consulta é incluída na instrução CREATE MODEL mais adiante neste 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

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 as Funções Geográficas. Para mais informações sobre a análise geoespacial, consulte esta página.

Executar a consulta

Para executar a consulta que compila os dados de treinamento do modelo:

1. No console do Google Cloud, clique no botão Escrever nova consulta.

2. Digite a consulta SQL padrão abaixo na área de texto do Editor de consultas.

   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. Clique em Executar.

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

   

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.

É possível criar e treinar um modelo k-means usando o CREATE MODEL com a opção model_type=kmeans. A consulta a seguir adiciona uma instrução CREATE MODEL à consulta anterior e remove os campos id dos dados.

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

Detalhes da consulta

A instrução CREATE MODEL especifica o número desejado de clusters: 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).

Executar a consulta CREATE MODEL

Para executar a consulta que cria o modelo k-means:

1. No console do Google Cloud, clique no botão Escrever nova consulta.

2. Digite a consulta SQL padrão abaixo na área de texto do Editor de consultas.

   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. Clique em Run.

4. No painel de navegação, na seção Recursos, expanda o nome do projeto, clique em bqml_tutorial e, depois, em london_station_clusters.

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

   

6. 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 mostram até 10 dos valores numéricos mais importantes para cada centróide. É possível selecionar quais recursos visualizar no menu suspenso.

   

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

Para identificar o cluster ao qual uma determinada estação pertence, use a função ML.PREDICT. A consulta a seguir prevê o cluster de todas as estações que têm a string "Kennington" no 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')))

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 ML.PREDICT

Para executar a consulta ML.PREDICT:

1. No console do Google Cloud, clique no botão Escrever nova consulta.

2. Digite a consulta SQL padrão abaixo na área de texto do Editor de consultas.

   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. Clique em Executar.

4. Após concluir a consulta, clique na guia Resultados abaixo da área de texto da consulta. Os resultados terão a aparência abaixo.

   

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.

Neste exemplo, Cluster#3 mostra uma estação movimentada que fica perto do centro da cidade. Cluster#2 mostra a segunda estação da cidade, que é menos movimentada. Cluster#1 mostra uma subestação menos movimentada no subúrbio, com locações de prazo mais longo. Cluster#4 mostra outra estação com viagens mais curtas no subúrbio. 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 em Cluster#1, Cluster#2 ou Cluster#4 parecem ser escolhas mais 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? Cluster#1 é o grupo de estações que estão longe do centro da cidade, cujas viagens são 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.

Como excluir seu 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) e clique em Excluir.

Como excluir o projeto

Para excluir o projeto, faça o seguinte:

Cuidado: excluir um projeto tem os seguintes efeitos:

• Tudo no projeto é excluído. Se você tiver usado um projeto atual para seguir este tutorial, a exclusão dele incluirá quaisquer outras ações feitas no projeto.
• Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja explorar vários tutoriais e guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

1. No Console do Google Cloud, acesse a página Gerenciar recursos.

   Acessar "Gerenciar recursos"

2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

A seguir

• Para uma visão geral sobre ML do BigQuery, consulte Introdução ao ML do BigQuery.
• Para mais informações sobre como criar modelos, consulte a página de sintaxe CREATE MODEL.