Cluster K Means in Tableau con il tutorial TabPy

Cos'è TabPy

TabPy è un framework che permette a Tableau di eseguire codice Python. Consente di eseguire script Python all'interno dei campi calcolati di Tableau oppure di distribuire funzioni sul server TabPy tramite API Python.  

TabPy è uno strumento potente che offre varie configurazioni e utility. Puoi integrarlo con le visualizzazioni di Tableau e, ogni volta che cambi i parametri, lo script Python viene eseguito automaticamente per offrirti un'esperienza di visualizzazione dinamica. 

Perché TabPy? 

Anche se Tableau offre funzionalità ricche per creare, manipolare e ripulire i campi dati, si è limitati a funzionalità statistiche semplici. Per sbloccare statistiche avanzate come il machine learning, integreremo le potenti librerie Python con Tableau. 

Impara varie tecniche statistiche in Tableau con un corso interattivo di DataCamp.

In questo tutorial impareremo a configurare un server TabPy e a lavorare su un semplice progetto di machine learning. Useremo l'algoritmo K Means per dividere gli annunci AirBnB di Amsterdam in vari cluster. 

Configurare TabPy

Configurare un server TabPy è semplice. Puoi installare TabPy usando `pip` nel terminale o `!pip` in Jupyter Notebook. Installerà automaticamente il server e le API client per Python.

pip install tabpy

Per avviare il server, digiteremo `tabpy` nel terminale. In pochi secondi vedrai che il server è in esecuzione in locale sulla porta 9004. 

tabpy

Output

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

Configurazione del server TabPy

Puoi configurare il tuo server TabPy usando il file di configurazione e il comando seguente. 

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

Puoi configurare:

• Connessione HTTP vs HTTPS
• Gestione utenti 
• Logging

TabPy ti dà la libertà di personalizzare il server in base alle policy aziendali di sicurezza e di quality assurance. Puoi consultare il file di configurazione di esempio e imparare a impostare un server con requisiti specifici. 

Distribuire TabPy su Heroku

Se usi Tableau Cloud o Tableau Server, dovrai distribuire un server TabPy su una piattaforma cloud o di web hosting. Puoi farlo usando un file Docker o distribuendo direttamente il server su Heroku. 

Per eseguire il server remoto su Heroku:

• Accedi al tuo account Heroku via browser; se non hai un account, registrati gratuitamente.
• Vai al repository TabPy su GitHub e fai clic sul pulsante "Deploy to Heroku" nel Readme.

• Segui le istruzioni. Inserisci il nome del server e seleziona la posizione del server.
• Imposta le variabili d'ambiente username e password.

Il tuo server è distribuito senza problemi. Puoi collegare Tableau con l'URL e il numero di porta. 

Connessione a TabPy

Assicurati che il tuo server TabPy sia in esecuzione in locale o in remoto prima di collegarlo a Tableau.  

Per connettere il server, fai clic sul menu Aiuto e seleziona Impostazioni e prestazioni > Gestisci connessione estensione di Analytics. Si aprirà una nuova finestra con vari tipi di connessione: TabPy, Einstein Discovery, RServe e Analytics Extension API. 

Selezioneremo l'opzione TabPy, che aprirà un'altra finestra chiedendoci di aggiungere Hostname, Porta, Username e Password. Ignoreremo le opzioni username e password perché non le abbiamo impostate.

Nel passaggio successivo, aggiungeremo Hostname come “localhost” e Porta “9004” e premeremo Test connessione. Dopo aver superato il test, salveremo la configurazione della connessione. 

Usare Python con i calcoli di Tableau

Per eseguire uno script Python in un campo calcolato, ti serve una di queste funzioni script in base al tuo output:

• SCRIPT_BOOL
• SCRIPT_INT
• SCRIPT_REAL
• SCRIPT_STR

Se la tua funzione restituisce valori booleani, usa la funzione SCRIPT_BOOL. Puoi sempre ottenere interi e poi convertirli in altri tipi usando le funzioni native. 

In questa sezione useremo un dataset di vendite di negozi da Kaggle. I campi dati Sales e Profit calcolano il coefficiente di correlazione di Pearson. 

La SCRIPT_REAL richiede due parti. La prima è lo script Python tra doppie virgolette e la seconda sono gli argomenti aggregati. 

