Tutoriel K-means dans Tableau avec TabPy

Qu’est-ce que TabPy

TabPy est un framework qui permet à Tableau d’exécuter du code Python. Il autorise l’exécution de scripts Python au sein d’un champ calculé de Tableau, ou le déploiement de fonctions sur le serveur TabPy via l’API Python.  

TabPy est un outil puissant, livré avec de nombreuses configurations et utilitaires. Vous pouvez l’intégrer à vos visualisations Tableau et, dès que des paramètres changent, le script Python s’exécute automatiquement pour vous offrir une expérience de visualisation dynamique. 

Pourquoi TabPy ?

Même si Tableau propose de riches fonctionnalités pour créer, manipuler et nettoyer des champs, ses fonctions statistiques natives restent limitées. Pour accéder à des statistiques avancées comme l’apprentissage automatique, nous allons intégrer de puissantes bibliothèques Python à Tableau. 

Apprenez diverses techniques statistiques dans Tableau avec un cours interactif DataCamp.

Dans ce tutoriel, nous allons configurer un serveur TabPy et mener un mini-projet de machine learning. Nous utiliserons l’algorithme K-means pour regrouper des annonces AirBnB d’Amsterdam en plusieurs clusters. 

Configuration de TabPy

Mettre en place un serveur TabPy est simple. Vous pouvez installer TabPy avec `pip` dans le terminal ou `!pip` dans Jupyter Notebook. L’installation ajoute automatiquement le serveur et l’API client pour Python.

pip install tabpy

Pour lancer le serveur, tapez `tabpy` dans le terminal. Au bout de quelques secondes, le serveur tourne en local sur le port 9004. 

tabpy

Sortie

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

Configuration du serveur TabPy

Vous pouvez configurer votre serveur TabPy à l’aide d’un fichier de configuration et de la commande ci-dessous. 

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

Vous pouvez configurer :

• connexion HTTP vs HTTPS
• gestion des utilisateurs 
• journalisation (logging)

TabPy vous laisse personnaliser le serveur selon les politiques de sécurité et d’assurance qualité de votre entreprise. Consultez le fichier de configuration d’exemple pour apprendre à configurer un serveur selon des exigences particulières. 

Déployer TabPy sur Heroku

Si vous utilisez Tableau Cloud ou Tableau Server, vous devrez déployer un serveur TabPy sur une plateforme cloud ou d’hébergement web. Vous pouvez le faire avec un fichier Docker ou en déployant directement le serveur sur Heroku. 

Pour exécuter le serveur distant sur Heroku :

• Connectez-vous à votre compte Heroku depuis un navigateur. Si vous n’avez pas de compte, inscrivez-vous gratuitement.
• Allez sur le référentiel TabPy sur GitHub et cliquez sur le bouton « Deploy to Heroku » dans le Readme.

• Suivez les instructions. Donnez un nom au serveur et sélectionnez sa localisation.
• Définissez les variables d’environnement pour le nom d’utilisateur et le mot de passe.

Votre serveur est déployé sans friction. Vous pouvez relier Tableau via l’URL et le numéro de port. 

Connexion à TabPy

Assurez-vous que votre serveur TabPy fonctionne en local ou à distance avant de le connecter à Tableau.  

Pour se connecter, cliquez sur le menu Aide puis sélectionnez Paramètres et performances > Gérer la connexion à l’extension Analytics. Une nouvelle fenêtre s’ouvre avec plusieurs types de connexion : TabPy, Einstein Discovery, RServe et Analytics Extension API. 

Sélectionnez l’option TabPy, ce qui ouvre une autre fenêtre pour saisir le nom d’hôte, le port, le nom d’utilisateur et le mot de passe. Nous ignorerons le nom d’utilisateur et le mot de passe, non configurés ici.

À l’étape suivante, indiquez Hostname « localhost » et Port « 9004 », puis cliquez sur Tester la connexion. Après un test concluant, enregistrez la configuration. 

Utiliser Python dans les calculs Tableau

Pour exécuter un script Python dans un champ calculé, utilisez l’une de ces fonctions selon le type de sortie :

• SCRIPT_BOOL
• SCRIPT_INT
• SCRIPT_REAL
• SCRIPT_STR

Si votre fonction renvoie des valeurs booléennes, utilisez SCRIPT_BOOL. Vous pouvez aussi renvoyer des entiers puis les convertir avec des fonctions natives. 

