La data visualization è uno dei compiti più importanti per i professionisti dei dati. Ci aiuta, infatti, a comprendere i dati e a porre ulteriori domande per ulteriori approfondimenti.

Ma la visualizzazione dei dati non è solo un compito che si conclude nella fase di analisi esplorativa dei dati. Potrebbe anche essere necessario presentare i dati, spesso a un pubblico non tecnico, per aiutarlo a trarre alcune conclusioni.

In Python, generalmente utilizziamo matplotlib e seaborn come librerie per disegnare i grafici.

Tuttavia, a volte potremmo aver bisogno di alcune visualizzazioni interattive, per una migliore comprensione o presentazione dei dati.

In questo articolo parleremo di plotly, una libreria Python per realizzare visualizzazioni interattive.

Che cos’è Plotly?

Come possiamo leggere sul loro sito:

Plotly’s Python graphing library makes interactive, publication-quality graphs. Examples of how to make line plots, scatter plots, area charts, bar charts, error bars, box plots, histograms, heatmaps, subplots, multiple-axes, polar charts, and bubble charts.

Plotly.py is free and open source and you can view the source, report issues or contribute on GitHub.

Quindi, plotly è una libreria Python gratuita e open source per creare visualizzazioni interattive.

Come possiamo vedere sul loro sito web, ci dà la possibilità di creare grafici per diversi ambiti: AI/ML, statistico, scientifico, finanziario e molto altro.

Poiché siamo interessati al Machine Learning e alla Data Science, mostreremo alcuni grafici relativi a questo campo e come crearli in Python.

Innanzitutto, per installare la libreria scriviamo:

$ pip install plotly

Grafici a bolle interattivi

Una caratteristica interessante e utile di plotly è che abbiamo la possibilità di poter creare grafici a bolle interattivi.

Nel caso dei grafici a bolle normali, a volte le bolle possono intersecarsi tra di loro, rendendo difficile la lettura dei dati.

Se il grafico è interattivo, invece, possiamo leggere i dati più facilmente.

Vediamo un esempio:

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

Questo è il risultato che otteniamo:

Quindi, abbiamo creato dei dati con NumPy e li abbiamo archiviati in un data frame con pandas.

Successivamente, abbiamo creato il grafico interattivo con il metodo px.scatter() recuperando i dati dal data frame e specificando il titolo (al contrario di matplotlib in cui inseriamo il titolo al di fuori del metodo utilizzato per creare il grafico stesso) .

Matrici di correlazione interattive

Uno dei compiti con cui, a volte, si possono avere difficoltà è la corretta visualizzazione delle matrici di correlazione.

Queste, infatti, a volte possono essere difficili da leggere e da visualizzare quando si hanno molti dati. Un modo per risolvere il problema è utilizzare plotly per creare una visualizzazione interattiva.

Per fare un esempio, creiamo un data frame in pandas con 10 colonne e creiamo una matrice di correlazione interattiva 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()

Questo è il risultato che otteniamo:

Quindi, in modo molto semplice, possiamo creare una matrice di correlazione interattiva con il metodo ff.create_annotated_map() di plotly.

Grafici interattivi per il Machine Learning

Nel Machine Learning, a volte abbiamo bisogno di confrontare graficamente delle quantità su un grafico ma, a volte, la lettura risulta difficile.

Il caso tipico è una curva ROC/AUC in cui confrontiamo le prestazioni di diversi modelli di ML. A volte, infatti, le curve si intersecano tra di loro e non riusciamo a visualizzarle correttamente.

Per migliorare le nostre visualizzazioni, possiamo utilizzare plotly per creare una curva ROC/AUC interattiva in questo modo:

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

E otteniamo:

Quindi, con il metodo add.trace(go.Scatter) abbiamo creato grafici a dispersione per ogni modello ML che abbiamo utilizzato (KNN, SVM, Decision Tree e Random Forest).

In questo modo è facile visualizzare i dettagli ed i valori delle zone in cui le curve si intercettano.

Conclusioni

In questo articolo, abbiamo visto una rapida introduzione a plotly e abbiamo mostrato come possiamo utilizzarlo per visualizzazioni migliori nell’analisi dei dati e nel Machine Learning.

Come possiamo vedere, si tratta di una libreria low-code che, infatti, ci aiuta a visualizzare meglio i nostri dati, migliorando i nostri risultati.

NOTA: l’articolo originale è stato scritto in inglese e pubblicato su Towards Data Science.

Sono Federico Trotta e sono un Technical Writer.

Vuoi collaborare con me? Contattami.