Clústeres K-means en Tableau con TabPy: tutorial

¿Qué es TabPy?

TabPy es un framework que permite a Tableau ejecutar código Python. Te permite correr scripts de Python dentro de los campos calculados de Tableau o desplegar funciones en el servidor de TabPy usando la API de Python.  

TabPy es una herramienta potente que incluye varias configuraciones y utilidades. Puedes integrarlo con tus visualizaciones de Tableau y, siempre que cambies los parámetros, el script de Python se ejecutará automáticamente para ofrecerte una experiencia de visualización dinámica. 

¿Por qué TabPy?

Aunque Tableau ofrece mucha funcionalidad para crear, manipular y limpiar campos de datos, sus funciones estadísticas nativas son básicas. Para acceder a estadísticas avanzadas como el machine learning, integraremos potentes librerías de Python con Tableau. 

Aprende varias técnicas estadísticas en Tableau con un curso interactivo de DataCamp.

En este tutorial, veremos cómo configurar un servidor TabPy y trabajaremos en un proyecto sencillo de machine learning. Usaremos el algoritmo K-means para dividir anuncios de AirBnB en Ámsterdam en varios clústeres. 

Configuración de TabPy

Poner en marcha un servidor TabPy es sencillo. Puedes instalar TabPy con `pip` en la terminal o con `!pip` en Jupyter Notebook. Se instalarán automáticamente el servidor y la API cliente para Python.

pip install tabpy

Para ejecutar el servidor, escribe `tabpy` en la terminal. En unos segundos verás que el servidor está funcionando en local en el puerto 9004. 

tabpy

Salida

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

Configuración del servidor TabPy

Puedes configurar tu servidor TabPy usando un archivo de configuración y el siguiente comando. 

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

Puedes configurar:

• Conexión HTTP o HTTPS
• Gestión de usuarios 
• Registro de logs

TabPy te da libertad para personalizar el servidor según las políticas de seguridad y calidad de tu empresa. Consulta el archivo de configuración de ejemplo y aprende a montar un servidor con requisitos específicos. 

Desplegar TabPy en Heroku

Si usas Tableau Cloud o Tableau Server, necesitarás desplegar un servidor TabPy en una plataforma cloud o de hosting web. Puedes hacerlo con un archivo Docker o desplegando el servidor directamente en Heroku. 

Para ejecutar el servidor remoto en Heroku:

• Inicia sesión en tu cuenta de Heroku desde el navegador; si no tienes cuenta, regístrate gratis.
• Ve al repositorio de TabPy en GitHub y haz clic en el botón "Deploy to Heroku" del Readme.

• Sigue las instrucciones. Escribe el nombre del servidor y selecciona la región.
• Configura las variables de entorno de usuario y contraseña.

Tu servidor quedará desplegado sin complicaciones. Podrás conectar Tableau con la URL y el puerto. 

Conectar con TabPy

Asegúrate de que tu servidor TabPy esté en ejecución, en local o en remoto, antes de conectarlo con Tableau.  

Para conectar el servidor, haz clic en el menú Help y selecciona Settings and Performance > Manage Analytics Extension Connection. Se abrirá una ventana con varios tipos de conexión: TabPy, Einstein Discovery, RServe y Analytics Extension API. 

Selecciona la opción TabPy. Aparecerá otra ventana para añadir Hostname, Port, Username y Password. Ignoraremos usuario y contraseña porque no los hemos configurado.

En el siguiente paso, añade Hostname como "localhost" y Port como "9004" y pulsa Test Connection. Tras pasar la prueba, guarda la configuración de la conexión. 

Usar Python con los cálculos de Tableau

Para ejecutar un script de Python en un campo calculado, utiliza una de estas funciones según el tipo de salida:

• SCRIPT_BOOL
• SCRIPT_INT
• SCRIPT_REAL
• SCRIPT_STR

Si tu función devuelve valores booleanos, usa SCRIPT_BOOL. Siempre puedes obtener enteros y luego convertirlos a otros tipos con las funciones nativas. 

En esta sección, usaremos un conjunto de datos de ventas de tienda de Kaggle. Calcularemos el coeficiente de correlación de Pearson entre los campos Sales y Profit. 

