Como criar um modelo de clustering k-means para segmentação de mercado usando o BigQuery ML

Aprenda como segmentar dados de público do Google Analytics 360 para fins de marketing criando clusters k-means com o BigQuery ML.

Visão geral

Um desafio comum de análise de marketing que você pode ter é determinar temas no comportamento do consumidor que podem ser usados para desenvolver perfis ou perfis de cliente. Esses perfis podem ajudar você a incorporar mais conhecimento do cliente às suas campanhas de marketing.

Para criar rapidamente segmentos de clientes com base nos seus dados, use uma técnica chamada clustering. O clustering permite agrupar clientes com comportamento semelhante para criar públicos-alvo diferentes para usar no marketing. Você pode personalizar a divulgação para os clientes personalizando os anúncios e outras comunicações com eles, de acordo com as preferências e comportamentos indicados pelo cluster a que cada cliente pertence.

Neste tutorial, você aprende a criar clusters de clientes usando um modelo k-means no BigQuery ML. Você treina o modelo com dados de clientes de amostra que contêm informações demográficas e de transações, e o modelo retorna informações sobre os clusters de clientes que ele identifica nesses dados. Em seguida, você recebe previsões do modelo que permitem atribuir cada cliente ao cluster apropriado com base nos dados demográficos e no histórico de transações delas. Depois de atribuir cada cliente a um cluster, envie os dados atualizados do cliente de volta ao Google Analytics 360 para usá-lo na ativação de marketing.

Veja neste tutorial como criar uma instância de notebooks gerenciados pelo usuário do Vertex AI Workbench para concluir essas etapas, fornecendo orientações prescritivas e procedimentos passo a passo. Se você quiser usar um notebook completo como referência, use o notebook Como criar modelos de agrupamento em k-means para segmentação de mercado no BigQuery ML. servidor de notebook de sua escolha.

Este tutorial é destinado a engenheiros, cientistas de dados e analistas de dados que criam conjuntos de dados e modelos de ML para apoiar decisões de negócios. Pressupomos que você tenha conhecimentos básicos sobre os seguintes tópicos:

• Conceitos de machine learning
• Python
• SQL padrão

Como funcionam os algoritmos de clustering?

O clustering é um tipo de machine learning não supervisionado. Você executa um algoritmo, k-means, neste caso, para identificar como os dados são agrupados logicamente. O algoritmo avalia os dados de treinamento em busca de semelhanças e agrupa os dados com base nele, em vez de depender de um rótulo fornecido por humanos para agrupar os dados. Por exemplo, suponha que você queira agrupar seus clientes por idade e renda estimada. É possível usar o clustering para ajudar a determinar quantos clusters existem nos dados com base nesses atributos. Embora o clustering possa parecer simples quando você está considerando apenas um ou dois atributos do cliente, fica cada vez mais difícil fazer manualmente manualmente à medida que você leva mais atributos do cliente em consideração.

Um desafio de uso do clustering é determinar se você tem o número "certo" de clusters. Neste tutorial, mostramos como melhorar o modelo depois de criar uma versão inicial para que você tenha um modelo que cria um número apropriado de clusters para seu caso de uso. para criar um anexo da VLAN de monitoramento.

Conjunto de dados

Este tutorial usa o conjunto de dados de amostra do Google Analytics, hospedado publicamente no BigQuery. Esse conjunto de dados fornece 12 meses (agosto de 2016 a agosto de 2017) de dados ofuscados do Google Analytics 360 da Google Merchandise Store, uma loja de comércio eletrônico real que vende mercadorias com a marca do Google.

Caso você tenha seus próprios dados do Analytics 360, poderá usá-los se quiser. Há informações em todo o tutorial sobre o que fazer de maneira diferente nesse caso.

Objetivos

• Processe os dados do cliente no formato correto para criar um modelo de clustering k-means.
• Crie, treine e implante o modelo k-means usando o BigQuery ML.
• Iterar no modelo para desenvolver uma versão que crie o número ideal de clusters.
• Analise os clusters produzidos pelo modelo para entender o que eles dizem sobre seus segmentos de clientes.
• Receber previsões do modelo implantado para atribuir clientes aos clusters apropriados
• Exporte dados de cliente atualizados do BigQuery para usá-los na ativação de marketing no Analytics 360.

