K-Means-Cluster in Tableau mit TabPy: Tutorial

Was ist TabPy

TabPy ist ein Framework, mit dem Tableau Python-Code ausführen kann. Damit lassen sich Python-Skripte in berechneten Feldern in Tableau ausführen oder Funktionen über die Python-API auf dem TabPy-Server bereitstellen.

TabPy ist ein leistungsstarkes Tool mit verschiedenen Konfigurationen und Utilities. Du kannst es in deine Tableau-Visualisierung integrieren – änderst du Parameter, läuft das Python-Skript automatisch und liefert dir eine dynamische Visualisierungserfahrung.

Warum TabPy?

Obwohl Tableau umfangreiche Funktionen zum Erstellen, Bearbeiten und Bereinigen von Datenfeldern mitbringt, bleiben die statistischen Möglichkeiten eher einfach. Für fortgeschrittene Statistik und Machine Learning kombinieren wir Tableau mit starken Python-Bibliotheken.

Lerne verschiedene statistische Techniken in Tableau in einem interaktiven DataCamp-Kurs.

In diesem Tutorial richten wir einen TabPy-Server ein und setzen ein kleines Machine-Learning-Projekt um. Wir nutzen den K-Means-Algorithmus, um AirBnB-Angebote in Amsterdam in verschiedene Cluster zu unterteilen.

TabPy einrichten

Die Einrichtung eines TabPy-Servers ist unkompliziert. Du kannst TabPy per `pip` im Terminal oder mit `!pip` im Jupyter Notebook installieren. Dadurch werden Server und Python-Client-API automatisch mit installiert.

pip install tabpy

Zum Starten des Servers gibst du im Terminal `tabpy` ein. Nach wenigen Sekunden läuft der Server lokal auf Port 9004.

tabpy

Ausgabe

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

Du kannst deinen TabPy-Server über eine Konfigurationsdatei mit folgendem Befehl steuern.

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

Konfigurierbar sind unter anderem:

• HTTP- vs. HTTPS-Verbindung
• Benutzerverwaltung
• Logging

TabPy gibt dir die Freiheit, den Server an Sicherheits- und QA-Vorgaben deines Unternehmens anzupassen. Sieh dir die Beispiel-Konfigurationsdatei an und erfahre, wie du einen Server mit spezifischen Anforderungen aufsetzt.

TabPy auf Heroku deployen

Wenn du Tableau Cloud oder Tableau Server nutzt, musst du einen TabPy-Server in der Cloud oder auf einer Webhosting-Plattform bereitstellen. Das geht per Docker-Image oder durch direktes Deployen auf Heroku.

So startest du den Remote-Server auf Heroku:

• Melde dich über den Browser bei deinem Heroku-Konto an. Falls du noch keines hast, kannst du dich kostenlos registrieren.
• Öffne das TabPy-Repository auf GitHub und klicke im Readme auf den Button "Deploy to Heroku".

• Befolge die Anweisungen. Vergib einen Servernamen und wähle den Standort.
• Lege die Umgebungsvariablen für Benutzername und Passwort fest.

Schon ist dein Server ohne Aufwand bereitgestellt. Du kannst Tableau per URL und Port verbinden.

Verbindung mit TabPy herstellen

Stelle sicher, dass dein TabPy-Server lokal oder remote läuft, bevor du ihn mit Tableau verbindest.

Zur Verbindung klickst du im Menü auf Hilfe und wählst Einstellungen und Leistung > Verbindung mit Analytics-Erweiterung verwalten. Es erscheint ein Fenster mit Verbindungstypen: TabPy, Einstein Discovery, RServe und Analytics Extension API.

Wähle TabPy aus. Im nächsten Fenster trägst du Hostname, Port, Benutzername und Passwort ein. Benutzername und Passwort lassen wir aus, da wir sie nicht gesetzt haben.

Im nächsten Schritt setzen wir den Hostname auf „localhost“ und den Port auf „9004“ und klicken auf Verbindung testen. Nach erfolgreichem Test speichern wir die Verbindungskonfiguration.

Python in Tableau-Berechnungen verwenden

Um ein Python-Skript in einem berechneten Feld auszuführen, brauchst du je nach Rückgabewert eine dieser Skriptfunktionen:

• SCRIPT_BOOL
• SCRIPT_INT
• SCRIPT_REAL
• SCRIPT_STR

Gibt deine Funktion boolesche Werte zurück, nutze SCRIPT_BOOL. Alternativ kannst du Ganzzahlen zurückgeben und sie anschließend mit nativen Funktionen in andere Typen umwandeln.

