Python-Funktionen und Prophet-Vorhersagemodell mit TabPy in Tableau bereitstellen

TabPy Tools

TabPy Tools ist ein Python-Paket zum Bereitstellen und Verwalten von Python-Funktionen auf dem TabPy-Server. 

Lass uns die Funktionen der TabPy Tools im Detail anschauen.

Verbindung zu TabPy

Mit der Client-Funktion verbindest du die Python-API per URL und PORT mit dem TabPy-Server. 

rom tabpy.tabpy_tools.client import Client

client = Client('http://localhost:9004/')

Über das Objekt „client“ kannst du die Authentifizierung setzen und Python-Funktionen auf dem Server verwalten. 

Authentifizierung

Lege Benutzername und Passwort mit der Funktion „set_credentials“ fest. Für die Bereitstellung eines Modells auf dem Server sind Zugangsdaten erforderlich. 

Hinweis: Führe diese Funktion nur aus, wenn du die Authentifizierung auf dem TabPy-Server aktiviert hast. Lies die Serverkonfigurations-Dokumentation, um mehr zu erfahren.  

client.set_credentials('username', 'password')

Funktion bereitstellen

Erstelle eine Funktion und veröffentliche sie mit client.deploy(). Dafür brauchst du drei Argumente: Funktionsname, Python-Funktion und Beschreibung. 

Die Funktion addition addiert zwei Datenfelder und gibt die Liste zurück. Später greifen wir in Tableau auf die Funktion „add“ zu.

client.deploy('add', addition, 'Adds two numbers x and y')

Modell bereitstellen

Wenn du ein Machine-Learning-Modell trainiert und die Inferenzfunktion bereitgestellt hast, speichert Tableau das Modell und die Funktionsdefinition automatisch mit cloudpickle. Es verbleibt im Server-Speicher, um schnellere Antwortzeiten zu liefern. 

Kurz gesagt: Du musst dein Modell nicht jedes Mal neu trainieren, wenn sich in Tableau etwas ändert. Mehr zum Bereitstellen von Modellen folgt in den nächsten Abschnitten. 

Endpoints entfernen

Um eine Funktion oder ein Modell zu entfernen, verwende die Funktion remove. Dafür genügt der Funktionsname. 

client.remove('add')

>>> Für weitere fortgeschrittene Features wirf einen Blick ins GitHub-Repository TabPy/tabpy.

Eine Python-Funktion über die IDE bereitstellen

Wie im ersten Teil erstellen wir eine Funktion für den Pearson-Korrelationskoeffizienten. Statt die Funktion in Tableau zu schreiben, deployen wir sie dieses Mal über die Python-API auf den Server und greifen dann per Tableau-Berechnung darauf zu.

In diesem Abschnitt verwenden wir das Sales Store Product-Dataset von Kaggle, um die Korrelation zwischen den Feldern Sales und Profit zu berechnen. 

Kaggle-Datensatz Sales Store Product

Bevor wir mit dem Python-Code starten, stelle sicher, dass du das aktuelle TabPy-Paket installiert hast.

pip install -U tabpy

Starte den Server lokal über das Terminal.

tabpy

TabPy-Client 

Wenn du mit Python vertraut bist, ist dieser Teil schnell verstanden. Alles über Python-Funktionen lernst du im Kurs Introduction to Python.

1. Wir importieren Client aus tabpy_tools und NumPy für Berechnungen. 
2. Verbinde den TabPy-Server über URL und PORT.
3. Erstelle pearson_correlation_coefficient(), das x und y entgegennimmt und den Korrelationskoeffizienten als Einzelwert zurückgibt. 
4. Veröffentliche die Funktion „pcc“ mit client.deploy(). Es braucht drei Argumente: Name, Funktion und Beschreibung.  

from tabpy.tabpy_tools.client import Client
import numpy as np


client = Client('http://localhost:9004/')


def pearson_correlation_coefficient(x,y):
    return np.corrcoef(x,y)[0,1]


client.deploy('pcc', pearson_correlation_coefficient, 'correlation coefficient is extracted of x and y')

TabPy Query 

Jetzt rufen wir die Funktion in Tableau mit tabpy.query() auf. Dafür brauchst du den Python-Funktionsnamen und Argument-Platzhalter wie _arg1 und _arg2. 