Dans cette section, nous utiliserons un jeu de données store sales de Kaggle. Les champs Sales et Profit servent à calculer le coefficient de corrélation de Pearson. 

SCRIPT_REAL comporte deux parties : le script Python entre guillemets doubles et les arguments agrégés. 

Nous utiliserons le paquet Python NumPy pour calculer la corrélation entre les arguments Sales et Profit. On ne peut pas passer directement les arguments ; il faut utiliser des espaces réservés « _arg1 » et « _arg2 ». Par exemple, SUM([Profit]) est le second argument et correspond à « _arg2 ».

Nous extrayons simplement le coefficient de corrélation de la matrice np.corrcoef pour renvoyer une seule colonne. 

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

Après avoir ajouté le script dans le champ calculé « Correlation », cliquez sur Appliquer. Le script s’exécute et renvoie des valeurs par Customer Name. 

Avant de cliquer sur OK, cliquez sur le texte « Default Table Calculation » et remplacez Automatic par Customer Name. 

Pour visualiser un nuage de points par catégorie de produit et segment client : 

1. Glissez-déposez les champs Category et Sales dans l’étagère Colonnes.
2. Puis, glissez-déposez Customer Segment et Profit dans l’étagère Lignes. 
3. Glissez-déposez Customer Name sur le bouton Détail dans la section Repères (Marks). 
4. Enfin, glissez-déposez le champ calculé Correlation sur le bouton Étiquette dans la section Repères. 

Le graphique ci-dessus affiche le coefficient de corrélation des clients selon la catégorie de produit et le segment. La corrélation est élevée entre la catégorie Furniture et les clients Small Business.   

Script Python de clustering dans Tableau

Dans cette section, nous utiliserons le jeu de données Airbnb Amsterdam pour créer des clusters avec l’algorithme K-means et le framework de machine learning scikit-learn. 

Avant de passer au script TabPy, analysons et comprenons le jeu de données dans Jupyter Notebook. 

Initialisation du projet 

Nous utiliserons pandas pour l’ingestion et le nettoyage des données, matplotlib et seaborn pour la visualisation, et scikit-learn pour le traitement et les algorithmes de clustering.

Nous allons d’abord importer les packages Python requis et charger le fichier « listing.csv ». Puis nous explorerons les valeurs manquantes avec .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()

On observe plusieurs valeurs manquantes dans neighbourhood_group, last_review et reviews_per_month. Plutôt que d’imputer ou supprimer ces colonnes, nous ne les inclurons pas dans l’entraînement du modèle. 

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

Préparation des données

Nous allons créer une table X contenant les variables essentielles pour l’entraînement. Ces variables n’ont pas de valeurs manquantes, pas d’identifiants uniques, et pas de forte colinéarité. Par exemple, nous excluons id, name, host_id, host_name, latitude et longitude.

Nous avons des colonnes catégorielles : pour les convertir en numériques, nous utiliserons LabelEncoder(). Pour l’appliquer à plusieurs colonnes, nous emploierons la méthode .apply() de Pandas.  

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

Comme on le voit, la table finale comporte sept colonnes numériques. 

Chercher le coude (elbow) pour K-means

La méthode du coude permet de déterminer le nombre optimal de clusters pour un jeu de données. Nous utiliserons n_clusters et .inertia_ pour tracer des courbes présentant une forme de « coude ». Inertia est la somme des distances au carré des échantillons vers leur centre de cluster le plus proche. 

Le code ci-dessous exécute K-means de 1 à 9 clusters et ajoute l’inertie au tableau clusters. Nous traçons ensuite la courbe clusters vs inertie. 

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

Le graphique montre un premier coude à 3 et un second à 4. Nous inclurons ces deux valeurs dans l’analyse visuelle dans Tableau. 

Pour en savoir plus sur le clustering K-means en Python avec scikit-learn, consultez notre tutoriel.  

Créer le paramètre N-clusters

Pour éviter de saisir manuellement le nombre de clusters dans le code, créons un paramètre allant de 1 à 10. 

Créez un paramètre en effectuant un clic droit dans la section Données, puis Créer un paramètre. Changez le Type de données en Entier, la Valeur actuelle à 1, puis cliquez sur Plage et fixez Minimum à 1 et Maximum à 10. 

Script Python dans un champ calculé

