Kerndichteschätzung: Von der Theorie zur Praxis

Schon mal versucht, eine Verteilung zu visualisieren – und jedes Mal eine andere Histogrammform bekommen, sobald du die Klassengröße änderst?

Typischer Ablauf: Du wählst 10 Klassen und siehst eine glatte Kurve. Stellst du auf 30 um, tauchen mehrere Peaks auf. Die Daten sind identisch, doch unterschiedliche Klassenzahlen liefern unterschiedliche Interpretationen. Genau das ist das Kernproblem von Histogrammen: Sie zeigen dir nicht „die“ Verteilung, sondern nur eine Version davon – beeinflusst von einem Parameter, den du willkürlich setzt.

KDE geht anders vor. Statt Daten in Klassen zu schneiden, legt sie auf jeden Datenpunkt eine kleine, glatte Kurve und summiert alles auf. So erhältst du eine einzige, stetige Schätzung der zugrunde liegenden Verteilung.

In diesem Artikel bekommst du die Intuition hinter KDE, einen Rundgang durch die Formel, eine Erklärung, wie die Bandbreite die Glättung steuert, sowie praxisnahe Beispiele in Python und R.

Neu bei Histogrammen? Hier findest du eine umfassende Einführung in Frequency Histograms – perfekt für den Einstieg.

Was ist Kerndichteschätzung?

Die Kerndichteschätzung ist eine nichtparametrische Methode, um die Wahrscheinlichkeitsdichtefunktion eines Datensatzes zu schätzen.

Der nichtparametrische Teil macht den Unterschied.

Bei parametrischen Methoden nimmst du an, dass deine Daten einer bestimmten Verteilung folgen – normal, exponentiell – und passt dann die Parameter an. Ist die Annahme falsch, ist auch das Modell falsch. KDE macht solche Annahmen nicht. Die Daten „sprechen für sich“ und die Verteilung wird direkt aus den Beobachtungen geschätzt.

Das Ergebnis ist eine glatte Kurve, die zeigt, wo Werte wahrscheinlich liegen – und wie wahrscheinlich. Hohe Kurvenpunkte bedeuten dichte Bereiche, niedrige zeigen dünn besetzte Regionen.

Warum Kerndichteschätzung verwenden?

Histogramme sind der Standard zur Visualisierung von Verteilungen, haben aber ein Problem: Die sichtbare Form hängt von der gewählten Klassenzahl ab – und diesen Parameter bestimmst du. Zwei Personen können denselben Datensatz ansehen und allein durch unterschiedliche Klassenzahlen zu völlig verschiedenen Schlüssen kommen.

Mit KDE zwingst du die Daten nicht in Klassen. Stattdessen entsteht eine glatte, stetige Kurve, die nicht von einem willkürlichen Parameter abhängt, den du vorab festlegst.

Das ist nützlich für:

• Die Gesamtform einer Verteilung ohne Klassengrößen-Bias sichtbar machen
• Muster wie mehrere Peaks, Schiefe oder fette Tails erkennen
• Verteilungen zwischen Gruppen im selben Plot vergleichen
• Vor dem Modellieren ein klareres Bild der Daten bekommen

Die Intuition hinter KDE

Du nimmst jeden Datenpunkt und legst eine kleine, glatte Kurve darüber. Diese Kurve heißt Kernel. Dann summierst du all diese Kurven zu einer einzigen auf.

Am Ende erhältst du eine glatte Kurve, die die Dichte deiner Daten zeigt. Wo Punkte clustern, überlappen viele Kerne und stapeln sich – die Kurve steigt. Wo wenige Daten liegen, überlappen sie kaum – die Kurve bleibt niedrig. Jeder Punkt trägt gleich stark zur Schätzung bei.

Stell dir vor, du hast die Abschlussklausur-Noten einer Klasse erfasst. Statt ein Histogramm zu bilden, legt KDE auf jede Note eine kleine glatte Kurve. Wo die Noten clustern – sagen wir um 70–75 – stapeln sich die Kurven und die Schätzung steigt. Eine einzelne 95 erzeugt nur einen kleinen Buckel im Tail.

Die folgende Visualisierung zeigt genau das. Die meisten Schüler lagen um den Durchschnitt, eine Person deutlich höher:

KDE visualisiert

Die KDE-Formel

Die KDE-Formel wirkt einschüchternder, als sie ist.

