0Pricing
Pandas & NumPy Academy · Lektion

Heatmaps für Korrelationsmatrizen

Berechnen Sie mit DataFrame.corr() eine Korrelationsmatrix und visualisieren Sie sie mit sns.heatmap als farbcodierte Heatmap.

Heatmaps für Korrelationsmatrizen ist eine kostenlose Pandas & NumPy Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Pandas & NumPy Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Pandas & NumPy Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist eine Korrelationsmatrix?

Eine Korrelationsmatrix ist eine quadratische Tabelle, in der der Eintrag (i, j) den Pearson-Korrelationskoeffizienten zwischen Spalte i und Spalte j enthält. Die Werte reichen von -1 (perfekt negative lineare Korrelation) bis +1 (perfekt positive Korrelation), wobei 0 keinen linearen Zusammenhang bedeutet. Die Diagonale ist immer 1 (eine Variable korreliert perfekt mit sich selbst). Korrelationsmatrizen sind der erste Schritt, um zu verstehen, welche Variablen sich gemeinsam verändern, bevor Sie ein Modell erstellen.

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

Korrelationsmatrix berechnen

Rufen Sie DataFrame.corr() auf, um paarweise Pearson-Korrelationen für alle numerischen Spalten zu berechnen. Der Parameter method legt fest, welche Korrelation berechnet wird: 'pearson' (Standardwert, linear), 'spearman' (rangbasiert, robust gegenüber Ausreißern und nichtlinearen monotonen Zusammenhängen) oder 'kendall'. Bei schief verteilten Finanz- oder Zähldaten ist Spearman oft aussagekräftiger als 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))

Einfache Heatmap mit sns.heatmap

sns.heatmap(data) nimmt ein zweidimensionales Array oder einen DataFrame entgegen und stellt ihn als Farbmatrix dar – die Farbe jeder Zelle kodiert ihren numerischen Wert. Bei einer Korrelationsmatrix stehen warme Farben (Rot) normalerweise für positive Korrelationen und kühle Farben (Blau) für negative. Der Parameter annot=True schreibt den numerischen Wert in jede Zelle und ist unverzichtbar, um eine Korrelations-Heatmap korrekt zu lesen.

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

Die richtige Farbkarte auswählen

Verwenden Sie für Korrelationsmatrizen immer eine divergierende Farbkarte mit Mittelpunkt bei null: cmap='coolwarm', 'RdBu_r' oder 'vlag'. Diese Karten verwenden eine Farbe für positive Werte, eine andere für negative Werte und einen neutralen Mittelpunkt bei null. Vermeiden Sie sequenzielle Farbkarten (wie 'Blues') für Korrelationsdaten, da sich damit positive und negative Korrelationen visuell nicht unterscheiden lassen. Setzen Sie vmin=-1, vmax=1, um die Farbskala auf den vollständigen Korrelationsbereich festzulegen.

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

Obere Dreiecksmatrix maskieren

Da eine Korrelationsmatrix symmetrisch ist (corr[i,j] == corr[j,i]), ist die Darstellung beider Hälften redundant. Verwenden Sie np.triu, um eine Maske für das obere Dreieck zu erstellen, und übergeben Sie sie mit mask= an sns.heatmap. Dadurch halbiert sich die Zahl der Zellen, sodass das Diagramm übersichtlicher und leichter lesbar wird. Auch die Diagonalwerte (alle 1.0) können maskiert werden, da sie keine Informationen enthalten.

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

Annotation und Zellgröße anpassen

Steuern Sie das Format der Annotation mit fmt= (z. B. '.2f' für zwei Dezimalstellen) und die Schriftgröße mit annot_kws={'size': 10}. Der Parameter linewidths fügt dünne Linien zwischen den Zellen ein und erleichtert so bei großen Matrizen das Lesen des Rasters. Verwenden Sie square=True, um unabhängig von den Abmessungen der Abbildung quadratische Zellen zu erzwingen. Dadurch erhalten Heatmaps ein klares, ausgewogenes Erscheinungsbild.

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 mit clustermap

sns.clustermap() ordnet Zeilen und Spalten mithilfe des hierarchischen Clusterings neu an, um Variablen mit ähnlichen Korrelationsmustern zusammenzufassen. Dadurch lassen sich Gruppen korrelierter Merkmale in großen Matrizen deutlich leichter erkennen. Das Dendrogramm an den oberen und linken Achsen zeigt den Clusterbaum. Verwenden Sie method='ward' und metric='euclidean' als sinnvolle Standardwerte für korrelationsbasiertes Clustering.

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 für Pivot-Tabellendaten

