Visualizzazione dei dati con Matplotlib e Seaborn
Creerà istogrammi, grafici a dispersione e mappe di calore delle correlazioni per esplorare distribuzioni e relazioni nei dati prima della modellazione.
Visualizzazione dei dati con Matplotlib e Seaborn è una lezione Machine Learning Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Machine Learning Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Machine Learning Academy include 4 lezioni in totale.
Perché la visualizzazione è importante nel ML
I grafici non servono solo per le relazioni: sono uno strumento diagnostico in ogni fase. Matplotlib offre un controllo completo; Seaborn crea grafici statistici accattivanti con meno codice.
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import numpy as np
# Set seaborn theme for all plots
sns.set_theme(style='whitegrid', palette='muted')
# Load a built-in dataset
df = sns.load_dataset('tips')
print(df.head())Istogrammi: comprendere le distribuzioni
Un istogramma raggruppa una colonna numerica in intervalli per mostrarne la forma: normale, asimmetrica o con valori anomali. Riconoscere l'asimmetria aiuta a capire quando una trasformazione logaritmica potrebbe migliorare il modello.
import matplotlib.pyplot as plt
import seaborn as sns
df = sns.load_dataset('tips')
fig, axes = plt.subplots(1, 2, figsize=(12, 4))
# Raw distribution (right-skewed)
axes[0].hist(df['total_bill'], bins=30, edgecolor='white')
axes[0].set_title('Total Bill Distribution (Raw)')
# After log transform
import numpy as np
axes[1].hist(np.log(df['total_bill']), bins=30, edgecolor='white')
axes[1].set_title('Total Bill Distribution (Log Transformed)')
plt.tight_layout()
plt.show()Grafici a dispersione: relazioni tra caratteristiche
Un grafico a dispersione mostra la relazione tra due numeri: lineare, curva o ricca di valori anomali. Aggiunga il colore con hue per inserire una terza variabile nella stessa visualizzazione.
import matplotlib.pyplot as plt
import seaborn as sns
df = sns.load_dataset('tips')
# Scatter plot with hue encoding
sns.scatterplot(
data=df,
x='total_bill',
y='tip',
hue='time', # encode meal time as colour
size='size', # encode party size as dot size
alpha=0.7
)
plt.title('Tip vs Total Bill (coloured by Meal Time)')
plt.show()Box plot: confrontare gruppi
Un box plot mostra mediana, dispersione e valori anomali tra diversi gruppi. Se il box di una caratteristica appare molto diverso per ogni categoria, probabilmente vale la pena conservarla.
import matplotlib.pyplot as plt
import seaborn as sns
df = sns.load_dataset('tips')
fig, axes = plt.subplots(1, 2, figsize=(12, 5))
sns.boxplot(data=df, x='day', y='total_bill', ax=axes[0])
axes[0].set_title('Bill by Day of Week')
sns.boxplot(data=df, x='smoker', y='tip', hue='sex', ax=axes[1])
axes[1].set_title('Tip by Smoking Status and Sex')
plt.tight_layout()
plt.show()Heatmap delle correlazioni: trovare caratteristiche correlate
Una heatmap delle correlazioni usa i colori per indicare quanto ogni coppia di colonne varia insieme. Rivela buoni predittori dell'obiettivo e caratteristiche ridondanti da eliminare.
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
df = pd.read_csv('titanic.csv')
# Compute correlation matrix
corr = df[['Survived', 'Pclass', 'Age', 'SibSp', 'Parch', 'Fare']].corr()
# Plot heatmap
plt.figure(figsize=(8, 6))
sns.heatmap(
corr,
annot=True, # show correlation values
fmt='.2f', # 2 decimal places
cmap='RdYlGn', # red-yellow-green colour scale
vmin=-1, vmax=1
)
plt.title('Feature Correlation Matrix')
plt.show()Pair plot: esplorare tutte le coppie di caratteristiche
Un pair plot mostra contemporaneamente i grafici a dispersione di ogni coppia di caratteristiche: è un primo esame rapido di un nuovo dataset. Usi il colore per classe per vedere quali caratteristiche separano i gruppi.
import seaborn as sns
import matplotlib.pyplot as plt
# Use the iris dataset (classic ML benchmark)
df = sns.load_dataset('iris')
# Pair plot coloured by species
sns.pairplot(
df,
hue='species',
diag_kind='kde', # KDE on diagonal
plot_kws={'alpha': 0.6}
)
plt.suptitle('Iris Dataset Pair Plot', y=1.02)
plt.show()Grafici a barre e grafici dei conteggi
Un count plot mostra la frequenza di ogni categoria: è il modo più rapido per controllare l'equilibrio delle classi prima di addestrare un classificatore. Aggiunga hue per confrontare due categorie.
import seaborn as sns
import matplotlib.pyplot as plt
df = sns.load_dataset('titanic')
fig, axes = plt.subplots(1, 2, figsize=(12, 5))
# Class distribution (check balance)
sns.countplot(data=df, x='survived', ax=axes[0])
axes[0].set_title('Survival Count')
# Class by passenger class and sex
sns.countplot(data=df, x='class', hue='sex', ax=axes[1])
axes[1].set_title('Class Distribution by Sex')
plt.tight_layout()
plt.show()Tracciare le curve di apprendimento
Una curva di apprendimento traccia il punteggio di addestramento e quello di validazione man mano che aumentano i dati. Se entrambi sono bassi, si ha underfitting; una grande differenza indica overfitting; se entrambi sono alti e vicini, l'adattamento è buono.
import matplotlib.pyplot as plt
import numpy as np
from sklearn.model_selection import learning_curve
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
X, y = load_breast_cancer(return_X_y=True)
train_sizes, train_scores, val_scores = learning_curve(
DecisionTreeClassifier(max_depth=5), X, y, cv=5
)
plt.plot(train_sizes, train_scores.mean(axis=1), label='Training Score')
plt.plot(train_sizes, val_scores.mean(axis=1), label='Validation Score')
plt.xlabel('Training Set Size')
plt.ylabel('Accuracy')
plt.legend()
plt.title('Learning Curve')
plt.show()Visualizzare le previsioni del modello
Dopo l'addestramento, tracci le previsioni. La heatmap di una matrice di confusione mostra dove un classificatore confonde le etichette, fornendo molte più informazioni di un singolo valore di accuratezza.
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix
from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
model = DecisionTreeClassifier(max_depth=3)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix')
plt.show()Salvare e personalizzare i grafici
I grafici efficaci richiedono alcuni ritocchi: titoli, etichette degli assi e caratteri leggibili. Li salvi con savefig usando dpi=150 o superiore per le relazioni e scelga una tavolozza adatta alle persone daltoniche.
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
# Create figure and axes explicitly
fig, ax = plt.subplots(figsize=(8, 5))
x = np.linspace(0, 10, 100)
ax.plot(x, np.sin(x), label='sin(x)', linewidth=2)
ax.plot(x, np.cos(x), label='cos(x)', linewidth=2, linestyle='--')
# Customise
ax.set_xlabel('x', fontsize=13)
ax.set_ylabel('y', fontsize=13)
ax.set_title('Sine and Cosine', fontsize=15, fontweight='bold')
ax.legend(fontsize=12)
ax.grid(True, alpha=0.3)
# Save
fig.savefig('plot.png', dpi=150, bbox_inches='tight')
plt.show()Grafici delle distribuzioni con Seaborn
Un violin plot combina un box plot con una curva di densità e mostra la forma completa di una distribuzione. displot e kdeplot di Seaborn sono ideali per confronti uniformi.
import seaborn as sns
import matplotlib.pyplot as plt
df = sns.load_dataset('tips')
fig, axes = plt.subplots(1, 2, figsize=(12, 5))
# Violin plot
sns.violinplot(data=df, x='day', y='total_bill', hue='sex',
split=True, inner='quart', ax=axes[0])
axes[0].set_title('Bill Distribution by Day (Violin)')
# KDE distribution comparison
sns.kdeplot(data=df, x='tip', hue='time', fill=True, alpha=0.4, ax=axes[1])
axes[1].set_title('Tip Distribution by Meal Time (KDE)')
plt.tight_layout()
plt.show()Verifica rapida
Verifichi la Sua comprensione dei concetti di Machine Learning con Python presentati in questa lezione.
Riepilogo della lezione
Ha imparato a osservare i dati: istogrammi e grafici a dispersione ne rivelano la forma, le heatmap individuano i predittori e le curve di apprendimento diagnosticano l'adattamento. Prossimo argomento: il Suo primo modello! 🚀
Impara Python con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 30
- Lezioni
- 120
Domande Frequenti
La lezione «Visualizzazione dei dati con Matplotlib e Seaborn» è gratuita?
Sì — il testo completo di «Visualizzazione dei dati con Matplotlib e Seaborn» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Machine Learning Academy, passa a CoddyKit PRO. Il corso Machine Learning Academy include 4 lezioni in totale.
Cosa imparerò in «Visualizzazione dei dati con Matplotlib e Seaborn»?
Creerà istogrammi, grafici a dispersione e mappe di calore delle correlazioni per esplorare distribuzioni e relazioni nei dati prima della modellazione. Eserciti Machine Learning Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Machine Learning Academy?
Non è richiesta alcuna esperienza precedente. Machine Learning Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Visualizzazione dei dati con Matplotlib e Seaborn»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Machine Learning Academy?
Sì. Ogni lezione Machine Learning Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Installazione di Anaconda e Jupyter Notebook
- Fondamenti di NumPy: array e operazioni matematiche
- Pandas per la manipolazione dei dati
- Visualizzazione dei dati con Matplotlib e Seaborn