Clusters de K-means no Tableau com TabPy: tutorial

O que é o TabPy

TabPy é um framework que permite ao Tableau executar código em Python. Ele possibilita rodar scripts de Python em campos calculados do Tableau ou fazer o deploy de funções no servidor TabPy usando a API em Python.  

O TabPy é uma ferramenta poderosa, com várias configurações e utilitários. Você pode integrá-lo às visualizações do Tableau e, sempre que os parâmetros forem alterados, o script em Python roda automaticamente para oferecer uma experiência de visualização dinâmica. 

Por que usar o TabPy? 

Embora o Tableau ofereça muitos recursos para criar, manipular e limpar campos de dados, suas funções estatísticas nativas são mais simples. Para liberar estatística avançada, como machine learning, vamos integrar as bibliotecas robustas do Python ao Tableau. 

Aprenda diversas técnicas estatísticas no Tableau com um curso interativo da DataCamp.

Neste tutorial, vamos configurar um servidor TabPy e trabalhar em um projeto simples de machine learning. Usaremos o algoritmo K-means para dividir os anúncios do AirBnB de Amsterdã em vários clusters. 

Configurando o TabPy

Configurar um servidor TabPy é simples. Você pode instalar o TabPy com `pip` no terminal ou `!pip` no Jupyter Notebook. A instalação inclui automaticamente o servidor e a API cliente para Python.

pip install tabpy

Para iniciar o servidor, digite `tabpy` no terminal. Em poucos segundos, você verá que o servidor está rodando localmente na porta 9004. 

tabpy

Saída

... Password file is not specified: Authentication is not enabled
... Call context logging is disabled
... Initializing TabPy...
... Initializing TabPy Server...
... Done initializing TabPy.
... Setting max request size to 104857600 bytes
... Initializing models...
... Web service listening on port 9004

Configuração do servidor TabPy

Você pode configurar o servidor TabPy usando um arquivo de configuração e o comando abaixo. 

tabpy --config=path/to/my/config/file.conf

É possível configurar:

• Conexão HTTP vs HTTPS
• Gerenciamento de usuários 
• Logging

O TabPy dá liberdade para personalizar o servidor de acordo com as políticas de segurança e qualidade da sua empresa. Confira o arquivo de configuração de exemplo e veja como configurar um servidor com requisitos específicos. 

Fazendo deploy do TabPy no Heroku

Se você usa o Tableau Cloud ou o Tableau Server, será preciso fazer o deploy de um servidor TabPy em uma plataforma de nuvem ou hospedagem web. Dá para fazer isso com um arquivo Docker ou fazendo o deploy direto no Heroku. 

Para rodar o servidor remoto no Heroku:

• Acesse sua conta no Heroku pelo navegador. Se ainda não tem uma conta, crie uma gratuitamente.
• Vá ao repositório do TabPy no GitHub e clique no botão "Deploy to Heroku" no Readme.

• Siga as instruções. Defina o nome do servidor e selecione a região.
• Configure as variáveis de ambiente de username e password.

Pronto: seu servidor foi implantado sem dor de cabeça. Você pode conectar o Tableau com a URL e o número da porta. 

Conectando ao TabPy

Antes de conectar no Tableau, garanta que seu servidor TabPy esteja em execução localmente ou de forma remota.  

Para conectar, clique no menu Help e selecione Settings and Performance > Manage Analytics Extension Connection. Vai abrir uma janela com vários tipos de conexão: TabPy, Einstein Discovery, RServe e Analytics Extension API. 

Selecione a opção TabPy. Vai abrir outra janela pedindo Hostname, Port, Username e Password. Vamos ignorar username e password porque não configuramos isso.

No passo seguinte, adicione Hostname como “localhost” e Port como “9004” e clique em Test Connection. Se o teste passar, salve a configuração da conexão. 

Usando Python em cálculos do Tableau

Para rodar um script em Python em um campo calculado, use uma destas funções conforme o tipo de saída:

• SCRIPT_BOOL
• SCRIPT_INT
• SCRIPT_REAL
• SCRIPT_STR

Se sua função retorna valores booleanos, use SCRIPT_BOOL. Você também pode retornar inteiros e, depois, converter para outros tipos usando funções nativas. 

Nesta seção, vamos usar um dataset de vendas de loja do Kaggle. Os campos Sales e Profit vão calcular o coeficiente de correlação de Pearson. 

O SCRIPT_REAL exige duas partes: primeiro, o script em Python entre aspas duplas; segundo, os argumentos agregados. 

Usaremos o pacote NumPy para calcular a correlação entre os argumentos Sales e Profit. Não podemos passar os argumentos diretamente; usamos placeholders como “_arg1” e “_arg2”. Por exemplo, SUM([Profit]) está em segundo na ordem e corresponde a “_arg2”.

Vamos extrair o coeficiente de correlação da matriz np.corrcoef para retornar uma única coluna. 

