0Pricing
Pandas & NumPy Academy · Lezione

Heatmap per matrici di correlazione

Calcoli una matrice di correlazione con DataFrame.corr() e la visualizzi come heatmap codificata a colori con sns.heatmap.

Heatmap per matrici di correlazione è una lezione Pandas & NumPy 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 Pandas & NumPy Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Pandas & NumPy Academy include 4 lezioni in totale.

Che cos'è una matrice di correlazione?

Una matrice di correlazione è una tabella quadrata in cui l'elemento (i, j) contiene il coefficiente di correlazione di Pearson tra la colonna i e la colonna j. I valori variano da -1 (correlazione lineare negativa perfetta) a +1 (positiva perfetta), mentre 0 indica l'assenza di una relazione lineare. La diagonale è sempre pari a 1 (una variabile è perfettamente correlata con sé stessa). Le matrici di correlazione sono il primo passo per capire quali variabili variano insieme prima di costruire un modello.

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

# Compute correlation matrix for numeric columns
tips = sns.load_dataset('tips')
corr = tips[['total_bill', 'tip', 'size']].corr()
print(corr.round(2))

Calcolo della matrice di correlazione

Chiami DataFrame.corr() per calcolare le correlazioni di Pearson a coppie per tutte le colonne numeriche. Il parametro method controlla quale correlazione calcolare: 'pearson' (predefinita, lineare), 'spearman' (basata sui ranghi, robusta rispetto agli outlier e alle relazioni monotone non lineari) oppure 'kendall'. Per dati finanziari o dati di conteggio asimmetrici, Spearman è spesso più informativa di Pearson.

import pandas as pd
import seaborn as sns

tips = sns.load_dataset('tips')
numeric = tips.select_dtypes(include='number')

# Pearson vs Spearman
pearson = numeric.corr(method='pearson')
spearman = numeric.corr(method='spearman')

print('Pearson:')
print(pearson.round(2))
print('\nSpearman:')
print(spearman.round(2))

Mappa di calore di base con sns.heatmap

sns.heatmap(data) accetta un array 2D o un DataFrame e lo visualizza come una griglia colorata: il colore di ogni cella codifica il suo valore numerico. Quando viene applicata a una matrice di correlazione, i colori caldi (rosso) rappresentano in genere una correlazione positiva, mentre i colori freddi (blu) rappresentano una correlazione negativa. Il parametro annot=True stampa il valore numerico all'interno di ogni cella, un'opzione essenziale per leggere correttamente una mappa di calore della correlazione.

import seaborn as sns
import matplotlib.pyplot as plt

tips = sns.load_dataset('tips')
corr = tips.select_dtypes('number').corr()

sns.heatmap(corr, annot=True, fmt='.2f')
plt.title('Correlation Heatmap — Tips Dataset')
plt.tight_layout()
plt.show()

Scelta della scala cromatica appropriata

Per le matrici di correlazione, utilizzi sempre una scala cromatica divergente centrata sullo zero: cmap='coolwarm', 'RdBu_r' oppure 'vlag'. Queste scale usano un colore per i valori positivi, un altro per quelli negativi e un punto intermedio neutro in corrispondenza dello zero. Eviti le scale cromatiche sequenziali (come 'Blues') per i dati di correlazione, perché rendono impossibile distinguere visivamente le correlazioni positive da quelle negative. Imposti vmin=-1, vmax=1 per fissare la scala cromatica all'intero intervallo della correlazione.

import seaborn as sns
import matplotlib.pyplot as plt

tips = sns.load_dataset('tips')
corr = tips.select_dtypes('number').corr()

sns.heatmap(
    corr,
    annot=True,
    fmt='.2f',
    cmap='coolwarm',
    vmin=-1,
    vmax=1,
    center=0
)
plt.title('Correlation Heatmap with Diverging Palette')
plt.tight_layout()
plt.show()

Mascheramento del triangolo superiore

Poiché una matrice di correlazione è simmetrica (corr[i,j] == corr[j,i]), mostrare entrambe le metà è ridondante. Usi np.triu per creare una maschera del triangolo superiore e la passi a mask= in sns.heatmap. In questo modo il numero di celle si dimezza, rendendo il grafico meno affollato e più facile da leggere. È possibile mascherare anche i valori della diagonale (tutti 1.0), poiché non forniscono informazioni.

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np