KDE-Formel

Das bedeuten die Teile:

• n ist die Anzahl der Datenpunkte

• x_i sind die einzelnen Datenpunkte in deinem Datensatz

• K ist die Kernfunktion – die glatte Kurve auf jedem Punkt

• h ist die Bandbreite – sie steuert die Breite jedes Kerns

• x ist der Punkt, an dem du die Dichte auswertest

Einfach gesagt: Für einen beliebigen Punkt x schaust du, wie nah jeder Datenpunkt x_i daran liegt, gewichtest diese Nähe mit der Kernfunktion K und bildest den Durchschnitt über alle n Punkte. Machst du das für alle x entlang des Bereichs, bekommst du die vollständige Dichtekurve.

Die Bandbreite h steht im Nenner des Bruchs innerhalb von K. Ein kleineres h macht den Kern schmaler – nur sehr nahe Punkte beeinflussen die Schätzung. Ein größeres h weitet den Einfluss. Mehr dazu weiter unten im Artikel.

Was ist eine Kernfunktion?

Der Kernel ist die glatte Kurve, die du auf jeden Datenpunkt legst. Sie definiert, wie sich der Einfluss dieses Punktes auf seine Nachbarn verteilt.

Jeder Kernel ist auf einen Datenpunkt zentriert und weist je nach Abstand Gewichte zu. Punkte nahe dem Zentrum erhalten hohes Gewicht, weit entfernte geringes oder keines. Die genaue Gewichtung hängt von der gewählten Kernform ab.

Drei gängige Varianten sind:

• Gauß: Die Glockenkurve. Alle Punkte im Datensatz erhalten Gewicht, das mit der Entfernung abnimmt. In den meisten Libraries Standard und praxistauglich
• Uniform: Ein flaches Rechteck. Alle Punkte innerhalb eines festen Abstands bekommen gleiches Gewicht, außerhalb keines. Einfach, aber weniger glatte Schätzungen
• Epanechnikov: Parabolische Form, mathematisch optimal bzgl. mittlerem quadratischen Fehler. Effizienter als Gauß, macht in der Praxis aber selten einen sichtbaren Unterschied.

Meistens spielt die Kernelwahl kaum eine Rolle. Zwei unterschiedliche Kerne mit gleicher Bandbreite liefern nahezu identische Kurven. Viel wichtiger ist die Bandbreite – und die schauen wir uns als Nächstes an.

Die Rolle der Bandbreite in der KDE

Die Bandbreite ist der eine Parameter mit dem größten Einfluss auf das KDE-Ergebnis – wichtiger als die Kernelwahl.

Sie steuert die Breite jedes Kerns. Ein schmaler Kern bezieht nur nahe Punkte ein. Ein breiter Kern verteilt den Einfluss über einen größeren Bereich. Das Ergebnis ist entweder eine Kurve, die den Daten eng folgt, oder eine stärker geglättete Darstellung.

Kleine Bandbreite

Eine kleine Bandbreite macht jeden Kern eng und schmal. Die Schätzung reagiert stark auf jeden Datenpunkt – sie erfasst echte Struktur, aber auch Rauschen.

In der Praxis wirkt das wie eine zackige Kurve mit vielen kleinen Peaks. Manche zeigen echte Cluster, andere sind Artefakte zu geringer Glättung. Beides zu unterscheiden ist schwierig – genau das ist das Problem.

KDE mit kleiner Bandbreite

Große Bandbreite

Eine große Bandbreite macht die Kerne breit. Benachbarte Kerne überlappen stark, die Kurve wird glatt.

Wird es zu glatt, gehen echte Strukturen verloren. Zwei getrennte Cluster können zu einer einzigen Welle verschwimmen. Eine Verteilung mit fettem Tail kann plötzlich symmetrisch wirken. Die Visualisierung versteckt dann wichtige Details.

KDE mit großer Bandbreite

Die richtige Bandbreite finden

Eine universell „richtige“ Bandbreite gibt es nicht. Ziel ist ein Wert, der Rauschen ausreichend glättet, ohne echte Muster zu verwischen.

Die meisten Libraries bieten automatische Auswahlverfahren. Die Daumenregel von Silverman ist am verbreitetsten. Sie wählt die Bandbreite basierend auf Stichprobengröße und Standardabweichung. Für annähernd normale Verteilungen gut, bei multimodalen oft zu glatt.