Useremo il pacchetto Python Numpy per calcolare la correlazione tra gli argomenti Sales e Profit. Non possiamo aggiungere gli argomenti direttamente. Usiamo invece placeholder come “_arg1” e “_arg2”. Per esempio, SUM([Profit]) è il secondo in ordine ed è collegato a “_arg2”.

Stiamo semplicemente estraendo un coefficiente di correlazione dalla matrice np.corrcoef per restituire una singola colonna. 

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

Dopo aver aggiunto lo script nel campo calcolato “Correlation”, fai clic sul pulsante Applica. Eseguirà lo script e restituirà i valori corrispondenti al Customer Name. 

Prima di premere il pulsante OK, fai clic sul testo “Default Table Calculation” e cambia l'opzione da Automatic a Customer Name. 

Per visualizzare uno scatter plot della categoria di prodotto e della segmentazione dei clienti: 

1. Trascina e rilascia i campi dati Category e Sales nella mensola Columns.
2. Poi trascina e rilascia i campi dati Customer Segment e Profit nella mensola Rows. 
3. Trascina e rilascia Customer Name sul pulsante Detail nella sezione Marks. 
4. Infine, trascina e rilascia il campo calcolato appena creato Correlation sul pulsante Label nella sezione Marks. 

Il grafico sopra mostra il coefficiente di correlazione dei clienti in base alla categoria di prodotto e al segmento di clientela. C'è un'alta correlazione tra la categoria Furniture e i clienti Small Business.     

Script Python di clustering in Tableau

In questa sezione useremo il dataset Airbnb Amsterdam per creare cluster usando l'algoritmo di clustering K-means e il framework di machine learning scikit-learn. 

Prima di passare alla scrittura in TabPy, dobbiamo analizzare e comprendere il dataset su Jupyter Notebook. 

Inizializzazione del progetto 

Useremo pandas per l'ingestione e la pulizia dei dati, matplotlib e seaborn per la visualizzazione, e scikit-learn per l'elaborazione dei dati e gli algoritmi di clustering.

Per prima cosa importeremo i pacchetti Python necessari e caricheremo il file “listing.csv”. Poi esploreremo i valori mancanti usando .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()

Come possiamo osservare, ci sono diversi valori mancanti in neighbourhood_group, last_review e reviews_per_month. Invece di imputare o eliminare queste colonne, non le includeremo nell'addestramento del modello. 

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

Elaborazione dei dati

Creeremo un dataframe X che conterrà le caratteristiche essenziali per l'addestramento. Queste feature non hanno valori mancanti, ID univoci o alta correlazione. Per esempio, non includeremo id, name, host_id, host_name, latitude e longitude.

Abbiamo colonne categoriche e, per convertirle in numeriche, useremo LabelEncoder(). Per applicarlo a più colonne categoriche, useremo la funzione Pandas .apply().  

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

Come possiamo vedere, il dataframe finale ha sette colonne con valori numerici. 

Ricerca del gomito per i cluster K Means

Il metodo del gomito viene utilizzato per determinare il numero ottimale di cluster in un particolare dataset. Useremo n_clusters e .inertia_ per mostrare grafici a linee con andamenti a gomito. L'inerzia è la somma delle distanze al quadrato dei campioni dal centro del cluster più vicino. 

Il codice seguente eseguirà da 1 a 9 e aggiungerà i valori di inerzia all'array clusters. Poi useremo queste informazioni per tracciare un grafico a linee di cluster vs inerzia. 

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

Il grafico mostra che il primo arco è su 3 e il secondo su 4. Includeremo entrambi questi numeri di cluster nell'analisi visiva in Tableau. 

Puoi approfondire il clustering K Means in Python con scikit-learn seguendo il nostro tutorial.  

Creare il parametro N-Cluster

Per evitare di aggiungere manualmente nel codice il numero di cluster, creeremo un parametro con un intervallo da 1 a 10. 

Possiamo creare parametri facendo clic con il tasto destro nella sezione Data e selezionando l'opzione Create Parameter. Cambia il Data type in Integer, il Current value in 1 e fai clic su Range per aggiungere Minimum 1 e Maximum 10. 

Script Python nel campo calcolato

