Distribuire funzioni Python e modello di previsione Prophet in Tableau con TabPy

Strumenti TabPy

TabPy Tools è un pacchetto Python per distribuire e gestire funzioni Python sul server TabPy. 

Vediamo nel dettaglio le funzionalità degli strumenti TabPy.

Connessione a TabPy

La funzione client ti permette di connettere l'API Python al server TabPy usando URL e PORT. 

rom tabpy.tabpy_tools.client import Client

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

Possiamo usare l'oggetto "client" per impostare l'autenticazione e gestire le funzioni Python sul server. 

Autenticazione

Puoi impostare nome utente e password usando la funzione "set_credentials". È necessario impostare le credenziali per distribuire un modello sul server. 

Nota: esegui questa funzione solo se hai abilitato l'autenticazione sul server TabPy. Leggi la documentazione della configurazione del server per saperne di più.  

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

Distribuire una funzione

Crea una funzione e pubblicala usando la funzione `client.deploy()`. Richiede tre argomenti: nome della funzione, funzione Python e descrizione. 

La funzione di addizione somma due campi dati e restituisce l'elenco. In seguito, la funzione "add" sarà accessibile in Tableau.

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

Distribuire un modello

Quando hai addestrato un modello di machine learning e distribuito la funzione di inferenza del modello, Tableau salverà automaticamente il modello e la definizione delle funzioni usando cloudpickle. Rimane in memoria sul server per fornire tempi di risposta più rapidi. 

In poche parole, non devi riaddestrare il modello ogni volta che qualcosa cambia in Tableau. Impareremo di più sulla distribuzione dei modelli nelle prossime sezioni. 

Rimozione degli endpoint

Per rimuovere una funzione o un modello, usa la funzione `remove`. Richiede solo il nome della funzione. 

client.remove('add')Offerto da

>>> Per funzionalità più avanzate, dai un'occhiata al repository TabPy/tabpy su GitHub.

Distribuire una funzione Python usando l'IDE

Come nella prima parte, creeremo una funzione per il coefficiente di correlazione di Pearson. Invece di scrivere la funzione in Tableau, la distribuiremo sul server usando l'API Python e poi accederemo alla funzione tramite un calcolo in Tableau.

In questa sezione useremo il dataset Sales Store Product da Kaggle per calcolare la correlazione tra i campi dati vendite e profitto. 

Dataset Kaggle Sales Store Product

Prima di passare alla scrittura del codice Python, assicurati di avere l'ultima versione del pacchetto TabPy.

pip install -U tabpyOfferto da

Esegui il server in locale usando un terminale.

tabpyOfferto da

Client TabPy 

Se conosci Python, questa parte è piuttosto semplice da capire. Puoi imparare tutto sulle funzioni Python seguendo il corso introduzione a Python.

1. Importeremo Client da tabpy_tools e NumPy per i calcoli. 
2. Connetti il server TabPy usando URL e PORT.
3. Crea pearson_correlation_coefficient() che prenderà x e y e restituirà la singola colonna del coefficiente di correlazione. 
4. Usa la funzione client.deploy() per pubblicare la funzione "pcc". Richiede tre argomenti: nome, funzione e descrizione.  

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')Offerto da

Query TabPy 

Ora invocheremo questa funzione in Tableau usando tabpy.query(). Richiede i nomi della funzione Python e i segnaposto degli argomenti come _arg1 e _arg2. 

1. All'interno di SCRIPT_REAL, aggiungi lo script di query e aggrega i campi dati. 
2. Lo script di query inizia con return e termina con [‘response’] per estrarre i risultati dal JSON.
3. Imposta il calcolo tabella predefinito sul campo dati Customer Name.
4. Applica e premi OK.

Campo calcolato del coefficiente di correlazione di Pearson

Puoi rivedere la prima parte del tutorial per capire lo script Tableau. 

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

Visualizzazione dei dati 

Ora creeremo una visualizzazione che mostra la correlazione per categoria di prodotto e segmentazione dei clienti.

1. Trascina Customer Name su Detail e Ship Mode su Color nel pannello Marks. 
2. Trascina Customer Segment e pcc (campo calcolato della correlazione) nella mensola Columns. 
3. Trascina Product Category nella mensola Rows.

Visualizzazione del grafico a barre del coefficiente di correlazione 

Nella maggior parte dei casi, il settore Corporate mostra un'alta correlazione tra vendite e profitto. In generale, puoi usare i coefficienti di correlazione per prendere decisioni data-driven e aumentare il profitto dell'azienda. 