In diesem Abschnitt verwenden wir ein Store-Sales-Dataset von Kaggle. Zwischen den Feldern Sales und Profit berechnen wir den Pearson-Korrelationskoeffizienten.

SCRIPT_REAL benötigt zwei Teile: Zuerst das Python-Skript in doppelten Anführungszeichen, dann die aggregierten Argumente.

Wir nutzen das Python-Paket Numpy, um die Korrelation zwischen den Argumenten Sales und Profit zu berechnen. Argumente werden nicht direkt übergeben, sondern über Platzhalter wie „_arg1“ und „_arg2“. Beispiel: SUM([Profit]) steht an zweiter Stelle und ist damit „_arg2“ zugeordnet.

Wir extrahieren den Korrelationskoeffizienten aus der np.corrcoef-Matrix, um eine einzelne Spalte zurückzugeben.

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

Nachdem du das Skript im berechneten Feld „Correlation“ eingefügt hast, klicke auf Anwenden. Das Skript wird ausgeführt und liefert Werte je Customer Name.

Bevor du auf OK klickst, klicke auf den Text „Standardtabelle berechnen“ und ändere die Option von Automatisch auf Customer Name.

So erstellst du ein Streudiagramm für Produktkategorie und Kundensegmentierung:

1. Ziehe die Felder Category und Sales in das Regal Columns.
2. Ziehe dann Customer Segment und Profit in das Regal Rows.
3. Ziehe Customer Name auf Detail im Bereich Marks.
4. Ziehe abschließend das neu erstellte berechnete Feld Correlation auf Label im Bereich Marks.

Die Grafik oben zeigt den Korrelationskoeffizienten je Kundin/Kunde, aufgeschlüsselt nach Produktkategorie und Kundensegment. Zwischen der Kategorie Furniture und Small Business-Kund:innen besteht eine hohe Korrelation.

Clustering-Python-Skript in Tableau

In diesem Abschnitt verwenden wir das Airbnb Amsterdam-Dataset und erstellen Cluster mit dem K-Means-Algorithmus und dem Machine-Learning-Framework scikit-learn.

Bevor wir mit TabPy skripten, analysieren und verstehen wir das Dataset in Jupyter Notebook.

Projektinitialisierung

Wir nutzen pandas für Dateneinlesung und -bereinigung, matplotlib und seaborn für Visualisierung sowie scikit-learn für Datenaufbereitung und Clustering.

Zuerst importieren wir die benötigten Python-Pakete und lesen die Datei „listing.csv“ ein. Danach prüfen wir fehlende Werte mit .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()

Wie zu sehen ist, fehlen Werte in neighbourhood_group, last_review und reviews_per_month. Anstatt zu imputieren oder zu droppen, lassen wir diese Spalten für das Training außen vor.

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

Daten aufbereiten

Wir erstellen ein DataFrame X mit den relevanten Features fürs Training. Diese Features haben keine fehlenden Werte, keine eindeutigen IDs und keine starke Korrelation. Beispielsweise nehmen wir id, name, host_id, host_name, latitude und longitude nicht auf.

Kategoriale Spalten wandeln wir mit LabelEncoder() in numerische Werte um. Für mehrere Spalten nutzen wir 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()

Das finale DataFrame enthält sieben Spalten mit numerischen Werten.

Das Elbow für K-Means finden

Die Elbow-Methode hilft, die optimale Clusteranzahl für ein Dataset zu bestimmen. Wir nutzen n_clusters und .inertia_, um Liniendiagramme mit einem Ellbogenverlauf zu zeichnen. Inertia ist die Summe der quadrierten Abstände der Stichproben zum nächstgelegenen Clusterzentrum.

Der Code unten läuft von 1 bis 9 und hängt die Inertia-Werte an das Array clusters an. Anschließend plotten wir Cluster vs. Inertia als Liniendiagramm.

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

Die Grafik zeigt einen ersten Knick bei 3 und einen zweiten bei 4. Beide Clusterzahlen nehmen wir in die visuelle Analyse in Tableau auf.

Mehr dazu: K-Means-Clustering in Python mit scikit-learn in unserem Tutorial.

N-Cluster-Parameter erstellen

Damit wir die Clusteranzahl nicht manuell im Code ändern müssen, erstellen wir einen Parameter mit dem Bereich 1 bis 10.

Parameter erstellst du per Rechtsklick im Bereich Data über Create Parameter. Setze Data type auf Integer, Current value auf 1 und definiere unter Range die Werte Minimum 1 und Maximum 10.

Python-Skript im berechneten Feld

