Déployer des fonctions Python et le modèle de prévision Prophet dans Tableau avec TabPy

Outils TabPy

TabPy Tools est un package Python pour déployer et gérer des fonctions Python sur le serveur TabPy. 

Passons en revue en détail les fonctionnalités des outils TabPy.

Connexion à TabPy

La fonction client vous permet de connecter l’API Python au serveur TabPy via l’URL et le PORT. 

rom tabpy.tabpy_tools.client import Client

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

Nous pouvons utiliser l’objet « client » pour configurer l’authentification et gérer les fonctions Python sur le serveur. 

Authentification

Vous pouvez définir votre nom d’utilisateur et votre mot de passe avec la fonction « set_credentials ». Il est nécessaire de définir des identifiants pour déployer un modèle sur le serveur. 

Remarque : exécutez cette fonction uniquement si vous avez activé l’authentification sur le serveur TabPy. Lisez la documentation de configuration du serveur pour en savoir plus.  

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

Déployer une fonction

Créez une fonction puis publiez-la avec la fonction `client.deploy()`. Elle requiert trois arguments : le nom de la fonction, la fonction Python et une description. 

La fonction addition additionne deux champs et renvoie la liste. Ensuite, la fonction « add » sera accessible dans Tableau.

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

Déployer un modèle

Lorsque vous avez entraîné un modèle d’apprentissage automatique et déployé la fonction d’inférence, Tableau enregistre automatiquement le modèle et la définition des fonctions à l’aide de cloudpickle. Ils restent en mémoire côté serveur pour offrir un temps de réponse plus rapide. 

En clair, vous n’avez pas à réentraîner votre modèle à chaque modification dans Tableau. Nous verrons le déploiement des modèles plus en détail dans les sections suivantes. 

Suppression d’endpoints

Pour supprimer une fonction ou un modèle, utilisez la fonction `remove`. Elle ne requiert que le nom de la fonction. 

client.remove('add')

>>> Pour des fonctionnalités plus avancées, consultez le dépôt TabPy/tabpy sur GitHub.

Déployer une fonction Python avec un IDE

Comme dans la première partie, nous allons créer une fonction de coefficient de corrélation de Pearson. Au lieu d’écrire la fonction dans Tableau, nous la déploierons sur le serveur via l’API Python, puis nous y accéderons par un calcul Tableau.

Dans cette section, nous utiliserons le jeu de données Sales Store Product de Kaggle pour calculer la corrélation entre les champs ventes et profit. 

Jeu de données Kaggle Sales Store Product

Avant d’écrire le code Python, assurez-vous de disposer de la dernière version de TabPy.

pip install -U tabpy

Lancez le serveur en local via un terminal.

tabpy

Client TabPy 

Si vous connaissez Python, cette partie sera simple à comprendre. Vous pouvez tout apprendre sur les fonctions Python dans le cours Introduction to Python.

1. Nous allons importer Client depuis tabpy_tools et NumPy pour les calculs. 
2. Connectez-vous au serveur TabPy via l’URL et le PORT.
3. Créez pearson_correlation_coefficient() qui prend x et y et renvoie le coefficient de corrélation sous forme de colonne unique. 
4. Utilisez client.deploy() pour publier la fonction « pcc ». Trois arguments sont requis : nom, fonction et description.  

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

Requête TabPy 

Nous allons maintenant invoquer cette fonction dans Tableau à l’aide de tabpy.query(). Elle requiert le nom de la fonction Python et des espaces réservés pour les arguments tels que _arg1 et _arg2. 

1. Dans SCRIPT_REAL, ajoutez le script de requête et agrégerez les champs. 
2. Le script commence par return et se termine par [‘response’] pour extraire le résultat du JSON.
3. Définissez le calcul par défaut du tableau sur le champ Customer Name.
4. Appliquez puis cliquez sur OK.

Champ calculé du coefficient de corrélation de Pearson

Vous pouvez revoir la première partie du tutoriel pour comprendre le script Tableau. 

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

Visualisation des données 

Nous allons créer une visualisation affichant la corrélation par catégorie de produit et segment de clientèle.

1. Glissez-déposez Customer Name sur Detail et Ship Mode sur Color dans le panneau Marks. 
2. Glissez-déposez Customer Segment et pcc (champ calculé de corrélation) dans l’étagère Columns. 
3. Glissez-déposez Product Category dans l’étagère Rows.

Affichage d’un diagramme en barres du coefficient de corrélation 

Dans la plupart des cas, le secteur Corporate présente une forte corrélation entre ventes et profit. Globalement, vous pouvez utiliser les coefficients de corrélation et prendre des décisions basées sur les données pour augmenter le profit de l’entreprise. 