Wenn du unsicher bist, probiere mehrere Bandbreiten und vergleiche die Kurven. Die Unterschiede verraten dir viel über deine Daten.

KDE vs. Histogramm

Histogramme und KDE zeigen beide die Verteilung deiner Daten – aber auf sehr unterschiedliche Weise.

Histogramm

Ein Histogramm teilt die Daten in diskrete Klassen und zählt die Punkte in jeder Klasse. Schnell, intuitiv und leicht einem nicht-technischen Publikum zu erklären.

Das Problem ist die Sensitivität gegenüber der Klassenzahl. Änderst du sie, ändert sich die Form. Eine objektiv „richtige“ Klassenzahl gibt es nicht – zwei Personen können dadurch völlig unterschiedliche Schlüsse ziehen.

Histogramme erzeugen zudem eine stufige, diskontinuierliche Form. Für den schnellen Blick okay, aber die wahre Verteilung kann verdeckt bleiben.

KDE

KDE liefert eine glatte, stetige Kurve – ganz ohne Klassen. Sie zeigt die tatsächliche Form der Verteilung oft besser: Schiefe, mehrere Peaks oder fette Tails, die ein Histogramm je nach Klassenzahl übersehen oder verfälschen kann.

Der Trade-off: KDE bringt den Parameter Bandbreite mit, braucht mehr Rechenaufwand und ist weniger intuitiv zu erklären – die y-Achse zeigt Dichte statt Häufigkeiten, was ungeübte Leser verwirren kann.

Wann was nutzen

Nutze ein Histogramm für eine schnelle, gut verständliche Zusammenfassung oder wenn dein Publikum Dichteschätzungen nicht gewohnt ist. Nutze KDE, wenn die Form der Verteilung zählt – etwa beim Gruppenvergleich oder wenn du mehrere Modi erkennen möchtest.

Histogramm im Vergleich zu KDE

In der Praxis kombiniert man beides oft: Histogramm für Häufigkeiten, darübergelegt eine KDE für die Form.

Kerndichteschätzung in Python

In Python gibt es mehrere Wege, KDE zu berechnen und zu plotten – je nachdem, ob du eine schnelle Visualisierung brauchst oder die Schätzung selbst detaillierter steuern willst.

KDE mit seaborn visualisieren

Der schnellste Weg zu einem KDE-Plot ist seaborn.kdeplot(). So einfach ist es:

import seaborn as sns
import numpy as np

np.random.seed(42)
scores = np.concatenate([
    np.random.normal(65, 4, 60),
    np.random.normal(80, 3, 40)
])

sns.kdeplot(scores, bw_adjust=1)

KDE mit seaborn

Der Parameter bw_adjust skaliert die automatisch gewählte Bandbreite. Werte unter 1 straffen die Kurve, Werte über 1 glätten stärker. Es ist ein Multiplikator auf die von seaborn intern gewählte Bandbreite – du musst keinen Rohwert setzen.

Die y-Achse zeigt Wahrscheinlichkeitsdichte, nicht Zählwerte. Die Kurve zeigt, wie wahrscheinlich Werte relativ zum Rest der Verteilung sind. Höher bedeutet: mehr Daten konzentrieren sich dort.

KDE mit scipy berechnen

Wenn du die tatsächlichen Dichtewerte brauchst – nicht nur einen Plot –, nutze scipy.stats.gaussian_kde. Das liefert ein aufrufbares Objekt, das du an beliebigen Punkten auswerten kannst.

from scipy.stats import gaussian_kde
import numpy as np
import matplotlib.pyplot as plt

kde = gaussian_kde(scores, bw_method="scott")
x = np.linspace(45, 100, 500)
density = kde(x)

plt.plot(x, density)

bw_method="scott" nutzt Scotts Regel zur automatischen Bandbreitenwahl. Das ist in den meisten Fällen ein guter Standard. Du kannst auch einen Skalar übergeben, um die Bandbreite manuell zu setzen.

KDE mit scipy und matplotlib

Kerndichteschätzung in R

In R ist KDE im Basissystem enthalten. Du brauchst keine Zusatzpakete.

KDE mit density() berechnen

Die Funktion density() nimmt einen numerischen Vektor und gibt ein KDE-Objekt zurück.

set.seed(42)
scores <- c(rnorm(60, mean = 65, sd = 4),
            rnorm(40, mean = 80, sd = 3))