Custos

Neste tutorial, usamos os seguintes componentes faturáveis do Google Cloud:

• AI Platform
• BigQuery
• BigQuery ML

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

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. Ative as APIs Notebooks and Compute Engine.

   Ative as APIs

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

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

7. Ative as APIs Notebooks and Compute Engine.

   Ative as APIs

Ao concluir este tutorial, exclua os recursos criados para evitar o faturamento contínuo. Para mais informações, consulte Limpeza.

Criar um notebook

1. No Console do Cloud, acesse a página Notebooks.

   Acesse o Notebooks

2. Na guia Notebooks gerenciados pelo usuário, clique em  Novo notebook.

3. Escolha Python 3.

4. Em Nome da instância, digite kmeans.

5. Clique em Criar A criação da instância do notebook leva alguns minutos.

6. Quando a instância estiver disponível, clique em Abrir JupyterLab.

7. Na seção Notebook do JupyterLab, clique em Python 3.

Instalar bibliotecas

Instale as bibliotecas necessárias para este tutorial.

1. Copie o seguinte código na primeira célula do notebook:

   # Install libraries.
   !pip install pandas-gbq
   !pip install google-cloud-bigquery
   !pip install google-cloud-bigquery-storage
   # Needed to setup flex slots for flat-rate pricing
   !pip install google-cloud-bigquery-reservation
   
   # Automatically restart kernel after installs
   import IPython
   app = IPython.Application.instance()
   app.kernel.do_shutdown(True)
   

2. Clique em Executar na barra de menu.

Importar pacotes

Instale os pacotes necessários para este tutorial copiando o seguinte código na próxima célula vazia do notebook e executando-o:

from google.cloud import bigquery
import numpy as np
import pandas as pd
import pandas_gbq
import matplotlib.pyplot as plt

# used to display float format
pd.set_option('display.float_format', lambda x: '%.3f' % x)

Crie um cliente do BigQuery

Crie um cliente do BigQuery para a biblioteca de cliente Python para BigQuery. Para isso, copie o seguinte código na próxima célula vazia do notebook e execute-o. Substitua myProject pelo ID do projeto que você está usando para concluir este tutorial.

client = bigquery.Client(project="myProject")

Processar os dados.

Nesta seção, você prepara os dados necessários para treinar o modelo k-means. A preparação dos dados inclui a agregação dos dados de transações do cliente do Analytics 360, a geração de dados demográficos de cliente de amostra e a mesclagem desses dois conjuntos de dados para criar o conjunto de dados de treinamento.

Neste tutorial, você usa os dados de amostra do Google Analytics, mas em um caso de uso de produção, usaria seus próprios dados do Analytics 360.

Crie um conjunto de dados do BigQuery

Crie um conjunto de dados do BigQuery para conter os dados do cliente e o modelo k-means. Para isso, copie o código a seguir para a próxima célula vazia do notebook e execute-o:

! bq mk myProject:kmeans

Dados da transação agregada

Nesta seção, você agrega dados de transações do cliente a partir do conjunto de dados de amostra do Analytics 360. Os dados agregados oferecem uma visão mais clara da frequência com que os clientes compram itens, de quais tipos de itens compram e de quanto eles gastam.

Neste tutorial, supomos que uma compra ocorre quando o pagetype = "EVENT". Em um caso de uso de produção, convém identificar compras de outra maneira, dependendo da configuração do Analytics 360.

Neste tutorial, também usamos fullVisitorID como a chave dos dados do cliente. Em um caso de uso de produção, você precisa substituir instâncias de fullVisitorID por clientId nesta e nas consultas subsequentes. Isso ocorre porque você precisa usar clientId como o campo-chave ao importar dados de público-alvo para o Google Analytics 360. clientId normalmente é uma versão em hash de fullVisitorId, mas essa coluna não é preenchida no conjunto de dados de amostra do Google Analytics. Para preencher clientId nos seus próprios dados do Analytics 360, crie uma dimensão personalizada e preencha-o.