Lisez notre tutoriel Python details on correlation pour découvrir d’autres coefficients, calculer la corrélation en Python et comprendre le lien entre corrélation et causalité. 

Déployer le modèle Prophet dans Tableau 

Dans cette section, nous allons déployer le modèle de prévision Facebook Prophet et apprendre à modifier les champs de type date. Nous entraînerons le modèle de séries temporelles sur les Apple Stock Prices de 2015 à 2020. 

Jeu de données Kaggle Apple Stock Prices (2015-2020)

Avant d’écrire les scripts et de créer la visualisation de prévision dans Tableau, nous devons tester le code Python et évaluer le modèle de prévision dans un Jupyter Notebook. 

Facebook Prophet 

Facebook Prophet est une bibliothèque open source pour la prévision automatique de séries temporelles univariées. Elle fonctionne particulièrement bien avec des effets de saisonnalité annuels, hebdomadaires et quotidiens. 

Pourquoi Prophet ? 

Il gère bien les données manquantes, les changements de tendance et les valeurs aberrantes.  

Installer Prophet

Vous pouvez installer le package Python Prophet avec la commande ci-dessous dans le terminal. 

pip install pystan==2.19.1.1
pip install prophet

Ou, si vous utilisez l’environnement Python Anaconda, utilisez la commande suivante. 

conda install -c conda-forge prophet

Initialisation du projet 

1. Nous allons commencer par importer pandas pour l’ingestion et la manipulation des données, et Prophet pour l’entraînement et l’évaluation du modèle de prévision. 
2. Lisez le fichier du jeu de données Apple (AAPL.csv) avec la fonction pandas read_csv.
3. Définissez X avec les colonnes date et high.   
4. Affichez la taille du dataframe et visualisez la courbe de la série temporelle de la colonne 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();

Sortie

(1258, 2)

L’action Apple augmente avec le temps. Elle a connu deux creux, mais est revenue sur une trajectoire de croissance régulière. 

Suivez le tutoriel Python time series analysis de Hugo Bowne-Anderson pour aller plus loin. Vous pouvez aussi suivre le cours de DataCamp sur l’analyse de séries temporelles en Python pour pratiquer.  

Construire le modèle d’apprentissage

Nous allons préparer les données pour Prophet et l’entraîner avec les hyperparamètres par défaut. 

1. Renommez les colonnes en ds et y
2. Convertissez la colonne ds au format datetime (date)
3. Définissez un model avec Prophet()
4. Entraînez le modèle avec 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)

Évaluation du modèle

Pour évaluer, nous devons ajouter des dates futures au jeu de données. Nous pouvons le faire avec make_future_dataframe. 

Nous allons définir :

• periods à 365 jours
• freq à « D ». Vous pouvez aussi passer à « Y », mais il faudra alors mettre periods à 1.
• include_history à false pour omettre l’historique.

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

Sortie

Comme on le voit, le jeu de données future se termine en 2021. 

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

L’étape suivante consiste à utiliser ces dates pour prédire les valeurs high de l’action Apple. Ensuite, nous afficherons « ds », « yhat », « yhat_lower » et « yhat_upper ». 

Les bornes yhat_lower et yhat_upper définissent l’intervalle d’incertitude acceptable. En clair, le cours peut monter jusqu’à 485,3 et descendre à 365,4. Cette information aide les traders intraday à évaluer le risque. 

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

Sortie

    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

Visualisons la prévision avec la fonction plot(). Elle prend les valeurs prédictives pour afficher un graphique points-lignes avec l’intervalle en bleu. 

model.plot(forecast)

La visualisation ci-dessous indique que l’action Apple devrait croître sans creux marqués. 

Vous pouvez améliorer la prévision en ajustant les hyperparamètres liés aux prévisions saturantes, points de changement de tendance, saisonnalités, effets de jours fériés et régressseurs, saisonnalité multiplicative, intervalles d’incertitude, et valeurs aberrantes. Vous pouvez aussi les ajuster automatiquement via du réglage d’hyperparamètres. Pour en savoir plus sur Facebook Prophet, consultez la documentation.  

La prévision de séries temporelles est un vaste sujet. Pour tout apprendre, suivez notre tutoriel time series forecasting par Moez Ali. Il couvre l’analyse de séries temporelles, les modèles statistiques, les frameworks Python et l’AutoML. 

Vous pouvez aussi suivre notre cours visualizing time series data in Python, et apprendre à créer des courbes, détecter saisonnalité, tendance et bruit, et afficher plusieurs séries.  

Déployer l’inférence du modèle 