SCRIPT_REAL("import numpy as np
return np.corrcoef(_arg1,_arg2)[0,1]",
SUM([Sales]),SUM([Profit]))

Depois de adicionar o script ao campo calculado “Correlation”, clique em aplicar. O script vai rodar e retornar valores correspondentes a Customer Name. 

Antes de clicar em OK, clique no texto “Default Table Calculation” e mude a opção de Automatic para Customer Name. 

Para visualizar um scatter plot de categoria de produto e segmentação de clientes: 

1. Arraste Category e Sales para a prateleira Columns.
2. Depois, arraste Customer Segment e Profit para a prateleira Rows. 
3. Arraste Customer Name para o botão Detail na seção Marks. 
4. Por fim, arraste o novo campo calculado Correlation para o botão Label em Marks. 

O gráfico acima mostra o coeficiente de correlação por cliente, com base na categoria do produto e no segmento. Há alta correlação entre a categoria Furniture e clientes Small Business.     

Script de clustering em Python no Tableau

Nesta seção, vamos usar o dataset Airbnb Amsterdam para criar clusters com o algoritmo K-means e o framework de machine learning scikit-learn. 

Antes de partir para o script no TabPy, vamos analisar e entender o dataset no Jupyter Notebook. 

Inicialização do projeto 

Usaremos pandas para ingestão e limpeza de dados, matplotlib e seaborn para visualização, e scikit-learn para processamento e algoritmos de clustering.

Primeiro, vamos importar os pacotes necessários e carregar o arquivo “listing.csv”. Em seguida, exploramos os valores ausentes com .isna().sum().

mport pandas as pd

import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.preprocessing import LabelEncoder
from sklearn.cluster import KMeans


df = pd.read_csv("listings.csv")
df.isna().sum()

Como dá para ver, há vários valores ausentes em neighbourhood_group, last_review e reviews_per_month. Em vez de imputar ou remover essas colunas, vamos simplesmente não usá-las no treinamento do modelo. 

id                                    0
name                                 38
host_id                               0
host_name                             4
neighbourhood_group               20030
neighbourhood                         0
latitude                              0
longitude                             0
room_type                             0
price                                 0
minimum_nights                        0
number_of_reviews                     0
last_review                        2406
reviews_per_month                  2406
calculated_host_listings_count        0
availability_365                      0
dtype: int64

Processando os dados

Vamos criar um dataframe X com os recursos essenciais para o treinamento. Esses atributos não têm valores ausentes, IDs únicos ou alta correlação. Por exemplo, não incluiremos id, name, host_id, host_name, latitude e longitude.

Temos colunas categóricas; para convertê-las em numéricas, vamos usar LabelEncoder(). Para aplicar em múltiplas colunas, usaremos o .apply() do Pandas.  

X = df[['neighbourhood',
        'room_type',
        'price',
        'minimum_nights',
        'number_of_reviews',
        'availability_365',
        'calculated_host_listings_count']]
LE = LabelEncoder()
cat = ['neighbourhood','room_type']

X[cat] = X[cat].apply(LE.fit_transform)
X.head()

Como podemos ver, o dataframe final tem sete colunas numéricas. 

Buscando o "cotovelo" do K-means

O método do cotovelo (Elbow) ajuda a determinar o número ideal de clusters em um conjunto de dados. Vamos usar n_clusters e .inertia_ para exibir gráficos de linha com o padrão de “cotovelo”. Inertia é a soma dos quadrados das distâncias dos pontos ao centro do cluster mais próximo. 

O código abaixo roda de 1 a 9 e adiciona os valores de inércia ao array clusters. Depois, usamos essa informação para plotar o gráfico de linhas de clusters vs. inércia. 

clusters = []

for i in range(1, 10):
    km = KMeans(n_clusters=i).fit(X)
    clusters.append(km.inertia_)
 
fig, ax = plt.subplots(figsize=(12, 8))
sns.lineplot(x=list(range(1, 10)), y=clusters, ax=ax)
ax.set_title('Searching for Elbow')
ax.set_xlabel('Clusters')
ax.set_ylabel('Inertia');

O gráfico mostra um primeiro “arco” em 3 e um segundo em 4. Vamos incluir ambos na análise visual no Tableau. 

Saiba mais sobre clustering K-means em Python com scikit-learn no nosso tutorial.  

Criando o parâmetro N-Cluster

Para não precisar alterar manualmente o número de clusters no código, vamos criar um parâmetro com faixa de 1 a 10. 

Crie parâmetros clicando com o botão direito na seção Data e escolhendo Create Parameter. Mude o Data type para Integer, defina o Current value como 1 e clique em Range para configurar Minimum 1 e Maximum 10. 

Script em Python no campo calculado

Agora vamos transferir o código do Jupyter Notebook para um campo calculado no Tableau. O campo calculado do Tableau não precisa carregar dataset: já temos os campos necessários e vamos passá-los como argumentos do SCRIPT_INT. 