Leggi il nostro tutorial Dettagli su Python e la correlazione per conoscere altri coefficienti di correlazione, calcolare la correlazione in Python e il rapporto tra correlazione e causalità. 

Distribuire il modello Prophet in Tableau 

In questa sezione impareremo a distribuire il modello di previsione Facebook Prophet e a modificare i campi dati di tipo data. Addestreremo il modello di serie temporali sui prezzi azionari Apple dal 2015 al 2020. 

Dataset Kaggle Apple Stock Prices (2015-2020)

Prima di passare alla scrittura degli script e creare la visualizzazione delle previsioni in Tableau, dobbiamo testare il codice Python e valutare il modello di forecasting in Jupyter Notebook. 

Facebook Prophet 

Facebook Prophet è una libreria open source per il forecasting automatico di serie temporali univariate. Funziona al meglio con effetti di stagionalità annuali, settimanali e giornalieri. 

Perché Prophet? 

È efficace nel gestire dati mancanti, cambi di trend e outlier.  

Installazione di Prophet

Puoi installare il pacchetto Python Prophet usando il comando qui sotto nel terminale. 

pip install pystan==2.19.1.1
pip install prophetOfferto da

Oppure, se usi l'ambiente Python Anaconda, usa il comando qui sotto. 

conda install -c conda-forge prophetOfferto da

Inizializzazione del progetto 

1. Inizieremo importando pandas per l'ingestione e la manipolazione dei dati e Prophet per addestrare e valutare i modelli di forecasting. 
2. Leggi il file del dataset azionario Apple (AAPL.csv) usando la funzione read_csv di pandas.
3. Definisci X con le colonne date e high.   
4. Mostra la shape del dataframe e visualizza il grafico a linee della serie temporale della colonna 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();Offerto da

Output

(1258, 2)Offerto da

Il titolo Apple è in crescita nel tempo. Ha avuto due cali, ma è tornato a una crescita costante. 

Segui il tutorial analisi di serie temporali in Python di Hugo Bowne-Anderson per approfondire. Puoi anche seguire un breve corso di DataCamp sull'analisi di serie temporali in Python per fare pratica.  

Costruire il modello di Machine Learning

In questa parte, prepareremo i dati per il modello Prophet e lo addestreremo con gli iperparametri predefiniti. 

1. Rinomina le colonne in ds e y
2. Converti la colonna ds in datetime (data)
3. Definisci un model usando Prophet()
4. Addestra il modello con 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)Offerto da

Valutazione del modello

Per valutare, dobbiamo aggiungere date future al dataset. Possiamo farlo con make_future_dataframe. 

Imposteremo:

• prediods a 365 giorni
• freq su "D". Puoi anche cambiarlo in "Y" ma allora dovrai impostare periods a 1.
• Imposta include_history su false per omettere i dati precedenti.

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

Output

Come possiamo vedere, il dataset future termina con l'anno 2021. 

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

Il passo successivo è usare questi dati per predire i valori high del titolo Apple. Dopo mostreremo 'ds', 'yhat', 'yhat_lower' e 'yhat_upper'. 

yhat_lower e yhat_upper definiscono l'intervallo accettabile di varianza. In poche parole, il prezzo può salire fino a 485,3 e scendere a 365,4. Queste informazioni possono aiutare i day trader a valutare il rischio. 

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

Output

    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.024524Offerto da

Visualizziamo i dati delle previsioni usando la funzione plot(). Richiede i valori predittivi per mostrare il grafico a punti e linee con l'intervallo accettabile in blu. 

model.plot(forecast)Offerto da

La visualizzazione qui sotto mostra che le azioni Apple cresceranno di valore senza cali. 

Puoi migliorare le previsioni regolando gli iperparametri relativi a previsioni saturanti, changepoint del trend, stagionalità, effetti delle festività e regressori, stagionalità moltiplicativa, intervalli di incertezza e outlier. Puoi anche regolarli automaticamente con l'hyperparameter tuning. Scopri di più su Facebook Prophet leggendo la documentazione.  

Il forecasting di serie temporali è un campo vasto: puoi imparare tutto seguendo il nostro tutorial time series forecasting di Moez Ali. Il tutorial copre analisi delle serie temporali, modelli statistici, framework Python e AutoML. 

Puoi anche seguire il nostro corso visualizzare dati di serie temporali in Python, e imparare tutto su grafici a linee, rilevamento di stagionalità, trend e rumore, e visualizzazione di più serie temporali.  

Distribuire l'inferenza del modello 