Dans cette section, nous allons déployer l’inférence du modèle. Cela nous permettra de stocker le modèle et la définition de la fonction sur le serveur TabPy pour des réponses plus rapides. 

Nous allons d’abord connecter le Client via l’URL et le PORT. Puis nous définirons la fonction prophet_forecasting. 

1. Elle prendra en entrée un nombre d’années à prévoir et l’utilisera pour créer un dataframe de future dates. 
2. Elle fera des prédictions avec model.predict et le dataframe future. 
3. Elle renommera « yhat » en « y » afin de concaténer la prévision avec l’historique. 
4. La dernière partie est subtile. Dans Tableau, nous ne pouvons pas ajouter de valeur au champ data. Nous décalerons donc les valeurs Date de 365*n, où n est le nombre d’années.

Enfin, nous empaquetons et déployons sur le serveur TabPy avec client.deploy(). Nous définirons le nom de fonction « prophet ». L’argument override nous aidera à créer des versions du modèle et de la fonction, utile au début lors du débogage. 

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)

Configuration de Tableau

Pour piloter le nombre d’années dans Tableau, nous devons créer un paramètre Years. Il sera utilisé dans la fonction prophet. 

Créez un paramètre Years en effectuant un clic droit dans la section Data puis Create Parameter. Changez le Data type en Integer, la Current value à 1, et cliquez sur Range pour définir Minimum 1 et Maximum 5.

Création du paramètre Years 

Ensuite, nous créerons un champ calculé Forecast_date. Nous utiliserons le champ Date et décalerons les valeurs selon le nombre d’Years. 

Champ calculé Forecast_date 

La fonction DATEADD ajoutera les Years au champ Date puis tronquera au jour. 

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

Ensuite, nous créerons un champ calculé forecast et accéderons au modèle déployé via tabpy.query(). La fonction de requête a deux parties : le nom de la fonction Python, puis la liste des espaces réservés d’arguments. 

Champ calculé forecast 

Dans notre cas, il n’y a qu’un argument, nous ajouterons donc _arg1. Nous encapsulerons la requête dans la fonction Tableau SCRIPT_REAL et fournirons le paramètre Years en entrée. Avant de cliquer sur OK, assurez-vous que les résultats sont calculés le long de Forecast_date. Vous pouvez le modifier en cliquant sur le texte bleu (Default Table Calculation).

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

Après cela, nous créerons un champ calculé Actual à partir du champ High et du paramètre Years. 

Champ calculé Actual 

LOOKUP nous permet de décaler les valeurs High de Years*365. Par exemple, si le paramètre Years vaut 2, le décalage sera de 730.

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

Réel vs prévision

Nous y sommes presque. Pour tracer la courbe Actual vs. Forecast, suivez ces étapes simples :

1. Dans la section Parameters en bas à gauche, faites un clic droit sur le paramètre Years et sélectionnez Show Parameters.
2. Glissez-déposez Forecast_date dans l’étagère Columns. Passez-la en Day.
3. Glissez-déposez Measure Names depuis Dimensions vers Filters. Sélectionnez uniquement Actual et forecast. 
4. Glissez-déposez Measure Names depuis Dimensions vers Color.
5. Enfin, glissez-déposez Measure Names depuis Measures vers l’étagère Rows.

Après ces étapes, vous verrez Actual et forecast dans des couleurs différentes. 

Courbe Actual vs Forecast

Le graphique ci-dessus est perfectible : il nécessitera un réglage des hyperparamètres, de la validation croisée, l’imputation des valeurs et dates manquantes, ainsi qu’une amélioration des fonctions de date. 

Conclusion

Dans ce tutoriel, nous avons appris à construire et déployer un modèle d’apprentissage automatique sur un serveur TabPy et à y accéder depuis un script Tableau. Nous avons aussi vu les bases de tabpy_tools et comment l’utiliser pour déployer des fonctions ou des modèles. 

Approfondissez la prévision financière avec le cours DataCamp. Vous apprendrez à comprendre le compte de résultat, le bilan et les ratios de prévision, le formatage des données brutes, la gestion des dates et périodes financières, ainsi que les hypothèses et les variances dans les prévisions.

La prévision de séries temporelles constitue une base ; on peut améliorer les prédictions en entraînant les données sur d’autres algorithmes, tels que :

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

Si vous débutez avec Tableau et souhaitez tout apprendre sur la visualisation de données et les calculs statistiques, suivez le parcours de compétences Tableau fundamentals. 

Ceci est la dernière partie de la série. Dans la première partie de ce tutoriel TabPy, nous avons présenté TabPy et exécuté un script Python dans Tableau pour créer différents clusters d’annonces Airbnb à Amsterdam.