Ora trasferiremo il codice dal Jupyter Notebook al campo calcolato di Tableau. Il campo calcolato di Tableau non richiede il caricamento di un dataset. Abbiamo già i campi dati necessari e li useremo tramite gli argomenti SCRIPT_INT. 

1. Convertiremo il primo e il secondo argomento in tipo numerico usando LabelEncoder.
2. Recupera tutti gli argomenti e assegna loro nomi di variabile appropriati. 
3. Impileremo in colonne tutti gli argomenti di input tranne N. 
4. Definisci un modello con “N” numero di cluster. Possiamo modificare questa variabile con il parametro N Clusters.
5. Infine, addestriamo e prevediamo i cluster usando le feature.  
6. Restituisci l'output come elenco di interi. 

La seconda parte dello script riguarda i campi dati aggregati e un parametro. 

Puoi rivedere il codice qui sotto per comprendere la relazione tra argomenti e campi dati. 

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

Crea un nuovo campo calcolato (Kmean) e copia e incolla il codice sopra. Assicurati che i risultati siano calcolati in base a Host Id. Puoi modificarlo facendo clic sul testo blu Default Table Calculation.  

Visualizzazione dei dati

Per creare la visualizzazione qui sotto, dobbiamo seguire una serie di passaggi.

1. Trascina e rilascia il campo dati Price nella mensola Columns e Number of Reviews nella mensola Rows. 
2. Vai al menu Analysis in alto e deseleziona Aggregate Measures. 
3. Trascina e rilascia il campo dati Host Id su Detail nella sezione Marks e il campo calcolato Kmean su Color. 
4. Modifica il campo calcolato Kmean in Discrete facendo clic con il tasto destro e accedendo all'opzione.  
5. Fai clic con il tasto destro su N Clusters nella sezione Parameters e seleziona Show Parameters per visualizzare lo slider a destra. 
6. Regola lo slider N Clusters a 3 o 4 per vedere i risultati in tempo reale.   

Nella parte successiva creeremo più fogli di visualizzazione cambiando i campi dati e il numero di cluster.  

1. Price v/s Availability: possiamo vedere quattro cluster. Sulla base di queste informazioni, possiamo creare un sistema di raccomandazione per Airbnb o qualsiasi attività alberghiera. 
2. Review v/s Availability: possiamo vedere solo due grandi cluster anche se N Clusters è 3.  
3. Listings v/s Price: possiamo vedere cluster rossi, blu e verdi. Il giallo nell'angolo è circondato da verdi e blu. 

Approfondisci l'analisi avanzata e la visualizzazione seguendo il nostro corso Analyzing Data in Tableau. Ti aiuterà a comprendere preparazione dei dati, esplorazione, analisi cartografica, gruppi, insiemi e parametri.   

Se ti è piaciuto il tutorial sul clustering, prova a convertire i punti dati su una mappa. Trascina e rilascia semplicemente Latitude e Longitude nelle mensole Columns e Rows. 

Puoi anche creare cluster senza TabPy seguendo il nostro tutorial Cluster Analysis in the Tableau. 

Conclusione

Integrando TabPy, aprirai la porta a infinite possibilità per automatizzare e migliorare il tuo setup di data analytics. Possiamo anche usarlo per integrare modelli di deep learning in una dashboard analitica, eseguire compiti statistici complessi e implementare integrazione e sviluppo continui. 

L'integrazione TabPy presenta diverse limitazioni, come l'output singolo. Queste restrizioni influenzeranno principalmente chi è Data Scientist o Machine Learning Engineer. 

In questo post abbiamo visto cos'è TabPy (server Python per Tableau) e come usarlo per creare cluster K Means. Creare cluster è importante per i settori e-commerce, viaggi ed entertainment per comprendere il comportamento dei clienti. Abbiamo usato il cluster K Means, ma puoi usare altri algoritmi per ottenere risultati migliori. 

Ecco l'elenco dei principali algoritmi di clustering:

• Affinity Propagation
• Clustering gerarchico agglomerativo
• 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 sei alle prime armi con Tableau e vuoi imparare tutto su visualizzazione dei dati e calcolo statistico, segui il percorso di competenze Tableau Fundamentals. 

Nella seconda parte di questa serie di tutorial, esploriamo script Python complessi con TabPy. Impareremo a distribuire il modello di forecast Facebook Prophet sul server TabPy e a creare visualizzazioni di serie temporali dinamiche.