Kärntäthetsestimering: Från teori till praktik

Har du någon gång försökt visualisera en fördelning, bara för att få ett histogram som byter form varje gång du ändrar storleken på klasserna?

Så här brukar det gå till. Du väljer 10 klasser och ser en jämn kurva. Sedan byter du till 30 och det finns flera toppar. Datan är densamma, men olika antal klasser ger olika tolkningar. Det är det största problemet med histogram: de visar inte fördelningen, de visar en variant av den. Och den varianten påverkas av en parameter du själv väljer godtyckligt.

KDE tar en annan väg. I stället för att dela upp data i klasser placerar den en liten, mjuk kurva på varje datapunkt och summerar dem. Det ger en enda, kontinuerlig uppskattning av den underliggande fördelningen.

I den här artikeln får du intuitionen bakom KDE, en genomgång av formeln, en förklaring av hur bandbredden styr jämnheten, samt praktiska exempel i Python och R.

Är du ny på histogram? Här är en heltäckande guide till frekvenshistogram som får dig att komma igång.

Vad är kärntäthetsestimering?

Kärntäthetsestimering är en icke-parametrisk metod för att uppskatta ett datasets sannolikhetstäthetsfunktion.

Det icke-parametriska är vad som gör den annorlunda.

Med parametriska metoder antar du att dina data följer en specifik fördelning – normal, exponentiell – och anpassar sedan parametrar för att passa den. Om antagandet är fel, är modellen fel. KDE gör inga sådana antaganden. Den låter datan tala för sig själv och bygger en uppskattning av den underliggande fördelningen direkt från observationerna.

Resultatet är en jämn kurva som visar var värden sannolikt hamnar – och hur sannolikt det är. Höga punkter på kurvan betyder täta områden. Låga punkter betyder glesa.

Varför använda kärntäthetsestimering?

Histogram är standardverktyget för att visualisera fördelningar, men de har ett problem: formen du ser beror på hur många klasser du väljer. Och det antalet bestämmer du. Två personer kan titta på samma dataset och dra helt olika slutsatser bara genom att välja olika antal klasser.

Med KDE tvingar du inte in data i klasser; den producerar en jämn, kontinuerlig kurva som inte ändras baserat på en godtycklig parameter du ställt in från början.

Det gör den användbar för ett par saker:

• Visualisera den övergripande formen på en fördelning utan bias från klassbredd
• Upptäcka mönster som flera toppar, skevhet eller tunga svansar
• Jämföra fördelningar mellan grupper i samma diagram
• Få en renare bild av dina data före modellering

Intuitionen bakom KDE

Du tar varje datapunkt och placerar en liten, jämn kurva ovanpå den. Den kurvan kallas en kärna. Sedan summerar du helt enkelt alla de individuella kurvorna till en.

Du får en enda jämn kurva som visar tätheten i dina data. Där punkter klustrar överlappar flera kärnor och staplas, så kurvan stiger. Där data är gles överlappar kärnorna knappt och kurvan förblir låg. Varje punkt bidrar lika till den slutliga uppskattningen.

Tänk dig att du registrerade slutbetyg på en tentamen för en klass. I stället för att lägga dem i ett histogram placerar KDE en liten, jämn kurva på varje poäng. Där poäng klustrar – säg runt 70–75 – staplas kurvorna och uppskattningen stiger. En enskild student som fick 95 ger bara en liten puckel i svansen.

Visualiseringen nedan visar precis detta. De flesta eleverna presterade runt medelvärdet, och en elev presterade mycket högre:

KDE visualiserad

Formeln för kärntäthetsestimering

KDE-formeln ser mer skrämmande ut än den är.

KDE-formel

Det här betyder de olika delarna:

• n är antalet datapunkter

• x_i är de enskilda datapunkterna i ditt dataset

• K är kärnfunktionen – den mjuka kurvan som placeras på varje punkt

• h är bandbredden – styr hur bred varje kärna är

• x är punkten där du utvärderar tätheten

Enkelt uttryckt säger formeln: för en godtycklig punkt x, titta på hur nära varje datapunkt x_i ligger den, vik närheten med hjälp av kärnfunktionen K, och ta genomsnittet över alla n punkter. Gör detta för varje x längs intervallet och du får hela täthetskurvan.

Bandbredden h ligger i nämnaren i bråket inuti K. En mindre h gör kärnan smalare, så bara mycket nära punkter påverkar uppskattningen. En större h sprider påverkan vidare. Mer om detta senare i artikeln.

Vad är en kärnfunktion?

Kärnan är den jämna kurvan du placerar på varje datapunkt. Den definierar hur den punktens påverkan sprids till grannar.

Varje kärna är centrerad på en datapunkt och tilldelar vikter baserat på avstånd. Punkter nära centrum får hög vikt. Punkter långt bort får låg eller ingen vikt. Den exakta formen på vikten beror på vilken kärna du väljer.