1. Para criar uma visualização com dados de transação do cliente agregados, copie o seguinte código na próxima célula vazia do notebook e execute-o:

   ga360_only_view = 'GA360_View'
   shared_dataset_ref = client.dataset('kmeans')
   ga360_view_ref = shared_dataset_ref.table(ga360_only_view)
   ga360_view = bigquery.Table(ga360_view_ref)
   
   ga360_query = '''
   SELECT
     fullVisitorID,
     # This will be used to generate random data.
     ABS(farm_fingerprint(fullVisitorID)) AS Hashed_fullVisitorID,
     # You can aggregate this because an
     # operating system is tied to a fullVisitorID.
     MAX(device.operatingSystem) AS OS,
     SUM (CASE
          WHEN REGEXP_EXTRACT (v2ProductCategory,
                              r'^(?:(?:.*?)Home/)(.*?)/')
                              = 'Apparel' THEN 1 ELSE 0 END) AS Apparel,
     SUM (CASE
          WHEN REGEXP_EXTRACT (v2ProductCategory,
                              r'^(?:(?:.*?)Home/)(.*?)/')
                              = 'Office' THEN 1 ELSE 0 END) AS Office,
     SUM (CASE
          WHEN REGEXP_EXTRACT (v2ProductCategory,
                              r'^(?:(?:.*?)Home/)(.*?)/')
                              = 'Electronics' THEN 1 ELSE 0 END) AS Electronics,
     SUM (CASE
          WHEN REGEXP_EXTRACT (v2ProductCategory,
                              r'^(?:(?:.*?)Home/)(.*?)/')
                              = 'Limited Supply' THEN 1 ELSE 0 END) AS LimitedSupply,
     SUM (CASE
          WHEN REGEXP_EXTRACT (v2ProductCategory,
                              r'^(?:(?:.*?)Home/)(.*?)/')
                              = 'Accessories' THEN 1 ELSE 0 END) AS Accessories,
     SUM (CASE
          WHEN REGEXP_EXTRACT (v2ProductCategory,
                              r'^(?:(?:.*?)Home/)(.*?)/')
                              = 'Shop by Brand' THEN 1 ELSE 0 END) AS ShopByBrand,
     SUM (CASE
          WHEN REGEXP_EXTRACT (v2ProductCategory,
                              r'^(?:(?:.*?)Home/)(.*?)/')
                              = 'Bags' THEN 1 ELSE 0 END) AS Bags,
     ROUND (SUM (productPrice/1000000),2) AS totalSpent_USD
     FROM
     `bigquery-public-data.google_analytics_sample.ga_sessions_*`,
     UNNEST(hits) AS hits,
     UNNEST(hits.product) AS hits_product
   WHERE
     _TABLE_SUFFIX BETWEEN '20160801'
     AND '20160831'
     AND geoNetwork.country = 'United States'
     AND type = 'EVENT'
   GROUP BY
     1,
     2
   '''
   
   ga360_view.view_query = ga360_query.format('myProject')
   ga360_view = client.create_table(ga360_view)
   
   

2. Veja uma amostra dos dados de transação agregados do cliente. Basta copiar o seguinte código na próxima célula vazia do notebook e executá-lo:

   # Show a sample of GA360 data
   
   ga360_query_df = f'''
   SELECT * FROM {ga360_view.full_table_id.replace(":", ".")}
   ORDER BY fullVisitorID
   LIMIT 5
   '''
   
   job_config = bigquery.QueryJobConfig()
   
   # Start the query
   query_job = client.query(ga360_query_df, job_config=job_config) #API Request
   df_ga360 = query_job.result()
   df_ga360 = df_ga360.to_dataframe()
   
   df_ga360
   

   Os resultados serão semelhantes aos exibidos abaixo:

   

Gere dados demográficos

Use o procedimento a seguir para gerar dados demográficos de clientes sintéticos.

Em um caso de uso de produção, você usaria seus próprios dados de um sistema de gestão de relacionamento com o cliente (CRM, na sigla em inglês). Você pularia esta etapa e prosseguir para a próxima, que une os dados de CRM aos dados de transações agregados do cliente.