tips = sns.load_dataset('tips')
corr = tips.select_dtypes('number').corr()

# Mask the upper triangle (including diagonal)
mask = np.triu(np.ones_like(corr, dtype=bool))

sns.heatmap(
    corr,
    mask=mask,
    annot=True,
    fmt='.2f',
    cmap='coolwarm',
    vmin=-1,
    vmax=1
)
plt.title('Lower-Triangle Correlation Heatmap')
plt.tight_layout()
plt.show()

Personalizzazione delle annotazioni e delle dimensioni delle celle

Controlli il formato delle annotazioni con fmt= (ad esempio '.2f' per due cifre decimali) e la dimensione del carattere con annot_kws={'size': 10}. Il parametro linewidths aggiunge linee sottili tra le celle, facilitando la lettura della griglia per le matrici di grandi dimensioni. Usi square=True per forzare celle quadrate indipendentemente dalle dimensioni della figura, ottenendo mappe di calore dall'aspetto ordinato ed equilibrato.

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np

# Load a wider dataset for a more interesting heatmap
penguins = sns.load_dataset('penguins').select_dtypes('number')
corr = penguins.corr()
mask = np.triu(np.ones_like(corr, dtype=bool))

sns.heatmap(
    corr,
    mask=mask,
    annot=True,
    fmt='.2f',
    cmap='vlag',
    vmin=-1,
    vmax=1,
    linewidths=0.5,
    square=True,
    annot_kws={'size': 10}
)
plt.title('Penguins Correlation Matrix')
plt.tight_layout()
plt.show()

Clustering con clustermap

sns.clustermap() riordina righe e colonne usando il clustering gerarchico per raggruppare le variabili con modelli di correlazione simili. Questo facilita notevolmente l'identificazione di gruppi di caratteristiche correlate nelle matrici di grandi dimensioni. Il dendrogramma sugli assi superiore e sinistro mostra l'albero del clustering. Usi method='ward' e metric='euclidean' come valori predefiniti ragionevoli per il clustering basato sulle correlazioni.

import seaborn as sns
import matplotlib.pyplot as plt

penguins = sns.load_dataset('penguins').select_dtypes('number').dropna()
corr = penguins.corr()

sns.clustermap(
    corr,
    cmap='coolwarm',
    vmin=-1,
    vmax=1,
    annot=True,
    fmt='.2f',
    figsize=(6, 6)
)
plt.suptitle('Clustered Correlation Matrix', y=1.02)
plt.show()

Mappa di calore per i dati di una tabella pivot

Le mappe di calore non sono limitate alle matrici di correlazione: qualsiasi tabella numerica 2D può trarre vantaggio dalla codifica tramite colori. Un approccio comune consiste nel calcolare una tabella pivot (ad esempio, la mancia media per giorno e ora) e visualizzarla quindi come mappa di calore. In questo modo una tabella densa di numeri diventa una griglia colorata immediatamente leggibile, in cui i valori più alti e più bassi risaltano a colpo d'occhio.

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

tips = sns.load_dataset('tips')

# Pivot: average bill by day and time
pivot = tips.pivot_table(
    values='total_bill',
    index='day',
    columns='time',
    aggfunc='mean'
)

sns.heatmap(pivot, annot=True, fmt='.1f', cmap='YlOrRd')
plt.title('Average Bill by Day and Time')
plt.tight_layout()
plt.show()

Interpretazione dei valori di correlazione

Quando interpreta le correlazioni, usi questi riferimenti approssimativi: |r| < 0.2 = trascurabile, 0.2-0.4 = debole, 0.4-0.6 = moderata, 0.6-0.8 = forte, > 0.8 = molto forte. Tuttavia, la correlazione non fornisce alcuna informazione sulla causalità e può essere spuria (una correlazione casuale dovuta a una terza variabile confondente). Affianchi sempre all'analisi numerica della correlazione alcuni grafici a dispersione, per verificare che la relazione sia effettivamente lineare e non dipenda dagli outlier.

import pandas as pd
import seaborn as sns

# Find the most correlated pairs
penguins = sns.load_dataset('penguins').select_dtypes('number').dropna()
corr = penguins.corr()

