Show More
Menu
Image
Hi there! I am Federico Trotta

Technical WriterFreelance

Come Creare Visualizzazioni Interattive in Python: un’Introduzione a Plotly

Ottobre 31, 2023
By Federico
In AI
0 Comments
Post Image

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:

Grafico a bolle interattivo create on Python con la libreria Plotly da Federico Trotta
Il grafico a bolle risultante. Immagine dell’autore.

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:

Matrice di correlazione interattiva create in Python con Plotly da Federico Trotta
La matrice di correlazione risultante. Immagine dell’autore.

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:

Curva AUC/ROC interattiva create con Plotly in Python da Federico Trotta
La curva AUC/ROC risultante. Immagine dell’autore.

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.


Federico Trotta

Sono Federico Trotta e sono un Technical Writer.

Vuoi collaborare con me? Contattami.

Federico Trotta

Technical Writer: I document digital products and write articles about AI & Python programming.

Leave a reply