1. Para criar uma visualização com os dados do cliente gerados, copie o seguinte código para a próxima célula vazia do notebook e execute-o:

   CRM_only_view = 'CRM_View'
   shared_dataset_ref = client.dataset('kmeans')
   CRM_view_ref = shared_dataset_ref.table(CRM_only_view)
   CRM_view = bigquery.Table(CRM_view_ref)
   
   # The query below works by hashing the fullVisitorID, which creates a
   # random distribution. It uses modulo to artificially split gender and
   # household income distribution.
   CRM_query = '''
   SELECT
     fullVisitorID,
   IF
     (MOD(Hashed_fullVisitorID,2) = 0,
       "M",
       "F") AS gender,
     # Generate household income
     CASE
       WHEN MOD(Hashed_fullVisitorID,10) = 0 THEN 55000
       WHEN MOD(Hashed_fullVisitorID,10) < 3 THEN 65000
       WHEN MOD(Hashed_fullVisitorID,10) < 7 THEN 75000
       WHEN MOD(Hashed_fullVisitorID,10) < 9 THEN 85000
       WHEN MOD(Hashed_fullVisitorID,10) = 9 THEN 95000
     ELSE
     Hashed_fullVisitorID
   END
     AS hhi
   FROM (
     SELECT
       fullVisitorID,
       ABS(farm_fingerprint(fullVisitorID)) AS Hashed_fullVisitorID,
     FROM
       `bigquery-public-data.google_analytics_sample.ga_sessions_*`,
       UNNEST(hits) AS hits,
       UNNEST(hits.product) AS hits_product
         WHERE
       _TABLE_SUFFIX BETWEEN '20160801'
       AND '20160831'
       AND geoNetwork.country = 'United States'
       AND type = 'EVENT'
     GROUP BY
       1,
       2)
   '''
   
   CRM_view.view_query = CRM_query.format('myProject')
   CRM_view = client.create_table(CRM_view)
   

2. Veja uma amostra dos dados do cliente gerados ao copiar o código a seguir para a próxima célula vazia do notebook e executá-lo:

   # See an output of the synthetic CRM data
   
   CRM_query_df = f'''
   SELECT * FROM {CRM_view.full_table_id.replace(":", ".")}
   ORDER BY fullVisitorID
   LIMIT 5
   '''
   
   job_config = bigquery.QueryJobConfig()
   
   # Start the query
   query_job = client.query(CRM_query_df, job_config=job_config)
   df_CRM = query_job.result()
   df_CRM = df_CRM.to_dataframe()
   
   df_CRM
   

   Os resultados serão semelhantes aos exibidos abaixo:

   

Criar o conjunto de dados de treinamento

Use o procedimento a seguir para criar o conjunto de dados de treinamento mesclando os dados de transação agregados do cliente e os dados demográficos do cliente gerados.

1. Para criar uma visualização com dados mesclados de clientes e transações, copie o código a seguir na próxima célula vazia do notebook e execute-o:

   # Build a final view, which joins GA360 data with CRM data
   
   final_data_view = 'Final_View'
   shared_dataset_ref = client.dataset('kmeans')
   final_view_ref = shared_dataset_ref.table(final_data_view)
   final_view = bigquery.Table(final_view_ref)
   
   final_data_query = f'''
   SELECT
       g.*,
       c.* EXCEPT(fullVisitorId)
   FROM {ga360_view.full_table_id.replace(":", ".")} g
   JOIN {CRM_view.full_table_id.replace(":", ".")} c
   ON g.fullVisitorId = c.fullVisitorId
   '''
   
   final_view.view_query = final_data_query.format('myProject')
   final_view = client.create_table(final_view)
   
   print(f"Successfully created view at {final_view.full_table_id}")
   

2. Veja uma amostra dos dados mesclados copiando o seguinte código na próxima célula vazia do notebook e executando-o:

   # Show final data used before modeling
   
   sql_demo = f'''
   SELECT * FROM {final_view.full_table_id.replace(":", ".")}
   ORDER BY fullVisitorID
   LIMIT 5
   '''
   
   job_config = bigquery.QueryJobConfig()
   
   # Start the query
   query_job = client.query(sql_demo, job_config=job_config)
   df_demo = query_job.result()
   df_demo = df_demo.to_dataframe()
   
   df_demo
   

   Os resultados serão semelhantes aos exibidos abaixo:

   

Criar, treinar e implantar um modelo inicial