1. Füge innerhalb von SCRIPT_REAL das Query-Skript ein und aggregiere die Datenfelder. 
2. Das Query-Skript beginnt mit return und endet mit [‘response’], um das Ergebnis aus dem JSON zu ziehen.
3. Setze die Standardtabellenberechnung auf das Datenfeld Customer Name.
4. Apply und dann auf OK klicken.

Berechnetes Feld für den Pearson-Korrelationskoeffizienten

Den ersten Teil des Tutorials kannst du zur Auffrischung der Tableau-Skriptsprache heranziehen. 

SCRIPT_REAL("return tabpy.query('pcc',_arg1, _arg2)['response']",
SUM([Sales]),SUM([Profit]))

Datenvisualisierung 

Nun erstellen wir eine Visualisierung, die die Korrelation nach Produktkategorie und Kundensegment zeigt.

1. Ziehe Customer Name auf Detail und Ship Mode auf Color im Marks-Panel. 
2. Ziehe Customer Segment und pcc (berechnetes Korrelationsfeld) in das Columns-Regal. 
3. Ziehe Product Category in das Rows-Regal.

Balkendiagramm des Korrelationskoeffizienten 

In den meisten Fällen zeigt der Bereich Corporate eine hohe Korrelation zwischen Umsatz und Gewinn. Insgesamt kannst du mit Korrelationskoeffizienten datenbasierte Entscheidungen treffen, um den Unternehmensgewinn zu steigern. 

Lies unser Tutorial Python details on correlation, um weitere Korrelationsmaße, die Berechnung in Python und den Zusammenhang von Korrelation und Kausalität kennenzulernen. 

Prophet-Modell in Tableau bereitstellen 

In diesem Abschnitt deployen wir das Facebook-Prophet-Vorhersagemodell und lernen, Datumsfelder zu modifizieren. Wir trainieren das Zeitreihenmodell auf den Apple Stock Prices von 2015 bis 2020. 

Kaggle-Datensatz Apple Stock Prices (2015-2020)

Bevor wir Skripte schreiben und die Vorhersagevisualisierung in Tableau erstellen, testen wir den Python-Code und evaluieren das Vorhersagemodell in Jupyter Notebook. 

Facebook Prophet 

Facebook Prophet ist eine Open-Source-Bibliothek für die automatische Vorhersage univariater Zeitreihen. Sie funktioniert besonders gut mit jährlicher, wöchentlicher und täglicher Saisonalität. 

Warum Prophet? 

Prophet geht gut mit fehlenden Werten, Trendwechseln und Ausreißern um.  

Prophet installieren

Du kannst das Prophet-Python-Paket mit dem folgenden Befehl im Terminal installieren. 

pip install pystan==2.19.1.1
pip install prophet

Oder, wenn du die Anaconda-Python-Umgebung nutzt, verwende diesen Befehl. 

conda install -c conda-forge prophet

Projektinitialisierung 

1. Wir importieren pandas für Datenaufnahme und -aufbereitung und Prophet für das Training und die Evaluierung von Vorhersagemodellen. 
2. Lies den Apple-Stock-Datensatz (AAPL.csv) mit der pandas-Funktion read_csv ein.
3. Definiere X mit den Spalten date und high.   
4. Gib die Form des DataFrames aus und visualisiere den Zeitreihen-Linienplot der Spalte high. 

import pandas as pd
from prophet import Prophet
data = pd.read_csv("AAPL.csv")
X = data.loc[:, ['date','high']]
print(X.shape)
X.plot();

Ausgabe

(1258, 2)

Die Apple-Aktie steigt im Zeitverlauf. Es gab zwei Dellen, doch insgesamt ist das Wachstum stabil. 

Für tiefere Einblicke folge dem Tutorial Python time series analysis von Hugo Bowne-Anderson. Oder sammle Praxis in DataCamps Kurs zur Zeitreihenanalyse in Python.  

Das Machine-Learning-Modell aufbauen

Hier bereiten wir die Daten für Prophet vor und trainieren das Modell mit Standard-Hyperparametern. 

1. Benenne die Spalten in ds und y um.
2. Wandle die Spalte ds in Datetime (Datum) um.
3. Definiere ein model mit Prophet().
4. Trainiere das Modell mit model.fit().

X.columns = ['ds', 'y']
X['ds']= pd.to_datetime(X['ds'], format='%Y-%m-%d').dt.date

model = Prophet()
# fit the model
model.fit(X)

Modellevaluierung

Zur Evaluierung müssen wir zukünftige Daten hinzufügen. Das erreichen wir mit make_future_dataframe. 