1. Converter os argumentos um e dois para numéricos usando LabelEncoder.
2. Capturar todos os argumentos e dar nomes de variáveis apropriados. 
3. Empilhar todos os argumentos de entrada (exceto N) em colunas. 
4. Definir o modelo com “N” clusters. Podemos mudar esse valor pelo parâmetro N Clusters.
5. Treinar e prever os clusters a partir das features.  
6. Retornar a saída como uma lista de inteiros. 

A segunda parte do script são os campos de dados agregados e o parâmetro. 

Revise o código abaixo para entender a relação entre argumentos e campos de dados. 

SCRIPT_INT("from sklearn.preprocessing import LabelEncoder
from sklearn.cluster import KMeans

LE = LabelEncoder()

neighbourhood = LE.fit_transform(_arg1)
room_type = LE.fit_transform(_arg2)

price = _arg3
minimum_nights = _arg4
number_of_reviews = _arg5
availability_365 = _arg6
calculated_host_listings_count = _arg7

N = _arg8[0]

X = np.column_stack(
    [
        neighbourhood,
        room_type,
        price,
        minimum_nights,
        number_of_reviews,
        availability_365,
        calculated_host_listings_count,
    ]
)

kmeans = KMeans(n_clusters=N, random_state=35)
return kmeans.fit_predict(X).tolist()

",
ATTR([Neighbourhood]),
ATTR([Room Type]),
AVG([Price]),
MEDIAN([Minimum Nights]),
SUM([Number Of Reviews]),
AVG([Availability 365]),
AVG([Calculated Host Listings Count]),
[N Clusters]
)

Crie um novo campo calculado (Kmean) e cole o código acima. Garanta que os resultados sejam computados ao longo de Host Id. Você pode ajustar isso clicando no texto azul Default Table Calculation.  

Visualização dos dados

Para criar a visualização abaixo, siga esta sequência:

1. Arraste o campo Price para Columns e Number of Reviews para Rows. 
2. No menu Analysis, desmarque Aggregate Measures. 
3. Arraste Host Id para Detail em Marks e o campo calculado Kmean para Color. 
4. Mude o campo calculado Kmean para Discrete clicando com o botão direito e selecionando a opção.  
5. Clique com o botão direito em N Clusters na seção Parameters e selecione Show Parameters para exibir o controle deslizante à direita. 
6. Ajuste o slider de N Clusters para 3 ou 4 e veja os resultados em tempo real.   

Em seguida, vamos criar várias planilhas de visualização mudando os campos de dados e o número de clusters.  

1. Price vs. Availability: vemos quatro clusters. Com isso, dá para criar um sistema de recomendação para o Airbnb ou qualquer negócio de hotelaria. 
2. Reviews vs. Availability: aparecem só dois clusters grandes, mesmo com N Clusters = 3.  
3. Listings vs. Price: observamos clusters em vermelho, azul e verde. O amarelo no canto está cercado por verdes e azuis. 

Aprenda mais sobre analytics avançado e visualização no nosso curso Analyzing Data in Tableau. Você vai entender preparação de dados, exploração, mapas, grupos, conjuntos e parâmetros.   

Se curtiu o tutorial de clustering, experimente colocar os pontos no mapa. Basta arrastar Latitude e Longitude para as prateleiras Columns e Rows. 

Você também pode criar clusters sem TabPy seguindo nosso tutorial de análise de clusters no Tableau. 

Conclusão

Ao integrar o TabPy, você abre as portas para inúmeras possibilidades de automatizar e melhorar seu setup atual de analytics. Também é possível integrar modelos de deep learning a dashboards, executar tarefas estatísticas complexas e implementar integração e entrega contínuas. 

A integração com TabPy tem algumas limitações, como saída única. Essas restrições tendem a afetar mais quem atua como Data Scientist ou Machine Learning Engineer. 

Neste post, vimos o que é o TabPy (servidor Python para Tableau) e como usá-lo para criar clusters K-means. Criar clusters é importante para e-commerce, viagens e entretenimento, ajudando a entender o comportamento dos clientes. Usamos K-means, mas você pode testar outros algoritmos para resultados melhores. 

Aqui estão alguns dos principais algoritmos de clustering:

• Affinity Propagation
• Agglomerative Hierarchical Clustering
• BIRCH (Balanced Iterative Reducing and Clustering using Hierarchies)
• DBSCAN (Density-Based Spatial Clustering of Applications with Noise)
• Gaussian Mixture Models (GMM)
• Mean Shift Clustering

Se você está começando no Tableau e quer aprender visualização de dados e estatística, faça a trilha de habilidades Tableau Fundamentals. 

Na segunda parte desta série, exploramos scripts de Python mais complexos com TabPy. Vamos fazer o deploy do modelo de previsão Facebook Prophet no servidor TabPy e criar visualizações de séries temporais dinâmicas.