Det finns tre vanliga val:

• Gaussisk: Klockkurvan. Den ger vikt åt varje punkt i datasetet, och påverkan avtar med avståndet. Detta är standard i de flesta bibliotek och fungerar bra i praktiken
• Uniform: En platt rektangel. Varje punkt inom ett fast avstånd får lika vikt, och allt utanför får ingen. Enkelt, men ger mindre jämna uppskattningar
• Epanechnikov: En parabolisk form som är matematiskt optimal i termer av medelkvadratfel. Den är mer effektiv än gaussisk men gör sällan någon synlig skillnad i praktiken.

I de flesta fall spelar valet av kärna liten roll. Två olika kärnor tillämpade på samma data med samma bandbredd ger kurvor som är nästan identiska. Det som spelar mycket större roll är bandbredden – och det tittar vi på härnäst.

Bandbreddens roll i KDE

Bandbredd är den enskilda parametern som har störst påverkan på ditt KDE-resultat, till och med mer än vilken kärna du väljer.

Den styr hur bred varje kärna är. En smal kärna tar bara in påverkan från närliggande punkter. En bred kärna sprider påverkan över ett mycket större intervall. Resultatet blir antingen en kurva som följer datan nära eller en som jämnar ut den.

Liten bandbredd

En liten bandbredd gör varje kärna tajt och smal. Uppskattningen reagerar kraftigt på varje datapunkt, vilket innebär att den fångar upp verklig struktur i datan, men också brus.

I praktiken ser det ut som en taggig kurva med flera små toppar. Vissa av topparna visar verkliga kluster i dina data. Andra är bara artefakter av för lite utjämning. Det är svårt att avgöra vad som är vad, och det är problemet.

KDE med liten bandbredd

Stor bandbredd

En stor bandbredd gör varje kärna bred. Närliggande kärnor överlappar och den slutliga kurvan blir jämn.

Om den blir för jämn börjar du tappa verklig struktur. Två distinkta kluster kan suddas ihop till en enda kurva. En fördelning med tung svans kan se symmetrisk ut. Visualiseringen kan dölja saker för dig.

KDE med stor bandbredd

Hitta rätt bandbredd

Det finns ingen universellt korrekt bandbredd. Målet är att hitta ett värde som är tillräckligt jämnt för att filtrera bort brus men inte så jämnt att det suddar ut verkliga mönster.

De flesta bibliotek gör detta med automatiska metoder för bandbreddsval. Silvermans tumregel är den vanligaste. Den väljer bandbredd baserat på stickprovsstorleken och standardavvikelsen i dina data. Den fungerar bra för ungefär normala fördelningar men kan överjämna multimodala.

Om du är osäker, prova ett par bandbreddsvärden och jämför kurvorna. Skillnaderna kommer att säga mycket om dina data.

KDE vs. histogram

Både histogram och KDE visar fördelningen i dina data – men de gör det på väldigt olika sätt.

Histogram

Ett histogram delar upp dina data i diskreta klasser och räknar hur många punkter som hamnar i varje. Det är snabbt, intuitivt och lätt att förklara för en icke-teknisk publik.

Problemet är känsligheten för antal klasser. Om du ändrar antalet klasser ändras formen. Det finns inget objektivt korrekt antal, vilket innebär att två personer kan titta på samma data och dra olika slutsatser bara utifrån det valet.

Histogram ger också en trappstegsformad, icke-kontinuerlig form. Det duger för en snabb överblick, men kan dölja den sanna underliggande fördelningen.

KDE

KDE ger dig en jämn, kontinuerlig kurva utan inblandning av klasser. Den är bättre på att visa den faktiska formen på en fördelning – sådant som skevhet, flera toppar eller tunga svansar som ett histogram kan missa eller feltolka beroende på klassval.

Nackdelen är att KDE introducerar en egen parameter – bandbredd – och kräver mer beräkning. Den är också mindre intuitiv att förklara, eftersom y-axeln visar sannolikhetstäthet, inte antal, vilket kan förvirra läsare som inte är bekanta med begreppet.

När du ska använda vilken

Använd ett histogram när du behöver en snabb, lättolkad sammanfattning av dina data eller när din publik inte är bekant med täthetsuppskattningar. Använd KDE när fördelningens form spelar roll – till exempel när du jämför grupper eller försöker upptäcka flera lägen i dina data.

Histogram jämfört med KDE

I praktiken används de ofta tillsammans: ett histogram för antalen, en KDE-kurva ovanpå för formen.

Kärntäthetsestimering i Python

Python ger dig ett par sätt att beräkna och plotta KDE, beroende på om du behöver ett snabbt diagram eller mer kontroll över själva uppskattningen.

Visualisera KDE med seaborn