Wir setzen:

• periods auf 365 Tage
• freq auf „D“. Du kannst auch „Y“ wählen, musst dann aber periods auf 1 ändern.
• include_history auf false, um vorherige Daten auszuschließen.

future = model.make_future_dataframe(periods=365,
                                    freq='D',
                                    include_history=False
                                    )
future.tail()

Ausgabe

Wie zu sehen ist, endet der future-Datensatz im Jahr 2021. 

        ds
360 2021-05-18
361 2021-05-19
362 2021-05-20
363 2021-05-21
364 2021-05-22

Als Nächstes nutzen wir diese Daten, um die high-Werte der Apple-Aktie vorherzusagen. Anschließend zeigen wir „ds“, „yhat“, „yhat_lower“ und „yhat_upper“ an. 

Die Spalten yhat_lower und yhat_upper definieren den akzeptablen Schwankungsbereich. Vereinfacht: Der Aktienkurs kann bis auf 485,3 steigen und auf 365,4 fallen. Diese Information hilft Daytradern bei der Risikoeinschätzung. 

forecast = model.predict(future)
forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail

Ausgabe

    ds       yhat yhat_lower yhat_upper
360 2021-05-18 423.757736 365.415878 485.293438
361 2021-05-19 423.862811 365.527086 482.751097
362 2021-05-20 423.918642 365.233839 482.501335
363 2021-05-21 423.842872 364.454184 483.672508
364 2021-05-22 421.187822 360.181717 481.024524

Visualisieren wir die Vorhersage mit der Funktion plot(). Sie benötigt die Prognosewerte und zeigt Punkte- und Liniendiagramm inklusive des blauen Unsicherheitsbereichs. 

model.plot(forecast)

Die folgende Visualisierung zeigt, dass der Wert der Apple-Aktie ohne größeren Einbruch weiter steigt. 

Du kannst die Vorhersage verbessern, indem du Hyperparameter zu Sättigungsvorhersagen, Trendwechselpunkten, Saisonalität, Feiertagseffekten sowie Regressoren, multiplikativer Saisonalität, Unsicherheitsintervallen und Ausreißern anpasst. Alternativ lässt du sie per Hyperparameter-Tuning automatisch optimieren. Mehr zu Facebook Prophet findest du in der Dokumentation.  

Zeitreihenvorhersage ist ein weites Feld. Eine umfassende Einführung bekommst du im Tutorial time series forecasting von Moez Ali. Es behandelt Zeitreihenanalyse, statistische Modelle, Python-Frameworks und AutoML. 

Oder nimm an unserem Kurs visualizing time series data in Python teil und lerne alles über Liniendiagramme, Saisonalität, Trend und Rauschen sowie die Darstellung mehrerer Zeitreihen.  

Modellinferenz bereitstellen 

In diesem Abschnitt deployen wir die Modellinferenz. So lassen sich Modell und Funktionsdefinition auf dem TabPy-Server speichern und schnelle Antwortzeiten erzielen. 

Zuerst verbinden wir den Client über URL und PORT. Danach definieren wir die Funktion prophet_forecasting. 

1. Sie nimmt die Anzahl der Vorhersagejahre entgegen und erzeugt daraus ein future-DataFrame. 
2. Erstelle Vorhersagen mit model.predict und dem future-DataFrame. 
3. Benenne „yhat“ in „y“ um, damit wir die Prognose mit historischen Daten zusammenführen können. 
4. Der letzte Teil ist knifflig: In Tableau können wir dem data-Feld keine Werte hinzufügen. Stattdessen verschieben wir die Datumswerte um 365*n, wobei n die Anzahl der Jahre ist.

Zum Schluss paketieren und deployen wir alles mit client.deploy() auf den TabPy-Server. Wir nennen die Funktion „prophet“. Das Argument override ermöglicht Versionen der Funktion bzw. des Modells. Das ist am Anfang beim Debuggen hilfreich. 

from tabpy.tabpy_tools.client import Client

client = Client('http://localhost:9004/')

def prophet_forecasting(n):
 
    future = model.make_future_dataframe(periods=365*n,include_history=False)
    prediction = model.predict(future)
    prediction.rename(columns={"yhat":"y"}, inplace=True)
 
    return pd.concat([X,prediction[['ds','y']]])['y'].to_list()[365*n:]

client.deploy('prophet',
              prophet_forecasting,
              'forecast time series data using prophet',override=True)

Tableau einrichten