SCRIPT_REAL requiere dos partes. La primera es el script de Python entre comillas dobles y la segunda son los argumentos agregados. 

Usaremos el paquete de Python Numpy para calcular la correlación entre los argumentos Sales y Profit. No podemos pasar los argumentos directamente; en su lugar, usamos marcadores como "_arg1" y "_arg2". Por ejemplo, SUM([Profit]) es el segundo en el orden y se vincula con "_arg2".

Simplemente extraemos el coeficiente de correlación de la matriz np.corrcoef para devolver una única columna. 

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

Después de añadir el script en el campo calculado "Correlation", haz clic en aplicar. Se ejecutará el script y devolverá valores correspondientes al Customer Name. 

Antes de pulsar OK, haz clic en el texto "Default Table Calculation" y cambia la opción de Automatic a Customer Name. 

Para visualizar un diagrama de dispersión por categoría de producto y segmentación de clientes: 

1. Arrastra y suelta la Category de producto y Sales en la estantería de Columns.
2. Luego, arrastra y suelta Customer Segment y Profit en la estantería de Rows. 
3. Arrastra y suelta Customer Name en el botón Detail de la sección Marks. 
4. Por último, arrastra y suelta el campo calculado Correlation en el botón Label de la sección Marks. 

El gráfico muestra el coeficiente de correlación de los clientes según la categoría de producto y el segmento de cliente. Hay una alta correlación entre la categoría Furniture y los clientes Small Business.     

Script de clustering en Tableau con Python

En esta sección, usaremos el conjunto de datos de Airbnb Ámsterdam para crear clústeres con el algoritmo K-means y el framework de machine learning scikit-learn. 

Antes de meternos con el script en TabPy, necesitamos analizar y entender el conjunto de datos en Jupyter Notebook. 

Inicialización del proyecto 

Usaremos pandas para la ingesta y limpieza de datos, matplotlib y seaborn para visualización, y scikit-learn para el procesado y los algoritmos de clustering.

Primero importaremos los paquetes necesarios de Python e ingeriremos el archivo "listing.csv". Luego exploraremos los valores ausentes con .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()

Como podemos ver, hay varios valores ausentes en neighbourhood_group, last_review y reviews_per_month. En lugar de imputar o eliminar estas columnas, no las incluiremos en el entrenamiento del modelo. 

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

Procesamiento de los datos

Crearemos un dataframe X con las características esenciales para el entrenamiento. Estas variables no tienen valores ausentes, no son identificadores únicos y no están altamente correlacionadas. Por ejemplo, no incluiremos id, name, host_id, host_name, latitude ni longitude.

Tenemos columnas categóricas y, para convertirlas a numéricas, usaremos LabelEncoder(). Para aplicarlo a varias columnas categóricas, aprovecharemos .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()

Como ves, el dataframe final tiene siete columnas con valores numéricos. 

Buscar el codo para K-means

El método del codo se usa para determinar el número óptimo de clústeres en un conjunto de datos. Usaremos n_clusters e .inertia_ para mostrar gráficos de líneas con la forma de un "codo". La inercia es la suma de las distancias cuadráticas de las muestras a su centro de clúster más cercano. 

El siguiente código ejecuta de 1 a 9 clústeres y añade los valores de inercia al array clusters. Luego usaremos esa información para dibujar un gráfico de líneas de clústeres frente a inercia. 

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

El gráfico muestra un primer codo en 3 y un segundo en 4. Incluiremos ambos valores en el análisis visual en Tableau. 

Puedes aprender más sobre clustering K-means en Python con scikit-learn en nuestro tutorial.  

Crear el parámetro N-Cluster

Para no tener que escribir manualmente el número de clústeres en el código, crearemos un parámetro con un rango de 1 a 10. 

Puedes crear parámetros haciendo clic derecho en la sección Data y eligiendo Create Parameter. Cambia el Data type a Integer, el Current value a 1 y, en Range, establece Minimum en 1 y Maximum en 10. 

Script de Python en un campo calculado

Ahora trasladaremos el código del Jupyter Notebook a un campo calculado de Tableau. El campo calculado de Tableau no requiere cargar un conjunto de datos: ya tenemos los campos necesarios y los usaremos mediante argumentos de SCRIPT_INT. 