Nesta seção, você criará uma função do Python que cria o modelo k-means. Ao criar uma função em vez de apenas usar o SQL, você pode definir vários modelos e deixar que o BigQuery os crie em paralelo. Essa função será usada novamente na seção Melhorar o modelo para criar várias versões do modelo para comparação.

Não use fullVisitorId como uma entrada para o modelo, porque esses dados não são necessários para criar um recurso para o clustering. Em geral, dados exclusivos ou incomuns não são úteis para essa finalidade.

Normalmente, você também precisa normalizar recursos numéricos, mas pode pular esta etapa aqui, porque o BigQuery ML cuida disso automaticamente.

1. Para definir a função makeModel, copie o seguinte código na próxima célula vazia do notebook e execute-o:

   PROJECT_ID = "myProject"
   
   def makeModel (n_Clusters, Model_Name):
       sql =f'''
       CREATE OR REPLACE MODEL `{PROJECT_ID}.kmeans.{Model_Name}`
       OPTIONS(model_type='kmeans',
       kmeans_init_method = 'KMEANS++',
       num_clusters={n_Clusters}) AS
       SELECT * except(fullVisitorID, Hashed_fullVisitorID) FROM `{final_view.full_table_id.replace(":", ".")}`
       '''
       job_config = bigquery.QueryJobConfig()
       client.query(sql, job_config=job_config)
   

2. Teste a função criando o modelo test que segmenta os dados em três clusters. O modelo leva aproximadamente cinco minutos para ser criado.

   Copie o seguinte código na próxima célula vazia do notebook e execute-o:

   model_test_name = "test"
   makeModel(3, model_test_name)
   

3. Confirme se o modelo foi criado copiando o seguinte código na próxima célula vazia do notebook e executando-o:

   for model in client.list_models('kmeans'):
     print(model)
   

   Os resultados serão semelhantes aos exibidos abaixo:

   Model(reference=ModelReference(project_id='myProject', dataset_id='kmeans', model_id='test'))
   

4. Exclua o modelo test copiando o seguinte código para a próxima célula vazia do notebook e executando-o:

   model_id = "kmeans."+model_test_name
   client.delete_model(model_id)
   print(f"Deleted model '{model_id}'")
   

Melhorar o modelo

Nesta seção, mostramos como melhorar o modelo ajustando-o para fornecer o número ideal de clusters ao seu caso de uso.

Determinar o número correto de clusters: este é o "k" em "k-means", depende do seu caso de uso. Às vezes, é fácil determinar quantos clusters são necessários. Por exemplo, se você estiver processando imagens de dígitos únicos escritos à mão, precisará de 10 clusters, cada um para os dígitos de 0 a 9. Para casos de uso menos óbvios, é possível testar várias versões do modelo que usam números diferentes de clusters. A comparação entre versões diferentes do modelo permite ver qual funciona melhor em termos de agrupamento dos dados e minimizar erros em cada cluster.

É possível determinar qual versão do modelo fornece os melhores agrupamentos usando o método de cotovelo, que é uma maneira de representar a perda de gráfico o número de clusters no modelo, em combinação com a pontuação do Davies–Bouldin (em inglês) do modelo. Essa pontuação indica a diferença entre os pontos de dados de um cluster. Ela é definida como a proporção entre o dispersão dos pontos de dados dentro de um determinado cluster e o dispersão dos próprios clusters. Um valor mais baixo melhora o agrupamento em cluster.

Criar vários modelos para comparação

Gerar várias versões do modelo k-means, a partir de uma que crie três clusters até um que crie quinze clusters.

1. Gere várias versões do modelo k-means. Observe que os modelos levam aproximadamente sete minutos para serem criados.

   Copie o seguinte código na próxima célula vazia do notebook e execute-o:

   low_k = 3
   high_k = 15
   model_prefix_name = 'kmeans_clusters_'
   
   lst = list(range (low_k, high_k+1)) #build list to iterate through k values
   
   for k in lst:
       model_name = model_prefix_name + str(k)
       makeModel(k, model_name)
   

