Pandas & NumPy Academy · Lektion

Heatmaps til korrelationsmatricer

Beregn en korrelationsmatrix med DataFrame.corr(), og visualisér den som et farvekodet heatmap med sns.heatmap.

Lektion 4 af 413 trin

Heatmaps til korrelationsmatricer er en gratis Pandas & NumPy Academy-lektion på CoddyKit. Dette er lektion 4 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Pandas & NumPy Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Pandas & NumPy Academy-kurset indeholder 4 lektioner i alt.

Hvad er en korrelationsmatrix?

En korrelationsmatrix er en kvadratisk tabel, hvor elementet (i, j) indeholder Pearsons korrelationskoefficient mellem kolonne i og kolonne j. Værdierne går fra -1 (perfekt negativ lineær korrelation) til +1 (perfekt positiv), hvor 0 betyder, at der ikke er nogen lineær sammenhæng. Diagonalen er altid 1 (en variabel er perfekt korreleret med sig selv). Korrelationsmatricer er første skridt til at forstå, hvilke variable der bevæger sig sammen, før du bygger en model.

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

Beregning af korrelationsmatricen

Kald DataFrame.corr() for at beregne parvise Pearson-korrelationer for alle numeriske kolonner. Parameteren method styrer, hvilken korrelation der beregnes: 'pearson' (standard, lineær), 'spearman' (rangbaseret, robust over for afvigere og ikke-lineære monotone sammenhænge) eller 'kendall'. For skæve finansielle data eller tælledata er Spearman ofte mere informativ end 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))

Grundlæggende heatmap med sns.heatmap

sns.heatmap(data) tager et todimensionalt array eller en DataFrame og gengiver det som et farvegitter — farven i hver celle repræsenterer dens numeriske værdi. Når det anvendes på en korrelationsmatrix, repræsenterer varme farver (rød) typisk positiv korrelation, mens kolde farver (blå) repræsenterer negativ korrelation. Parameteren annot=True skriver den numeriske værdi inde i hver celle, hvilket er afgørende for at kunne læse et korrelationsheatmap korrekt.

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

Valg af det rigtige farvekort

Til korrelationsmatricer skal du altid bruge et divergerende farvekort centreret ved nul: cmap='coolwarm', 'RdBu_r' eller 'vlag'. Disse kort bruger én farve til positive værdier, en anden til negative og et neutralt midtpunkt ved nul. Undgå sekventielle farvekort (som 'Blues') til korrelationsdata, fordi de gør det umuligt visuelt at skelne mellem positive og negative korrelationer. Angiv vmin=-1, vmax=1 for at fastlåse farveskalaen til hele korrelationsintervallet.

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

Maskering af den øvre trekant

Da en korrelationsmatrix er symmetrisk (corr[i,j] == corr[j,i]), er det overflødigt at vise begge halvdele. Brug np.triu til at oprette en maske for den øvre trekant, og giv den videre med mask= til sns.heatmap. Det halverer antallet af celler, så diagrammet bliver mindre rodet og lettere at læse. Diagonalværdierne (alle 1.0) kan også maskeres, da de ikke indeholder nogen information.

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

Tilpasning af annotationer og cellestørrelse

Styr formatet for annotationer med fmt= (f.eks. '.2f' for to decimaler) og skriftstørrelsen med annot_kws={'size': 10}. Parameteren linewidths tilføjer tynde linjer mellem cellerne, så gitteret bliver lettere at læse for store matricer. Brug square=True til at tvinge cellerne til at være kvadratiske uanset figurens dimensioner. Det giver heatmaps et rent og velafbalanceret udseende.

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

Klyngedannelse med clustermap

sns.clustermap() omorganiserer rækker og kolonner ved hjælp af hierarkisk klyngedannelse, så variable med lignende korrelationsmønstre grupperes sammen. Det gør det meget lettere at identificere blokke af korrelerede egenskaber i store matricer. Dendrogrammet på de øverste og venstre akser viser klyngedannelsens træ. Brug method='ward' og metric='euclidean' som fornuftige standardværdier til korrelationsbaseret klyngedannelse.

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