Heatmaps sind nicht auf Korrelationsmatrizen beschränkt – jede numerische zweidimensionale Tabelle profitiert von der Kodierung durch Farben. Ein häufiges Vorgehen besteht darin, eine Pivot-Tabelle zu berechnen (z. B. das durchschnittliche Trinkgeld nach Tag und Uhrzeit) und anschließend als Heatmap darzustellen. So wird eine dichte Zahlentabelle in ein sofort erfassbares Farbraster umgewandelt, in dem die höchsten und niedrigsten Werte visuell hervorstechen.

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

Korrelationswerte interpretieren

Verwenden Sie bei der Interpretation von Korrelationen folgende grobe Richtwerte: |r| < 0.2 = vernachlässigbar, 0.2-0.4 = schwach, 0.4-0.6 = mittel, 0.6-0.8 = stark, > 0.8 = sehr stark. Korrelation sagt jedoch nichts über Kausalität aus und kann scheinhaft sein (zufällig durch eine dritte, konfundierende Variable korreliert). Kombinieren Sie die numerische Korrelationsanalyse immer mit Streudiagrammen, um zu überprüfen, ob der Zusammenhang tatsächlich linear ist und nicht durch Ausreißer bestimmt wird.

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 großer Datensätze: Teilmengen bilden

Bei DataFrames mit vielen Spalten wird eine vollständige Korrelations-Heatmap unlesbar. Ein besserer Ansatz besteht darin, die Korrelationsmatrix zu filtern, sodass nur Paare mit |r| oberhalb eines Schwellenwerts (z. B. 0.5) angezeigt werden, oder nur die Merkmale mit der stärksten Korrelation zu einer Zielvariable auszuwählen. Sie können die Auswahl auch nach Fachbereich einschränken – beispielsweise Korrelationen zwischen Finanzkennzahlen getrennt von operativen Kennzahlen in einem Geschäftsdataset darstellen.

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

Heatmaps in Dateien speichern

Heatmaps werden häufig in Berichte und Präsentationen aufgenommen. Rufen Sie nach dem Erstellen der Heatmap plt.savefig('filename.png', dpi=150, bbox_inches='tight') auf, um sie zu speichern. Das Argument bbox_inches='tight' verhindert, dass Achsenbeschriftungen abgeschnitten werden. Verwenden Sie für PDF-Berichte format='pdf'. Bei sns.clustermap wird die Abbildung im zurückgegebenen Objekt gespeichert: 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')

Schnelltest

Testen Sie Ihr Verständnis der Korrelations-Heatmaps aus dieser Lektion.

Lektionszusammenfassung

In dieser Lektion haben Sie gelernt: DataFrame.corr() berechnet paarweise Korrelationen, sns.heatmap stellt sie mit divergierenden Farbkarten und Annotationen als Farbraster dar, und das Maskieren des oberen Dreiecks entfernt Redundanzen. Als Nächstes untersuchen wir die vollständige Pipeline der explorativen Datenanalyse – eine systematische Checkliste zur Profilierung jedes neuen Datensatzes.

Häufig gestellte Fragen

Ist die Lektion „Heatmaps für Korrelationsmatrizen“ kostenlos?

Ja — der vollständige Text von „Heatmaps für Korrelationsmatrizen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Pandas & NumPy Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Pandas & NumPy Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Heatmaps für Korrelationsmatrizen“?

Berechnen Sie mit DataFrame.corr() eine Korrelationsmatrix und visualisieren Sie sie mit sns.heatmap als farbcodierte Heatmap. Du übst Pandas & NumPy Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Pandas & NumPy Academy zu starten?

Keine Vorkenntnisse erforderlich. Pandas & NumPy Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Heatmaps für Korrelationsmatrizen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Pandas & NumPy Academy-Lektion Code schreiben und ausführen?

Ja. Jede Pandas & NumPy Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Verteilungsdiagramme: histplot und kdeplot
  2. Kategoriale Diagramme: boxplot, barplot, violinplot
  3. Streudiagramme und Pairplots
  4. Heatmaps für Korrelationsmatrizen
← Zurück zu Pandas & NumPy Academy