Det snabbaste sättet att få en KDE-plott är seaborn.kdeplot(). Det här är allt som krävs:

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 med seaborn

Parametern bw_adjust skalar den automatiskt valda bandbredden. Värden under 1 skärper kurvan, värden över 1 jämnar ut den. Det är en multiplikator ovanpå den bandbredd seaborn väljer internt, så du behöver inte sätta ett rått bandbreddsvärde själv.

Y-axeln visar sannolikhetstäthet, inte antal. Kurvan berättar hur sannolikt ett värde är i förhållande till resten av fördelningen. Högre betyder att mer data är koncentrerad där.

Beräkna KDE med scipy

Om du behöver de faktiska täthetsvärdena – inte bara en plott – använd scipy.stats.gaussian_kde. Det ger dig ett anropbart objekt som du kan utvärdera var som helst.

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" använder Scotts regel för att automatiskt välja bandbredd. Det är ett bra standardval i de flesta fall. Du kan också skicka in en skalar för att sätta bandbredd manuellt.

KDE med scipy och matplotlib

Kärntäthetsestimering i R

I R är KDE inbyggt i språket. Du behöver inga extra paket.

Beräkna KDE med density()

Funktionen density() tar en numerisk vektor och returnerar ett KDE-objekt.

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

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

Argumentet bw styr bandbreddsvalet. "SJ" använder Sheather–Jones-metoden, som hanterar multimodala fördelningar bättre än standarden. Du kan också ange ett numeriskt värde för att sätta bandbredden manuellt.

Resultatet är ett listobjekt med två nyckelkomponenter:

• kde$x: sekvensen av punkter där tätheten utvärderades
• kde$y: de motsvarande täthetsvärdena

Plotta kurvan

Skicka bara resultatet direkt till plot().

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

KDE plottad i R

För att lägga KDE ovanpå ett histogram, använd hist() med freq = FALSE först, lägg sedan till kurvan med lines().

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

Histogram med KDE i R

freq = FALSE skalar histogrammet till täthet så att både staplarna och kurvan delar samma y-axel.

Fördelar och begränsningar med KDE

KDE är ett genuint användbart visuellt verktyg, men som allt annat kommer det med avvägningar som är värda att känna till innan du använder det som ersättning för histogram.

Fördelar

Den största fördelen är att KDE inte gör några antaganden om dina datas fördelning. Du behöver inte bestämma i förväg om dina data är normala, exponentiella eller något annat. Formen kommer från själva datan, vilket gör KDE tillräckligt flexibelt för att hantera multimodala fördelningar och annat som inte passar en standardparametrisk form.

Resultatet är också en jämn, kontinuerlig kurva snarare än en trappstegsapproximation. Det gör det lättare att se mönster – sådant som flera toppar eller långa svansar – som ett histogram kan dölja beroende på klassval.

Och eftersom KDE fungerar på rådata utan att du först behöver anpassa en modell är det ett bra första steg i all explorativ analys.

Begränsningar

Bandbreddsvalet är den största svagheten. Om du väljer fel jagar uppskattningen antingen brus eller jämnar ut verkliga mönster i datan. Automatiska metoder som Silvermans regel fungerar bra för ungefär normal data, men kan vilseleda vid komplexa fördelningar. Du behöver ofta manuellt kontrollera ett par bandbreddsvärden innan du litar på resultatet.

Prestanda kan bli ett problem i stor skala. KDE utvärderar en kärnfunktion för varje datapunkt vid varje utvärderingsposition, vilket innebär att beräkningen växer snabbt när ditt dataset blir större. För de flesta explorativa syften är detta inget problem, men det kan gå långsamt på dataset med hundratusentals punkter.

Rand­effekter är ett mer subtilt problem. Standard-KDE antar att data kan sträcka sig oändligt i båda riktningarna. När dina data har en hård gräns – som värden som inte kan gå under noll – läcker uppskattningen sannolikhetsmassa förbi den gränsen, vilket ger en kurva som är konstlat låg nära kanten. Det finns randkorrigerade varianter av KDE, men de är mer sällan implementerade i standardbibliotek.

Slutsats

KDE ger dig ett renare sätt att titta på dina datas fördelning än histogram. Det finns inga klassval och inga parametriska antaganden – bara en jämn kurva som visar vad som faktiskt finns i ditt dataset.

Bandbredd är den enda parametern som verkligen spelar roll. Prova ett par värden, jämför kurvorna, använd automatiska alternativ och säkerställ att uppskattningen stämmer med det du vet om dina data innan du drar slutsatser.

Det bästa sättet att bygga intuition för KDE är att köra den på riktig data. Välj ett dataset du redan är bekant med, tillämpa KDE och jämför med ett histogram för att se vad du har missat.

Intresserad av datavisualisering? Kolla in vår kurs om Data Visualization with Seaborn om du använder Python, eller Data Visualization with ggplot2 om du använder R.