Um die Jahresanzahl in Tableau zu steuern, erstellen wir einen Years-Parameter. Er wird in der prophet-Funktion verwendet. 

Erstelle den Parameter Years, indem du im Bereich Data mit Rechtsklick Create Parameter wählst. Setze Data type auf Integer, Current value auf 1, und lege unter Range Minimum 1 und Maximum 5 fest.

Years-Parameter erstellen 

Danach erstellen wir ein berechnetes Feld Forecast_date. Wir nehmen das Datenfeld Date und verschieben die Werte um die Anzahl der Years. 

Berechnetes Feld Forecast_date 

Die Funktion DATEADD addiert die Years zum Datenfeld Date und wird dann auf den Tag gekürzt. 

DATETRUNC('day',DATEADD('year',[Years],[Date])))

Im nächsten Schritt erstellen wir ein berechnetes Feld forecast und greifen über tabpy.query() auf das bereitgestellte Modell zu. Die Query-Funktion besteht aus zwei Teilen: dem Namen der Python-Funktion und der Liste der Argument-Platzhalter. 

Berechnetes Feld forecast 

In unserem Fall ist es nur ein Argument, daher fügen wir _arg1 hinzu. Wir kapseln die Query in die Tableau-Funktion SCRIPT_REAL und übergeben den Parameter Years als Input. Bevor du auf OK klickst, stelle sicher, dass die Ergebnisse entlang von Forecast_date berechnet werden. Du kannst das über den blauen Text (Default Table Calculation) ändern.

SCRIPT_REAL("return tabpy.query('prophet',_arg1[0])['response']",
[Years]
)

Danach erstellen wir ein berechnetes Feld Actual auf Basis des Datenfelds High und des Parameters Years. 

Berechnetes Feld Actual 

LOOKUP verschiebt die High-Werte um Years*365. Beispiel: Steht Years auf 2, werden die Werte um 730 versetzt.

LOOKUP(SUM([High]),[Years]*365)

Ist vs. Forecast

Geschafft. So zeichnest du das Liniendiagramm Actual vs. Forecast:

1. Gehe unten links zu Parameters, Rechtsklick auf den Parameter Years und wähle Show Parameters.
2. Ziehe Forecast_date in das Columns-Regal. Stelle auf Day um.
3. Ziehe Measure Names aus Dimensions in Filters. Wähle nur Actual und forecast. 
4. Ziehe Measure Names aus Dimensions auf Color.
5. Ziehe abschließend Measure Names aus Measures in das Rows-Regal.

Nach diesen Schritten siehst du Actual und forecast in unterschiedlichen Farben. 

Liniendiagramm: Actual vs. Forecast

Das obige Liniendiagramm ist noch nicht perfekt und benötigt Hyperparameter-Tuning, Cross-Validation, das Imputieren fehlender Werte und Daten sowie Verbesserungen an der Datumslogik. 

Fazit

In diesem Tutorial haben wir gelernt, ein Machine-Learning-Modell auf dem TabPy-Server zu erstellen und bereitzustellen und per Tableau-Skript darauf zuzugreifen. Außerdem hast du die Basics von tabpy_tools kennengelernt und wie sich damit Funktionen oder Modelle deployen lassen. 

Erfahre mehr über Finanzprognosen im DataCamp-Kurs. Du lernst Gewinn- und Verlustrechnung, Bilanz und Kennzahlen zu verstehen, Rohdaten aufzubereiten, mit Stichtagen und Perioden umzugehen sowie Annahmen und Abweichungen in Prognosen zu managen.

Zeitreihenvorhersage ist die Basis. Bessere Prognosen erzielst du, wenn du weitere Machine-Learning-Algorithmen auf die Daten anwendest, zum Beispiel:

• Autoregressive Integrated Moving Average (ARIMA)
• Seasonal Autoregressive Integrated Moving Average (SARIMA)
• Exponentielle Glättung (ES)
• XGBoost
• LSTM (Deep Learning)
• Temporal Fusion Transformer (Google)

Wenn du neu bei Tableau bist und alles über Datenvisualisierung und statistische Berechnungen lernen möchtest, starte mit dem Lernpfad Tableau fundamentals. 

Dies ist der letzte Teil der Serie. Im ersten Teil dieses TabPy-Tutorials haben wir TabPy grundlegend erklärt und ein Python-Skript in Tableau ausgeführt, um verschiedene Cluster von Airbnb-Angeboten in Amsterdam zu erstellen.