2. Para conseguir uma lista dos modelos gerados, copie o código a seguir na próxima célula vazia do notebook e execute-o:

   models = client.list_models('kmeans')
   print("Listing current models:")
   for model in models:
       full_model_id = f"{model.dataset_id}.{model.model_id}"
       print(full_model_id)
   

   Os resultados serão semelhantes aos exibidos abaixo:

   

Comparar o desempenho do modelo

Use o procedimento de redução para comparar o desempenho de diferentes modelos analisando a distância média quadrática, que identifica a perda do modelo e a pontuação Davies–Bouldin em cada modelo.

Importante: devido à natureza aleatória dos dados do cliente gerados, você verá resultados diferentes dos mostrados nos procedimentos a seguir. A mesma orientação para avaliação dos resultados ainda se aplica.

1. Use a instrução SQL ML.EVALUATE para gerar a distância média quadrática e a pontuação de Davies–Bouldin para cada modelo. Isso pode levar aproximadamente um minuto.

   Copie o seguinte código na próxima célula vazia do notebook e execute-o:

   # This creates a dataframe with each model name, the Davies Bouldin Index, and Loss.
   
   df = pd.DataFrame(columns=['davies_bouldin_index', 'mean_squared_distance'])
   models = client.list_models('kmeans')
   for model in models:
       full_model_id = f"{model.dataset_id}.{model.model_id}"
       sql =f'''
           SELECT
               davies_bouldin_index,
               mean_squared_distance
           FROM ML.EVALUATE(MODEL `{full_model_id}`)
       '''
   
       job_config = bigquery.QueryJobConfig()
   
       # Start the query, passing in the extra configuration.
       query_job = client.query(sql, job_config=job_config)
       df_temp = query_job.to_dataframe()  # Wait for the job to complete.
       df_temp['model_name'] = model.model_id
       df =  pd.concat([df, df_temp], axis=0)
   

2. Atualize o DataFrame adicionando uma coluna que identifica o número de clusters usados pelo modelo e classificando os dados para gerar gráficos. Para fazer isso, copie o código a seguir na próxima célula vazia do notebook e execute-o:

   df['n_clusters'] = df['model_name'].str.split('_').map(lambda x: x[2])
   df['n_clusters'] = df['n_clusters'].apply(pd.to_numeric)
   df = df.sort_values(by='n_clusters', ascending=True)
   df
   

   Você verá resultados semelhantes à tabela a seguir:

   

3. Para criar um gráfico dos dados, copie o código a seguir na próxima célula vazia do notebook e execute-o:

   df.plot.line(x='n_clusters', y=['davies_bouldin_index', 'mean_squared_distance'])
   

   Você verá resultados semelhantes à tabela a seguir:

   

   Não há uma abordagem perfeita para determinar o número ideal de clusters para um caso de uso. Recomendamos a abordagem a seguir ao tomar essa decisão:

   1. Aplique o método de cotovelo e veja se ele mostra um lugar claro onde a perda continua.
   2. Considere as pontuações dos Davies-Bouldin para os modelos.
   3. Considere as regras ou os requisitos de negócios que podem afetar a quantidade de clusters com que você quer trabalhar.
   4. Escolha o modelo que atenda aos requisitos do seu negócio e tenha a melhor combinação de baixa perda e baixa pontuação de Davies-Bouldin.

   No gráfico anterior, a linha laranja representa a perda de cada modelo, como representada pela distância quadrada, plotada em relação ao número de clusters no modelo. A tendência dessa linha ilustra que aumentar o número de clusters diminui a perda, o que é esperado. A linha também diminui de modo consistente, em vez de pressionar um ponto em que a perda permanece e cria uma forma de cotovelo. Isso indica que, para esse conjunto de dados, usar somente o método cotovelo não é suficiente para determinar o número ideal de clusters.

   A linha azul representa a pontuação de Davies-Bouldin de cada modelo, representada pelo número de clusters no modelo. Como o método de cotovelo não identificou claramente o modelo de melhor desempenho, você também pode identificar esse modelo escolhendo um com uma baixa pontuação de Davies-Bouldin.

   O modelo com 11 clusters tem uma perda bastante baixa e a melhor pontuação de Davies-Bouldin. Portanto, se as regras de negócios não informarem um motivo para trabalhar com menos clusters, a melhor escolha será a escolha. Se as regras de negócio tiverem um motivo para trabalhar com menos clusters, o modelo com quatro clusters terá a segunda melhor pontuação de Davies-Bouldin. Para simplificar, este modelo usa o modelo com quatro clusters.

