K-means-clusters in Tableau met TabPy: tutorial

Wat is TabPy

TabPy is een framework waarmee Tableau Python-code kan uitvoeren. Het stelt je in staat om Python-scripts te draaien binnen een berekend veld van Tableau, of functies te deployen op de TabPy-server via de Python-API.  

TabPy is een krachtig hulpmiddel met verschillende configuraties en utilities. Je kunt het integreren met je Tableau-visualisatie; telkens wanneer je parameters wijzigt, draait het Python-script automatisch voor een dynamische visualisatie-ervaring. 

Waarom TabPy? 

Hoewel Tableau uitgebreide functionaliteit biedt om gegevensvelden te maken, te bewerken en op te schonen, ben je beperkt tot eenvoudige statistische functies. Om geavanceerde statistiek zoals machine learning te benutten, integreren we krachtige Python-bibliotheken met Tableau. 

Leer verschillende statistische technieken in Tableau met een interactieve DataCamp-cursus.

In deze tutorial zetten we een TabPy-server op en werken we aan een eenvoudig machinelearningproject. We gebruiken het K-means-algoritme om AirBnB-aanbiedingen in Amsterdam in verschillende clusters te verdelen. 

TabPy instellen

Het opzetten van een TabPy-server is eenvoudig. Je installeert TabPy met `pip` in de terminal of `!pip` in Jupyter Notebook. Dit installeert automatisch de server en de client-API voor Python.

pip install tabpy

Om de server te starten, typ je `tabpy` in de terminal. Na enkele seconden zie je dat de server lokaal draait op poort 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

TabPy-server configureren

Je kunt je TabPy-server configureren met het config-bestand en onderstaand commando. 

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

Je kunt configureren:

• HTTP- versus HTTPS-verbinding
• Gebruikersbeheer 
• Logging

TabPy geeft je de vrijheid om de server aan te passen aan het beveiligings- en kwaliteitsbeleid van je bedrijf. Bekijk het voorbeeld-config-bestand en leer hoe je een server opzet met specifieke eisen. 

TabPy deployen op Heroku

Als je Tableau Cloud of Tableau Server gebruikt, moet je een TabPy-server deployen op een cloud- of webhostingplatform. Dat kan met een Dockerfile of door de server direct op Heroku te deployen. 

Zo draai je de externe server op Heroku:

• Log in op je Heroku-account via de browser. Heb je nog geen account, meld je dan gratis aan.
• Ga naar de TabPy-repository op GitHub en klik in de Readme op de knop "Deploy to Heroku".

• Volg de instructies. Geef de servernaam op en selecteer de serverlocatie.
• Stel de omgevingsvariabelen username en password in.

Je server is zonder gedoe gedeployd. Je kunt Tableau verbinden met de URL en het poortnummer. 

Verbinding maken met TabPy

Zorg dat je TabPy-server lokaal of extern draait voordat je verbinding maakt met Tableau.  

Om de server te verbinden, klik je op het menu Help en kies je Settings and Performance > Manage Analytics Extension Connection. Er opent een nieuw venster met verschillende verbindingstypen: TabPy, Einstein Discovery, RServe en Analytics Extension API. 

We kiezen de TabPy-optie, waarna een venster verschijnt waarin je Hostname, Port, Username en Password kunt invullen. We negeren de opties username en password omdat we die niet hebben ingesteld.

Vul vervolgens Hostname in als “localhost” en Port als “9004” en klik op Test Connection. Na een geslaagde test slaan we de verbindingsconfiguratie op. 

Python gebruiken met Tableau-berekeningen

Om een Python-script in een berekend veld te draaien, gebruik je een van deze scriptfuncties op basis van je output:

• SCRIPT_BOOL
• SCRIPT_INT
• SCRIPT_REAL
• SCRIPT_STR

Als je functie booleans retourneert, gebruik je SCRIPT_BOOL. Je kunt ook altijd gehele getallen ophalen en die vervolgens met native functies naar andere types converteren. 

In deze sectie gebruiken we een winkelverkopen-dataset van Kaggle. Met de gegevensvelden Sales en Profit berekenen we de Pearson-correlatiecoëfficiënt. 