Jetzt übertragen wir den Code aus dem Jupyter Notebook in ein berechnetes Feld in Tableau. Das berechnete Feld benötigt kein separates Laden des Datasets – wir greifen direkt auf die vorhandenen Felder zu und übergeben sie über SCRIPT_INT-Argumente.

1. Wir wandeln Argument eins und zwei per LabelEncoder in numerische Werte um.
2. Wir lesen alle Argumente ein und vergeben sprechende Variablennamen.
3. Wir stapeln alle Eingaben außer N spaltenweise.
4. Wir definieren ein Modell mit „N“ Clustern. N steuern wir über den Parameter N Clusters.
5. Wir trainieren und sagen die Cluster mit den Features voraus.
6. Wir geben die Ausgabe als Liste von Ganzzahlen zurück.

Der zweite Teil des Skripts sind die aggregierten Datenfelder plus ein Parameter.

Am Code unten siehst du die Zuordnung zwischen Argumenten und Datenfeldern.

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

Erstelle ein neues berechnetes Feld (Kmean) und füge den Code ein. Achte darauf, dass die Berechnung entlang von Host Id erfolgt. Du kannst das über den blauen Text Standardtabelle berechnen anpassen.

Datenvisualisierung

Für die folgende Visualisierung gehst du so vor:

1. Ziehe Price in das Regal Columns und Number of Reviews in Rows.
2. Öffne oben das Menü Analysis und deaktiviere Aggregate Measures.
3. Ziehe Host Id auf Detail im Bereich Marks und das berechnete Feld Kmean auf Color.
4. Stelle Kmean per Rechtsklick auf Diskret um.
5. Rechtsklicke auf N Clusters im Bereich Parameters und wähle Show Parameters, um den Regler rechts anzuzeigen.
6. Stelle den Regler N Clusters auf 3 oder 4, um die Ergebnisse in Echtzeit zu sehen.

Im nächsten Schritt erstellen wir mehrere Visualisierungs-Sheets, indem wir Datenfelder und Clusteranzahl variieren.

1. Price vs Availability: Es erscheinen vier Cluster. Darauf aufbauend ließe sich ein Empfehlungssystem für Airbnb oder Hotels entwickeln.
2. Reviews vs Availability: Obwohl N Clusters auf 3 steht, sehen wir zwei große Cluster.
3. Listings vs Price: Deutlich erkennbar sind rote, blaue und grüne Cluster. Das gelbe in der Ecke ist von Grün und Blau umgeben.

Vertiefe dein Wissen zu Advanced Analytics und Visualisierung im Kurs Analyzing Data in Tableau. Du lernst Datenaufbereitung, Exploration, Kartenanalysen, Gruppen, Sets und Parameter.

Wenn dir das Clustering-Tutorial gefallen hat, setze die Datenpunkte doch auf einer Karte um. Ziehe einfach Latitude und Longitude auf die Regale Columns und Rows.

Du kannst Cluster auch ohne TabPy erstellen – schau dir dazu unser Tutorial Cluster Analysis in the Tableau an.

Fazit

Mit TabPy öffnest du die Tür zu unzähligen Möglichkeiten, deine aktuelle Analytics-Umgebung zu automatisieren und zu verbessern. Du kannst damit Deep-Learning-Modelle in Dashboards integrieren, komplexe Statistikaufgaben ausführen und Continuous Integration und Development umsetzen.

Die TabPy-Integration bringt einige Einschränkungen mit sich, etwa eine einzelne Ausgabe. Das betrifft vor allem Data Scientists oder Machine-Learning-Engineers.

In diesem Beitrag haben wir TabPy (Python-Server für Tableau) kennengelernt und gesehen, wie man damit K-Means-Cluster erstellt. Clustering ist wichtig in E‑Commerce, Reise- und Entertainment-Branche, um Kundenverhalten zu verstehen. Wir haben K-Means genutzt – du kannst aber auch andere Algorithmen einsetzen, um bessere Ergebnisse zu erzielen.

Hier sind einige der wichtigsten Clustering-Algorithmen:

• Affinity Propagation
• Agglomeratives hierarchisches 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

Wenn du neu bei Tableau bist und alles über Datenvisualisierung und statistische Berechnungen lernen willst, starte mit dem Skill-Lernpfad Tableau Fundamentals.

Im zweiten Teil dieser Tutorialreihe arbeiten wir mit komplexeren Python-Skripten in TabPy. Wir deployen das Prognosemodell Facebook Prophet auf dem TabPy-Server und erstellen dynamische Zeitreihen-Visualisierungen.