# Unstack to get pairs, remove self-correlations, sort
pairs = (corr
    .unstack()
    .reset_index()
    .rename(columns={'level_0': 'var1', 'level_1': 'var2', 0: 'r'})
    .query('var1 != var2')
    .assign(abs_r=lambda df: df['r'].abs())
    .sort_values('abs_r', ascending=False)
    .drop_duplicates(subset='abs_r')
)
print(pairs.head(6).to_string(index=False))

Mappe di calore per dataset di grandi dimensioni: selezione di sottoinsiemi

Per i DataFrame con molte colonne, una mappa di calore completa delle correlazioni diventa illeggibile. Un approccio migliore consiste nel filtrare la matrice di correlazione per mostrare solo le coppie con |r| superiore a una soglia (ad esempio 0.5), oppure nel selezionare solo le caratteristiche maggiormente correlate con una variabile obiettivo. Può anche creare sottoinsiemi in base al dominio: ad esempio, può rappresentare separatamente le correlazioni tra metriche finanziarie e quelle tra metriche operative in un dataset aziendale.

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np

# Show only features with |r| > 0.4 with any other feature
penguins = sns.load_dataset('penguins').select_dtypes('number').dropna()
corr = penguins.corr()

# Filter columns that have at least one high correlation (excluding diagonal)
high_corr = (corr.abs() > 0.4).any(axis=1)
filtered = corr.loc[high_corr, high_corr]
mask = np.triu(np.ones_like(filtered, dtype=bool))

sns.heatmap(filtered, mask=mask, annot=True,
            fmt='.2f', cmap='coolwarm', vmin=-1, vmax=1)
plt.title('High-Correlation Subset')
plt.tight_layout()
plt.show()

Salvataggio delle mappe di calore nei file

Le mappe di calore vengono spesso incluse in report e presentazioni. Dopo aver creato la mappa di calore, chiami plt.savefig('filename.png', dpi=150, bbox_inches='tight') per salvarla. L'argomento bbox_inches='tight' impedisce che le etichette degli assi vengano tagliate. Per i report in PDF, usi format='pdf'. Quando usa sns.clustermap, la figura viene memorizzata nell'oggetto restituito: g = sns.clustermap(...); g.savefig('plot.png').

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np

tips = sns.load_dataset('tips')
corr = tips.select_dtypes('number').corr()
mask = np.triu(np.ones_like(corr, dtype=bool))

fig, ax = plt.subplots(figsize=(6, 5))
sns.heatmap(corr, mask=mask, annot=True, fmt='.2f',
            cmap='coolwarm', vmin=-1, vmax=1,
            linewidths=0.5, ax=ax)
ax.set_title('Correlation Heatmap')

# Save to file
plt.savefig('/tmp/correlation_heatmap.png', dpi=150, bbox_inches='tight')
plt.close()
print('Saved to /tmp/correlation_heatmap.png')

Verifica rapida

Verifichi la Sua comprensione delle mappe di calore delle correlazioni illustrate in questa lezione.

Riepilogo della lezione

In questa lezione ha imparato che DataFrame.corr() calcola le correlazioni a coppie, sns.heatmap le visualizza come una griglia colorata con scale cromatiche divergenti e annotazioni e il mascheramento del triangolo superiore elimina la ridondanza. Ora esploreremo l'intero processo di analisi esplorativa dei dati (EDA), una checklist sistematica per profilare qualsiasi nuovo dataset.

Domande Frequenti

La lezione «Heatmap per matrici di correlazione» è gratuita?

Sì — il testo completo di «Heatmap per matrici di correlazione» è 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 Pandas & NumPy Academy, passa a CoddyKit PRO. Il corso Pandas & NumPy Academy include 4 lezioni in totale.

Cosa imparerò in «Heatmap per matrici di correlazione»?

Calcoli una matrice di correlazione con DataFrame.corr() e la visualizzi come heatmap codificata a colori con sns.heatmap. Eserciti Pandas & NumPy 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 Pandas & NumPy Academy?

Non è richiesta alcuna esperienza precedente. Pandas & NumPy 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 «Heatmap per matrici di correlazione»?

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 Pandas & NumPy Academy?

Sì. Ogni lezione Pandas & NumPy 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

  1. Grafici di distribuzione: histplot e kdeplot
  2. Grafici categorici: boxplot, barplot, violinplot
  3. Grafici a dispersione e pair plot
  4. Heatmap per matrici di correlazione
← Torna a Pandas & NumPy Academy