1. Convertiremos los argumentos uno y dos a tipo numérico con LabelEncoder.
2. Recogeremos todos los argumentos y les daremos nombres de variable adecuados. 
3. Apilaremos en columnas todas las variables de entrada excepto N. 
4. Definiremos un modelo con "N" clústeres. Podremos cambiar esta variable con el parámetro N Clusters.
5. Entrenaremos y predeciremos los clústeres con esas características.  
6. Devolveremos la salida como una lista de enteros. 

La segunda parte del script son los campos de datos agregados y el parámetro. 

Revisa el código para entender la relación entre argumentos y campos de datos. 

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

Crea un nuevo campo calculado (Kmean) y pega el código anterior. Asegúrate de que los resultados se calculen por Host Id. Puedes modificarlo haciendo clic en el texto azul Default Table Calculation.  

Visualización de datos

Para crear la visualización inferior, sigue estos pasos:

1. Arrastra el campo Price a Columns y Number of Reviews a Rows. 
2. Ve al menú Analysis y desmarca Aggregate Measures. 
3. Arrastra Host Id a Detail en la sección Marks y el campo calculado Kmean a Color. 
4. Cambia el campo calculado Kmean a Discrete con clic derecho.  
5. Haz clic derecho en N Clusters en la sección Parameters y selecciona Show Parameters para mostrar el control deslizante a la derecha. 
6. Ajusta el deslizador de N Clusters a 3 o 4 para ver los resultados en tiempo real.   

En la siguiente parte, crearemos varias hojas de visualización cambiando los campos de datos y el número de clústeres.  

1. Precio vs. disponibilidad: se aprecian cuatro clústeres. Con esta información, podemos crear un sistema de recomendaciones para Airbnb o cualquier negocio hotelero. 
2. Reseñas vs. disponibilidad: se ven solo dos clústeres grandes aunque N Clusters sea 3.  
3. Listings vs. precio: se ven clústeres rojo, azul y verde. El amarillo de la esquina está rodeado de verdes y azules. 

Aprende más sobre analítica avanzada y visualización con nuestro curso Analyzing Data in Tableau. Te ayudará a entender la preparación y exploración de datos, análisis geográfico, grupos, conjuntos y parámetros.   

Si te ha gustado el ejercicio de clustering, prueba a llevar los puntos del gráfico a un mapa. Solo tienes que arrastrar y soltar Latitude y Longitude en las estanterías de Columns y Rows. 

También puedes crear clústeres sin TabPy siguiendo nuestro tutorial Cluster Analysis in the Tableau. 

Conclusión

Al integrar TabPy, abrirás la puerta a infinitas posibilidades para automatizar y mejorar tu configuración de analítica de datos. También puedes integrarlo para llevar modelos de deep learning a un panel de analítica, realizar tareas estadísticas complejas e implementar integración y despliegue continuos. 

La integración con TabPy tiene algunas limitaciones, como la salida única. Estas restricciones afectarán sobre todo a quienes trabajen como data scientists o ingenieros de machine learning. 

En este artículo hemos visto qué es TabPy (servidor de Python para Tableau) y cómo usarlo para crear clústeres K-means. Agrupar es clave en comercio electrónico, viajes y entretenimiento para entender el comportamiento del cliente. Hemos usado K-means, pero puedes probar otros algoritmos para obtener mejores resultados. 

Algunos de los principales algoritmos de clustering:

• Affinity Propagation
• Clustering jerárquico aglomerativo
• BIRCH (Balanced Iterative Reducing and Clustering using Hierarchies)
• DBSCAN (Density-Based Spatial Clustering of Applications with Noise)
• Modelos de mezcla gaussiana (GMM)
• Mean Shift clustering

Si estás empezando con Tableau y quieres aprender sobre visualización y cálculo estadístico, realiza el itinerario de habilidades Tableau Fundamentals. 

En la segunda parte de esta serie de tutoriales, exploramos scripts de Python más complejos con TabPy. Veremos cómo desplegar el modelo de predicción Facebook Prophet en el servidor TabPy y crear visualizaciones de series temporales dinámicas.