De SCRIPT_REAL-functie vereist twee delen. Het eerste is Python-code tussen dubbele aanhalingstekens, het tweede deel zijn geaggregeerde argumenten. 

We gebruiken het Python-pakket Numpy om de correlatie te berekenen tussen de argumenten Sales en Profit. We kunnen de argumenten niet direct toevoegen; in plaats daarvan gebruiken we placeholders zoals “_arg1” en “_arg2”. Bijvoorbeeld: SUM([Profit]) staat als tweede en is gekoppeld aan “_arg2”.

We halen simpelweg de correlatiecoëfficiënt uit de np.corrcoef-matrix om één kolom terug te geven. 

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

Na het toevoegen van het script aan het berekende veld “Correlation”, klik je op Toepassen. Het script draait en retourneert waarden per Customer Name. 

Voordat je op OK klikt, klik je op de tekst “Default Table Calculation” en wijzig je de optie van Automatic naar Customer Name. 

Zo maak je een scatterplot van productcategorie en klantsegmentatie: 

1. Sleep de gegevensvelden Category en Sales naar de plank Columns.
2. Sleep vervolgens de gegevensvelden Customer Segment en Profit naar de plank Rows. 
3. Sleep Customer Name naar de knop Detail in de sectie Marks. 
4. Sleep tot slot het nieuw gemaakte berekende veld Correlation naar de knop Label in de sectie Marks. 

De grafiek hierboven toont de correlatiecoëfficiënt van klanten per productcategorie en klantsegment. Er is een hoge correlatie tussen de categorie Furniture en Small Business-klanten.     

Clustering-Python-script in Tableau

In deze sectie gebruiken we de dataset Airbnb Amsterdam om clusters te maken met het K-means-algoritme en het machinelearningframework scikit-learn. 

Voordat we in TabPy-scripting duiken, analyseren en begrijpen we de dataset in Jupyter Notebook. 

Projectinitialisatie 

We gebruiken pandas voor data-inname en opschoning, matplotlib en seaborn voor datavisualisatie, en scikit-learn voor dataverwerking en clusteringalgoritmen.

Eerst importeren we de vereiste Python-pakketten en lezen we het bestand “listing.csv” in. Vervolgens verkennen we ontbrekende waarden met .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()

We zien dat er meerdere ontbrekende waarden zijn in neighbourhood_group, last_review en reviews_per_month. In plaats van deze kolommen te imputeren of te droppen, nemen we ze niet mee in de training van ons model. 

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

De gegevens verwerken

We maken een X-dataframe met essentiële features voor de training. Deze features hebben geen ontbrekende waarden, geen unieke ID’s en geen hoge onderlinge correlatie. Zo nemen we bijvoorbeeld id, name, host_id, host_name, latitude en longitude niet mee.

We hebben categorische kolommen; om die naar numeriek om te zetten, gebruiken we LabelEncoder(). Om dit op meerdere categorische kolommen toe te passen, gebruiken we de Pandas-functie .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()

Zoals je ziet heeft het definitieve dataframe zeven kolommen met numerieke waarden. 

De K-means-elbow zoeken

De Elbow-methode wordt gebruikt om het optimale aantal clusters voor een dataset te bepalen. We gebruiken n_clusters en .inertia_ om lijngrafieken met een elbow-patroon te tonen. Inertia is de som van de kwadratische afstanden van samples tot het dichtstbijzijnde clustercentrum. 

De onderstaande code draait van 1 tot 9 en voegt de inertia-waarden toe aan de array clusters. Daarna gebruiken we deze informatie om een lijngrafiek van clusters t.o.v. inertia te plotten. 

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

De grafiek laat zien dat de eerste knik bij 3 ligt en de tweede bij 4. We nemen beide aantallen clusters mee in de visuele analyse in Tableau. 

Je kunt meer leren over K-means-clustering in Python met scikit-learn in onze tutorial.  

N-clusters-parameter maken

Om te voorkomen dat we het aantal clusters handmatig in de code moeten invullen, maken we een parameter met een bereik van 1 tot 10. 

Parameters maak je door in de sectie Data met rechts te klikken en Create Parameter te kiezen. Zet Data type op Integer, Current value op 1, en klik op Range om Minimum 1 en Maximum 10 toe te voegen. 