In questa sezione distribuiremo l'inferenza del modello. Questo ci permetterà di memorizzare definizione del modello e della funzione nel server TabPy per fornire tempi di risposta più rapidi. 

Per prima cosa connetteremo il Client usando URL e PORT. Poi definiremo la funzione prophet_forecasting. 

1. Prenderà in input un numero di anni per la previsione e lo userà per creare un data frame future. 
2. Eseguirà le previsioni usando model.predict e il dataframe future. 
3. Rinomina "yhat" in "y" così da poter concatenare la previsione con i dati storici. 
4. L'ultima parte è delicata. In Tableau non possiamo aggiungere valore al campo data. Invece, sposteremo i valori Date di 365*n. Dove n è il numero di anni.

Infine, impacchetteremo e distribuiremo sul server TabPy usando client.deploy(). Imposteremo il nome della funzione "prophet". L'argomento override ci aiuterà a creare le versioni del modello e della funzione. Questo è necessario nella fase iniziale in cui facciamo il debug del codice. 

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)Offerto da

Configurare Tableau

Per controllare il numero di anni in Tableau, dobbiamo creare un parametro Years. Sarà usato nella funzione prophet. 

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

Creazione del parametro Years 

Dopodiché, creeremo un campo calcolato Forecast_date. Useremo il campo dati Date e sposteremo i valori in base al numero di Years. 

Campo calcolato Forecast_date 

La funzione DATEADD aggiungerà gli Years al campo dati Date e poi troncherà al giorno. 

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

Nella parte successiva, creeremo un campo calcolato forecast e accederemo al modello distribuito usando tabpy.query(). La funzione di query è composta da due parti: la prima è il nome della funzione Python e la seconda è l'elenco dei segnaposto per gli argomenti. 

campo calcolato forecast 

Nel nostro caso c'è un solo argomento, quindi aggiungeremo _arg1. Incapsuleremo la query in una funzione Tableau chiamata SCRIPT_REAL e forniremo il parametro Years come input. Prima di premere il pulsante OK, assicurati che i risultati siano calcolati lungo Forecast_date. Puoi cambiarlo cliccando sul testo blu (Default Table Calculation).

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

Dopo creeremo un campo calcolato Actual usando il campo dati High e il parametro Years. 

Campo calcolato Actual 

LOOKUP ci aiuterà a traslare i valori High di Years*365. Ad esempio, se il parametro Years è 2, allora traslerà i valori di 730.

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

Actual vs. Forecast

Siamo finalmente arrivati alla fine. Per tracciare il grafico a linee di Actual vs. Forecast, seguiremo questi semplici passaggi:

1. Vai alla sezione Parameters in basso a sinistra, fai clic con il tasto destro sul parametro Years e seleziona Show Parameters.
2. Trascina Forecast_date nella mensola Columns. Cambialo in Day.
3. Trascina Measure Names da Dimensions a Filters. Seleziona solo Actual e forecast. 
4. Trascina Measure Names da Dimensions su Color.
5. Infine, trascina Measure Names da Measures nella mensola Rows.

Dopo aver seguito tutti i passaggi, vedrai Actual e forecast in colori diversi. 

Grafico a linee Actual vs. Forecast

Il grafico a linee sopra è lontano dall'essere perfetto e richiede hyperparameter tuning, cross-validation, imputazione di valori e date mancanti e miglioramenti sulla funzione data. 

Conclusione

In questo tutorial abbiamo imparato a costruire e distribuire un modello di machine learning sul server TabPy e ad accedervi tramite script Tableau. Abbiamo anche visto le basi di tabpy_tools e come usarlo per distribuire funzioni o modelli. 

Approfondisci il financial forecasting con il corso di DataCamp. Imparerai a comprendere conto economico, stato patrimoniale e indici di previsione, formattare dati grezzi, gestire date e periodi fiscali, e assunzioni e scostamenti nelle previsioni.

Il forecasting su serie temporali è la base; possiamo migliorare le previsioni addestrando i dati su altri algoritmi di machine learning come:

• Autoregressive Integrated Moving Average (ARIMA)
• Seasonal Autoregressive Integrated Moving Average (SARIMA)
• Exponential Smoothing (ES)
• XGBoost
• LSTM (Deep Learning)
• Temporal Fusion Transformer (Google)

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. 

Questa è la parte finale della serie. Nella prima parte di questo tutorial su TabPy, abbiamo imparato tutto su TabPy ed eseguito uno script Python in Tableau per creare vari cluster degli annunci Airbnb di Amsterdam.