Analisar os clusters de dados no modelo selecionado

Para entender como os dados foram agrupados nesse modelo, veja os centróides do modelo. Depois, analise os dados em cada cluster para entender quantos usuários estão. e o que o clustering indica sobre o comportamento do cliente.

1. Use o ML.CENTROIDS Instrução SQL para ver informações sobre os centroides de cada cluster para agender copiando o seguinte código na próxima célula vazia do notebook e executando-o:

   model_to_use = 'kmeans_clusters_4' # Edit this to use a different model
   final_model = 'kmeans.'+model_to_use
   
   pd.set_option('max_colwidth', 400)
   
   sql_get_attributes = f'''
   SELECT
     centroid_id,
     feature,
     categorical_value
   FROM
     ML.CENTROIDS(MODEL {final_model})
   WHERE
     feature IN ('gender')
   '''
   
   job_config = bigquery.QueryJobConfig()
   
   # Start the query
   query_job = client.query(sql_get_attributes, job_config=job_config)
   df_attributes = query_job.result()
   df_attributes = df_attributes.to_dataframe()
   df_attributes
   

   Os resultados serão semelhantes aos exibidos abaixo:

   

2. Calcule estatísticas resumidas nos dados do cluster usando informações de ML.PREDICT e ML.CENTROIDS copiando o código a seguir na próxima célula vazia do notebook e executando:

   sql_get_numerical_attributes = f'''
   WITH T AS (
   SELECT
     centroid_id,
     ARRAY_AGG(STRUCT(feature AS name,
                      ROUND(numerical_value,1) AS value)
                      ORDER BY centroid_id)
                      AS cluster
   FROM ML.CENTROIDS(MODEL {final_model})
   GROUP BY centroid_id
   ),
   
   Users AS(
   SELECT
     centroid_id,
     COUNT(*) AS Total_Users
   FROM(
   SELECT
     * EXCEPT(nearest_centroids_distance)
   FROM
     ML.PREDICT(MODEL {final_model},
       (
       SELECT
         *
       FROM
         {final_view.full_table_id.replace(":", ".")}
         )))
   GROUP BY centroid_id
   )
   
   SELECT
     centroid_id,
     Total_Users,
     (SELECT value from unnest(cluster) WHERE name = 'Apparel') AS Apparel,
     (SELECT value from unnest(cluster) WHERE name = 'Office') AS Office,
     (SELECT value from unnest(cluster) WHERE name = 'Electronics') AS Electronics,
     (SELECT value from unnest(cluster) WHERE name = 'LimitedSupply') AS LimitedSupply,
     (SELECT value from unnest(cluster) WHERE name = 'Accessories') AS Accessories,
     (SELECT value from unnest(cluster) WHERE name = 'Bags') AS Bags,
     (SELECT value from unnest(cluster) WHERE name = 'ShopByBrand') AS ShopByBrand,
     (SELECT value from unnest(cluster) WHERE name = 'totalSpent_USD') AS totalSpent_USD,
     (SELECT value from unnest(cluster) WHERE name = 'hhi') AS HouseholdIncome
   
   FROM T LEFT JOIN Users USING(centroid_id)
   ORDER BY centroid_id ASC
   '''
   
   job_config = bigquery.QueryJobConfig()
   
   # Start the query
   query_job = client.query(sql_get_numerical_attributes, job_config=job_config)
   df_numerical_attributes = query_job.result()
   df_numerical_attributes = df_numerical_attributes.to_dataframe()
   df_numerical_attributes.head()
   

   Os resultados serão semelhantes aos exibidos abaixo:

   

Considerando os dados de centroide e resumidos, é possível determinar as seguintes características para os clusters do modelo:

• Cluster 1: os clientes neste cluster compram muito em vestuário. Eles compram a maioria dos itens e têm o segundo maior gasto por item. e não são fortemente motivadas. O cluster é um pouco feminino.
• Cluster 2: os clientes nesse cluster compram em todas as categorias, mas compram a maior parte em vestuário. Eles compram menos itens do que os clientes no Cluster 1, mas gastam significativamente mais por item. Há muitas chances de que elas façam compras pela marca. Esse cluster degrada mais mulheres.
• Cluster 3: esse cluster é um outlier com apenas uma pessoa.
• Cluster 4: esse é o cluster mais preenchido. Os clientes nesse cluster fazem pequenos números de compra e gastam menos, em média. Eles costumam ser compradores novos, em vez de fiéis à marca. O desvio de gênero é mínimo.

Receber previsões

Use o modelo selecionado para atribuir usuários a clusters que podem ser usados para segmentação de marketing.

1. Crie uma tabela com dados de transação agregados do cliente. Basta copiar o seguinte código na próxima célula vazia do notebook e executá-lo:

   sql_score = f'''
   SELECT * EXCEPT(nearest_centroids_distance)
   FROM
     ML.PREDICT(MODEL {final_model},
       (
       SELECT
         *
       FROM
         {final_view.full_table_id.replace(":", ".")}
         LIMIT 10))
   '''
   
   job_config = bigquery.QueryJobConfig()
   
   # Start the query
   query_job = client.query(sql_score, job_config=job_config)
   df_score = query_job.result()
   df_score = df_score.to_dataframe()
   
   df_score
   

   Os resultados serão semelhantes aos exibidos abaixo:

   

Exportar dados para o Analytics 360

Depois de coletar as informações de cluster dos clientes com seu modelo k-means, você pode exportá-los para o Analytics 360 e usá-los em campanhas de marketing.

Para fazer isso, use o console do BigQuery para executar uma consulta que retorne os dados que você quer exportar, conforme mostrado no seguinte pseudocódigo SQL:

CREATE OR REPLACE TABLE myDataset.myCustomerDataTable AS (
    SELECT * EXCEPT(nearest_centroids_distance)
    FROM
      ML.PREDICT(MODEL myDataset.myModel,
        (
        SELECT
          *
        FROM
          myDataset.myTable)))

Salve os resultados da consulta como um arquivo CSV e, em seguida, use a Importação de dados para importá-los para o Google Analytics 360. É necessário mapear os nomes das colunas nos dados de recomendações exportados para o esquema de importação de dados do Analytics 360. Por exemplo, se o esquema de importação de dados for ga:clientId, ga:dimension1, ga:dimension2, os nomes das colunas nos dados precisarão ser ga:clientId, ga:dimension1, ga:dimension2. Como o BigQuery não permite o uso de dois pontos nos nomes das colunas, você precisa atualizar os nomes das colunas no arquivo CSV exportado antes de importá-lo.

Se quiser, use a implementação de referência MoDeM (Model Deployment for Marketing) (em inglês) para modelos do BigQuery ML para facilitar o carregamento de dados no Google Analytics 360. Para começar, use as instruções interativas no notebook BQML Deployment Template (em inglês).

Limpeza

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados neste tutorial, exclua o projeto que contém os recursos ou mantenha o projeto, mas exclua apenas esses recursos.

Seja como for, remova esses recursos para que não sejam faturados no futuro. Nas seções a seguir, você verá como excluir esses recursos.

Excluir o projeto

A maneira mais fácil de eliminar o faturamento é excluir o projeto criado para o tutorial.

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

Excluir os componentes

Se você não quiser excluir o projeto, use as seguintes seções para excluir os componentes faturáveis deste tutorial.

Excluir o conjunto de dados do BigQuery

1. Abra o console do BigQuery
2. Na seção Recursos, expanda o projeto em que você fez este tutorial e selecione o conjunto de dados bqml.
3. Clique em Excluir conjunto de dados no cabeçalho do painel do conjunto de dados.
4. Na janela de sobreposição que aparece, digite bqml e clique em Excluir.

Excluir a instância de notebooks gerenciado pelo usuário

1. Abrir a guia "Notebooks gerenciados pelo usuário"
2. Marque a caixa de seleção da instância do notebook kmeans.
3. Clique em Excluir.
4. Na janela de sobreposição que aparece, clique em Excluir.

A seguir

• Saiba mais sobre outras soluções de previsão preditiva.
• Saiba mais sobre o BigQuery ML.
• Saiba mais sobre o Google Analytics 360.