kde <- density(scores, bw = "SJ")

Das Argument bw steuert die Bandbreitenwahl. "SJ" nutzt die Sheather-Jones-Methode, die mit multimodalen Verteilungen besser umgeht als der Standard. Du kannst auch einen numerischen Wert für eine manuelle Bandbreite übergeben.

Das Ergebnis ist ein Listenobjekt mit zwei Schlüsselteilen:

• kde$x: die Punktfolge, an der die Dichte berechnet wurde
• kde$y: die zugehörigen Dichtewerte

Die Kurve plotten

Übergebe das Ergebnis direkt an plot().

plot(kde,
     main = "Exam Score Distribution",
     xlab = "Score",
     ylab = "Density")

KDE in R geplottet

Um die KDE auf ein Histogramm zu legen, nutze zuerst hist() mit freq = FALSE und füge die Kurve mit lines() hinzu.

hist(scores, freq = FALSE, main = "Histogram + KDE", xlab = "Score")
lines(kde, col = "blue", lwd = 2)

Histogramm mit KDE in R

freq = FALSE skaliert das Histogramm auf Dichte, sodass Balken und Kurve dieselbe y-Achse nutzen.

Vorteile und Grenzen von KDE

KDE ist eine ausgesprochen nützliche Visualisierung – aber wie immer gibt es Trade-offs, die du kennen solltest, bevor du Histogramme ersetzt.

Vorteile

Das größte Plus: KDE macht keine Annahmen über die Verteilung deiner Daten. Du musst nicht vorab entscheiden, ob sie normal, exponentiell o. Ä. sind. Die Form kommt aus den Daten selbst. Dadurch ist KDE flexibel genug für multimodale Verteilungen und alles, was nicht in ein Standardmodell passt.

Außerdem ist das Ergebnis eine glatte, stetige Kurve statt einer stufigen Approximation. Muster – mehrere Peaks, lange Tails – springen so eher ins Auge, statt je nach Klassenzahl unterzugehen.

Und weil KDE direkt auf den Rohdaten arbeitet, ohne dass du erst ein Modell fitten musst, ist sie ein guter erster Schritt in jeder explorativen Analyse.

Grenzen

Die Bandbreitenwahl ist die Schwachstelle. Triffst du sie schlecht, folgt die Schätzung entweder dem Rauschen oder bügelt echte Muster glatt. Automatische Verfahren wie Silvermans Regel funktionieren bei annähernd normalen Daten gut, können bei komplexen Verteilungen aber in die Irre führen. Oft lohnt es sich, manuell ein paar Werte zu testen, bevor du dem Ergebnis vertraust.

Leistung kann bei großen Datenmengen zum Thema werden. KDE wertet für jeden Datenpunkt an jeder Stelle die Kernfunktion aus – der Rechenaufwand wächst damit schnell. Für die meisten explorativen Aufgaben ist das kein Problem, bei Hunderttausenden Punkten kann es jedoch langsam werden.

Randeffekte sind ein subtileres Problem. Standard-KDE nimmt an, dass Daten nach beiden Seiten unendlich fortgesetzt werden können. Hat deine Variable eine harte Grenze – etwa Werte, die nicht unter null fallen können –, „leckt“ die Schätzung Dichte jenseits der Grenze und unterschätzt die Kurve am Rand. Es gibt randkorrigierte KDE-Varianten, sie sind aber seltener in Standardbibliotheken implementiert.

Fazit

KDE bietet einen klareren Blick auf die Verteilung deiner Daten als Histogramme. Keine Klassenauswahl, keine parametrischen Annahmen – nur eine glatte Kurve, die zeigt, was wirklich im Datensatz steckt.

Die Bandbreite ist der entscheidende Parameter. Probiere mehrere Werte aus, vergleiche die Kurven, nutze automatische Optionen und prüfe, ob die Schätzung zu deinem Datenverständnis passt, bevor du Schlüsse ziehst.

Am besten entwickelst du ein Gefühl für KDE an echten Daten. Nimm einen dir vertrauten Datensatz, wende KDE an und vergleiche mit einem Histogramm – du wirst staunen, was dir bisher entgangen ist.

Interessiert an Datenvisualisierung? Schau dir unseren Kurs Data Visualization with Seaborn für Python an – oder Data Visualization with ggplot2 für R.