En este artículo, vamos a hablar de Plotly, una biblioteca de Python para hacer visualizaciones interactivas.
La visualización de datos es una de las tareas más importantes para los profesionales de los datos. Nos ayuda, de hecho, a comprender los datos y a plantearnos más preguntas para investigaciones posteriores. Pero la visualización de datos no es sólo una tarea que tengamos que concluir en la fase de Análisis Exploratorio de Datos. También podemos necesitar presentar los datos, a menudo a un público para ayudarle a sacar algunas conclusiones.
En Python, generalmente utilizamos matplotlib y seaborn como bibliotecas para trazar nuestros gráficos. Sin embargo, a veces podemos necesitar algunas visualizaciones interactivas. En algunos casos, para una mejor comprensión de los datos. En otros casos, simplemente para presentar mejor nuestras soluciones.
Tabla de contenidos
¿Qué es Plotly?
Como podemos leer en su página web:
La librería de gráficos Python de Plotly crea gráficos interactivos de calidad editorial. Ejemplos de cómo hacer gráficos de líneas, gráficos de dispersión, gráficos de área, gráficos de barras, barras de error, gráficos de caja, histogramas, mapas de calor, subparcelas, múltiples ejes, gráficos polares y gráficos de burbujas.
Plotly.py es libre y de código abierto y se puede ver la fuente, informar de problemas o contribuir en GitHub. Así pues, Plotly es una biblioteca Python gratuita y de código abierto para realizar visualizaciones interactivas.
Como podemos ver en su página web, nos da la posibilidad de crear gráficos para diferentes ámbitos: AI/ML, estadístico, científico, financiero, y mucho más.
Ya que estamos interesados en Machine Learning y Data Science, vamos a mostrar algunos plots relacionados con este campo y cómo crearlos en Python.
Por último, para instalarlo, tenemos que teclear:
$ pip install plotly
1. Gráficos de burbujas interactivos
Una característica interesante y útil de Plotly que podemos utilizar es la posibilidad de gráficos de burbujas interactivos.
En el caso de los gráficos de burbujas, de hecho, a veces las burbujas pueden intersecarse, dificultando la lectura de los datos. En cambio, si el gráfico es interactivo, podemos leer los datos más fácilmente.
Veamos un ejemplo:
import plotly.express as px
import pandas as pd
import numpy as np
# Generate random data
np.random.seed(42)
n = 50
x = np.random.rand(n)
y = np.random.rand(n)
z = np.random.rand(n) * 100 # Third variable for bubble size
# Create a DataFrame
data = pd.DataFrame({‘X’: x, ‘Y’: y, ‘Z’: z})
# Create the scatter plot with bubble size with Plotly
fig = px.scatter(data, x=‘X’, y=‘Y’, size=‘Z’,
title=‘Interactive Scatter Plot with Bubble Plot’)
# Add labels to the bubbles
fig.update_traces(textposition=‘top center’, textfont=dict(size=11))
# Update layout properties
fig.update_layout(
xaxis_title=‘X-axis’,
yaxis_title=‘Y-axis’,
showlegend=False
)
# Display the interactive plot
fig.show()
Y conseguimos:
Así, hemos creado algunos datos con NumPy y los hemos almacenado en un marco de datos de Pandas. A continuación, hemos creado el gráfico interactivo con el método px.scatter() recuperando los datos del marco de datos, y especificando el título (a diferencia de Matplotlib en el que insertamos el título fuera del método utilizado para crear el propio gráfico).
2. Matrices de correlación interactivas
Una de las tareas con las que a veces lucho es la visualización adecuada de las matrices de correlación. Estas, de hecho, a veces pueden ser difíciles de leer y visualizar cuando tenemos muchos datos.
Una forma de resolver el problema es utilizar Plotly para crear una visualización interactiva.
Para el ámbito de aplicación, vamos a crear un marco de datos Pandas con 10 columnas y crear una matriz de correlación interactiva con Plotly:
import pandas as pd
import numpy as np
import plotly.figure_factory as ff
# Create random data
np.random.seed(42)
data = np.random.rand(100, 10)
# Create DataFrame
columns = [‘Column’ + str(i+1) for i in range(10)]
df = pd.DataFrame(data, columns=columns)
# Round values to 2 decimals
correlation_matrix = df.corr().round(2)
# Create interactive correlation matrix with Plotly
figure = ff.create_annotated_heatmap(
z=correlation_matrix.values,
x=list(correlation_matrix.columns),
y=list(correlation_matrix.index),
colorscale=‘Viridis’,
showscale=True
)
# Set axis labels
figure.update_layout(
title=‘Correlation Matrix’,
xaxis=dict(title=‘Columns’),
yaxis=dict(title=‘Columns’)
)
# Display the interactive correlation matrix
figure.show()
Y conseguimos:
Así, de forma muy sencilla, podemos crear una matriz de correlaciones interactiva con el método ff.create_annotated_map().
3. Gráficos interactivos de ML
En Machine Learning, a veces necesitamos comparar cantidades gráficamente. Y, en estos casos, a veces es difícil leer nuestros gráficos.
El caso típico es una curva ROC/AUC donde comparamos el rendimiento de diferentes modelos ML. A veces, de hecho, las curvas se interceptan y no somos capaces de visualizarlas correctamente.
Para mejorar nuestras visualizaciones, podemos utilizar Plotly para crear una curva ROC/AUC como esta:
import pandas as pd
import numpy as np
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.metrics import roc_curve, auc
import plotly.graph_objects as go
# Create synthetic binary classification data
X, y = make_classification(n_samples=1000, n_features=20, random_state=42)
# Scale the data using StandardScaler
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
# Split the data into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)
# Initialize the models
knn = KNeighborsClassifier()
rf = RandomForestClassifier()
dt = DecisionTreeClassifier()
svm = SVC(probability=True)
# Fit the models on the train set
knn.fit(X_train, y_train)
rf.fit(X_train, y_train)
dt.fit(X_train, y_train)
svm.fit(X_train, y_train)
# Predict probabilities on the test set
knn_probs = knn.predict_proba(X_test)[:, 1]
rf_probs = rf.predict_proba(X_test)[:, 1]
dt_probs = dt.predict_proba(X_test)[:, 1]
svm_probs = svm.predict_proba(X_test)[:, 1]
# Calculate the false positive rate (FPR) and true positive rate (TPR) for ROC curve
knn_fpr, knn_tpr, _ = roc_curve(y_test, knn_probs)
rf_fpr, rf_tpr, _ = roc_curve(y_test, rf_probs)
dt_fpr, dt_tpr, _ = roc_curve(y_test, dt_probs)
svm_fpr, svm_tpr, _ = roc_curve(y_test, svm_probs)
# Calculate the AUC (Area Under the Curve) for ROC curve
knn_auc = auc(knn_fpr, knn_tpr)
rf_auc = auc(rf_fpr, rf_tpr)
dt_auc = auc(dt_fpr, dt_tpr)
svm_auc = auc(svm_fpr, svm_tpr)
# Create an interactive AUC/ROC curve using Plotly
fig = go.Figure()
fig.add_trace(go.Scatter(x=knn_fpr, y=knn_tpr, name=‘KNN (AUC = {:.2f})’.format(knn_auc)))
fig.add_trace(go.Scatter(x=rf_fpr, y=rf_tpr, name=‘Random Forest (AUC = {:.2f})’.format(rf_auc)))
fig.add_trace(go.Scatter(x=dt_fpr, y=dt_tpr, name=‘Decision Tree (AUC = {:.2f})’.format(dt_auc)))
fig.add_trace(go.Scatter(x=svm_fpr, y=svm_tpr, name=‘SVM (AUC = {:.2f})’.format(svm_auc)))
fig.update_layout(title=‘AUC/ROC Curve’,
xaxis=dict(title=‘False Positive Rate’),
yaxis=dict(title=‘True Positive Rate’),
legend=dict(x=0.7, y=0.2))
# Show plot
fig.show()
Y conseguimos:
Así, con el método add.trace(go.Scatter) hemos creado gráficos de dispersión para cada modelo ML que hemos utilizado (KNN, SVM, Árbol de decisión y Random Forest).
De esta forma, es fácil visualizar los detalles y los valores de las zonas donde se interceptan las curvas.
Conclusiones
En este artículo, hemos mostrado una rápida introducción a Plotly y hemos visto cómo podemos usarlo para mejores visualizaciones en análisis de datos y Machine Learning.
Como podemos ver, se trata de una librería low-code que, efectivamente, nos ayuda a visualizar mejor nuestros datos, mejorando nuestros resultados.
Original article here