Python-script in berekend veld

Nu zetten we de code over van Jupyter Notebook naar een berekend veld in Tableau. Het berekende veld in Tableau hoeft geen dataset te laden. We hebben de benodigde gegevensvelden al en gebruiken die via SCRIPT_INT-argumenten. 

1. We zetten argument één en twee om naar numeriek met LabelEncoder.
2. We halen alle argumenten op en geven ze passende variabelenamen. 
3. We stapelen alle invoerargumenten behalve N in kolommen. 
4. We definiëren een model met “N” clusters. Deze variabele kunnen we wijzigen met de parameter N Clusters.
5. Tot slot trainen en voorspellen we de clusters met de features.  
6. We retourneren de output als een lijst met gehele getallen. 

Het tweede deel van het script bestaat uit geaggregeerde gegevensvelden en een parameter. 

Bekijk de onderstaande code om de relatie tussen argumenten en gegevensvelden te begrijpen. 

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

Maak een nieuw berekend veld (Kmean) en kopieer en plak de bovenstaande code. Zorg dat je resultaten worden berekend over Host Id. Dit kun je wijzigen door op de blauwe tekst Default Table Calculation te klikken.  

Datavisualisatie

Volg deze stappen om de visualisatie hieronder te maken.

1. Sleep het gegevensveld Price naar de plank Columns en Number of Reviews naar de plank Rows. 
2. Ga naar het menu Analysis bovenaan en vink Aggregate Measures uit. 
3. Sleep het gegevensveld Host Id naar Detail in de sectie Marks, en het berekende veld Kmean naar Color. 
4. Wijzig het berekende veld Kmean naar Discrete via de rechtermuisknop.  
5. Klik met rechts op N Clusters in de sectie Parameters en kies Show Parameters om de schuifregelaar rechts te tonen. 
6. Stel de schuifregelaar N Clusters in op 3 of 4 om de resultaten realtime te zien.   

In het volgende deel maken we meerdere visualisatie-werkbladen door gegevensvelden en het aantal clusters te variëren.  

1. Price v/s Availability: we zien vier clusters. Op basis hiervan kun je een aanbevelingssysteem bouwen voor Airbnb of een hotelbedrijf. 
2. Review v/s Availability: we zien slechts twee grote clusters, ook al staat N Clusters op 3.  
3. Listings v/s Price: we zien rode, blauwe en groene clusters. Het geel in de hoek wordt omringd door groen en blauw. 

Leer meer over geavanceerde analyses en visualisatie met onze cursus Analyzing Data in Tableau. Je leert er alles over datavoorbereiding, exploratie, kaartanalyse, groepen, sets en parameters.   

Vond je de clustering-tutorial interessant? Probeer de punten dan op een kaart te zetten. Sleep simpelweg Latitude en Longitude naar de planken Columns en Rows. 

Je kunt ook clusters maken zonder TabPy via onze tutorial Cluster Analysis in the Tableau. 

Conclusie

Door TabPy te integreren, open je de deur naar eindeloze mogelijkheden om je huidige data-analyseopzet te automatiseren en te verbeteren. Je kunt het ook gebruiken om deep-learningmodellen te integreren in een analysetool, complexe statistische taken uit te voeren en continuous integration en development te implementeren. 

De TabPy-integratie kent een aantal beperkingen, zoals een enkele output. Deze beperkingen raken vooral data scientists of machine learning engineers. 

In dit artikel hebben we geleerd over TabPy (Python-server voor Tableau) en hoe je het gebruikt om K-means-clusters te maken. Clusters maken is belangrijk in de e-commerce-, reis- en entertainmentindustrie om het gedrag van klanten te begrijpen. We hebben K-means gebruikt, maar je kunt ook andere algoritmen inzetten voor betere resultaten. 

Hier is een lijst met toonaangevende clusteringalgoritmen:

• 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

Ben je nieuw met Tableau en wil je alles leren over datavisualisatie en statistische berekeningen? Volg dan de skill track Tableau Fundamentals. 

In het tweede deel van deze tutorialserie verkennen we complexere Python-scripts met TabPy. We leren het voorspellingsmodel Facebook Prophet te deployen op de TabPy-server en dynamische tijdreeksvisualisaties te maken.