Nous allons maintenant transférer le code du Jupyter Notebook vers un champ calculé Tableau. Le champ calculé n’a pas besoin de charger un jeu de données : nous utilisons les champs déjà présents via les arguments SCRIPT_INT. 

1. Convertir les deux premiers arguments en numériques avec LabelEncoder.
2. Récupérer tous les arguments et leur donner des noms de variables pertinents. 
3. Empiler tous les arguments d’entrée, sauf N, en colonnes. 
4. Définir un modèle avec « N » clusters. Nous pourrons modifier cette valeur via le paramètre N Clusters.
5. Entraîner et prédire les clusters à partir des variables explicatives.  
6. Renvoyer la sortie comme une liste d’entiers. 

La seconde partie du script regroupe les champs de données et un paramètre. 

Référez-vous au code ci-dessous pour voir le lien entre arguments et champs. 

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

Créez un nouveau champ calculé (Kmean) et copiez-collez le code ci-dessus. Assurez-vous que les résultats sont calculés selon Host Id. Vous pouvez le régler via le lien Default Table Calculation en bleu.  

Visualisation des données

Pour créer la visualisation ci-dessous, suivez ces étapes :

1. Glissez-déposez le champ Price dans l’étagère Colonnes et Number of Reviews dans l’étagère Lignes. 
2. Dans le menu Analyse, décochez Mesures agrégées. 
3. Glissez-déposez Host Id sur Détail dans Repères, et le champ calculé Kmean sur Couleur. 
4. Passez le champ calculé Kmean en Discret via un clic droit.  
5. Cliquez droit sur N Clusters dans la section Paramètres et sélectionnez Afficher le paramètre pour afficher le curseur à droite. 
6. Réglez le curseur N Clusters sur 3 ou 4 pour voir le résultat en temps réel.   

Ensuite, créez plusieurs feuilles de visualisation en changeant les champs et le nombre de clusters.  

1. Price vs Availability : quatre clusters apparaissent. Cette information peut nourrir un système de recommandations pour Airbnb ou l’hôtellerie. 
2. Reviews vs Availability : on n’observe que deux grands clusters même si N Clusters vaut 3.  
3. Listings vs Price : on distingue des clusters rouge, bleu et vert. Le jaune dans le coin est entouré de vert et de bleu. 

Approfondissez l’analytics avancé et la visualisation avec notre cours Analyzing Data in Tableau. Vous y verrez la préparation des données, l’exploration, l’analyse cartographique, les groupes, ensembles et paramètres.   

Si vous avez apprécié ce tutoriel sur le clustering, projetez les points sur une carte : glissez-déposez simplement Latitude et Longitude dans les étagères Colonnes et Lignes. 

Vous pouvez aussi créer des clusters sans TabPy en suivant notre tutoriel Cluster Analysis in the Tableau. 

Conclusion

En intégrant TabPy, vous ouvrez la porte à d’infinies possibilités pour automatiser et améliorer votre dispositif d’analyse de données. Vous pouvez aussi intégrer des modèles de deep learning à un tableau de bord analytique, réaliser des analyses statistiques complexes et mettre en place une intégration et un déploiement continus. 

L’intégration TabPy comporte toutefois des limites, comme la sortie unique. Elles concernent surtout les Data Scientists et Machine Learning Engineers. 

Dans cet article, nous avons découvert TabPy (serveur Python pour Tableau) et comment l’utiliser pour créer des clusters K-means. Le clustering est clé dans l’e-commerce, le voyage et le divertissement pour comprendre le comportement des clients. Nous avons utilisé K-means, mais d’autres algorithmes peuvent donner de meilleurs résultats selon le cas. 

Voici quelques algorithmes de clustering de référence :

• Affinity Propagation
• Clustering hiérarchique agglomératif
• BIRCH (Balanced Iterative Reducing and Clustering using Hierarchies)
• DBSCAN (Density-Based Spatial Clustering of Applications with Noise)
• Gaussian Mixture Models (GMM)
• Mean Shift clustering

Si vous débutez avec Tableau et souhaitez maîtriser la visualisation et le calcul statistique, suivez le parcours de compétences Tableau Fundamentals. 

Dans la deuxième partie de cette série, nous explorons des scripts Python plus avancés avec TabPy. Nous verrons comment déployer le modèle de prévision Facebook Prophet sur le serveur TabPy et créer des visualisations temporelles dynamiques.