Heatmap for data fra pivottabeller

Heatmaps er ikke begrænset til korrelationsmatricer — enhver todimensional numerisk tabel kan drage fordel af farvekodning. Et almindeligt mønster er at beregne en pivottabel (f.eks. det gennemsnitlige drikkepengebeløb efter dag og tidspunkt) og derefter visualisere den som et heatmap. Det omdanner en tæt tabel med tal til et farvegitter, der hurtigt kan aflæses, hvor de højeste og laveste værdier straks springer i øjnene.

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

Fortolkning af korrelationsværdier

Brug disse omtrentlige tommelfingerregler, når du fortolker korrelationer: |r| < 0.2 = ubetydelig, 0.2-0.4 = svag, 0.4-0.6 = moderat, 0.6-0.8 = stærk, > 0.8 = meget stærk. Korrelation fortæller dog intet om årsagssammenhæng og kan være tilsyneladende (korreleret tilfældigt på grund af en tredje, forstyrrende variabel). Kombinér altid numerisk korrelationsanalyse med punktdiagrammer for at kontrollere, at sammenhængen faktisk er lineær og ikke skyldes afvigere.

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

Heatmaps for store datasæt: udvælgelse af delmængder

For DataFrames med mange kolonner bliver et komplet korrelationsheatmap ulæseligt. En bedre fremgangsmåde er at filtrere korrelationsmatricen, så den kun viser par med |r| over en tærskel (f.eks. 0.5), eller kun vælge de egenskaber, der korrelerer mest med en målvariabel. Du kan også udvælge efter fagområde — for eksempel plotte korrelationer mellem finansielle målepunkter separat fra operationelle målepunkter i et forretningsdatasæt.

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

Lagring af heatmaps i filer

Heatmaps indgår ofte i rapporter og præsentationer. Kald plt.savefig('filename.png', dpi=150, bbox_inches='tight') efter oprettelsen af heatmappet for at gemme det. Argumentet bbox_inches='tight' forhindrer, at aksemærkater bliver beskåret. Brug format='pdf' til PDF-rapporter. Når du bruger sns.clustermap, gemmes figuren i det returnerede objekt: 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')

Hurtig kontrol

Test din forståelse af korrelationsheatmaps fra denne lektion.

Opsummering af lektionen

I denne lektion lærte du, at DataFrame.corr() beregner parvise korrelationer, at sns.heatmap gengiver dem som et farvegitter med divergerende farvekort og annotationer, og at maskering af den øvre trekant fjerner overflødig information. Nu skal vi se på den komplette arbejdsgang for eksplorativ dataanalyse — en systematisk tjekliste til profilering af ethvert nyt datasæt.

Gratis at komme i gang

Lær Python med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser
30
Lektioner
120

Ofte stillede spørgsmål

Er lektionen “Heatmaps til korrelationsmatricer” gratis?

Ja — hele teksten til “Heatmaps til korrelationsmatricer” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Pandas & NumPy Academy-kurset, skal du opgradere til CoddyKit PRO. Pandas & NumPy Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Heatmaps til korrelationsmatricer”?

Beregn en korrelationsmatrix med DataFrame.corr(), og visualisér den som et farvekodet heatmap med sns.heatmap. Du øver dig i Pandas & NumPy Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Pandas & NumPy Academy?

Der kræves ingen tidligere erfaring. Pandas & NumPy Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 4 af 4.

Hvor lang tid tager lektionen “Heatmaps til korrelationsmatricer”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Pandas & NumPy Academy-lektion?

Ja. Alle Pandas & NumPy Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

  1. Fordelingsdiagrammer: histplot og kdeplot
  2. Kategoriske diagrammer: boxplot, barplot, violinplot
  3. Punktdiagrammer og parvise diagrammer
  4. Heatmaps til korrelationsmatricer
← Tilbage til Pandas & NumPy Academy