Perzentile in Python mit NumPy

Ein Perzentil gibt den Wert an, unterhalb dessen ein bestimmter Prozentsatz der Beobachtungen in einem Datensatz liegt. Erzielt ein Schüler beim 80. Perzentil einer Prüfung, liegen 80 % der Ergebnisse unter seinem Wert. Perzentile sind ein Grundpfeiler der explorativen Datenanalyse und werden im Machine Learning zur Ausreißererkennung, zum Feature-Clipping und zur Berichterstattung über die Modellleistung in Untergruppen eingesetzt.

Dieses Kapitel behandelt:

• Was ein Perzentil ist und wie es berechnet wird
• Wie man numpy.percentile() und numpy.quantile() verwendet
• Quartile und die Fünf-Punkte-Zusammenfassung
• Den Interquartilsabstand (IQR) zur Ausreißererkennung
• Interpolationsmethoden und wann sie relevant sind
• Die Perzentilrangbestimmung eines bestimmten Werts mit SciPy
• Praktische ML-Anwendungen: Winsorisierung und Daten-Clipping

Was ist ein Perzentil?

Ein Perzentil unterteilt einen sortierten Datensatz in 100 gleiche Teile. Das P-te Perzentil ist der Wert, bei oder unterhalb dessen P Prozent der Daten liegen.

Perzentile stehen in engem Zusammenhang mit Mittelwert, Median und Modus: Das 50. Perzentil ist genau der Median.

Perzentil vs. Quantil

Die Begriffe werden häufig synonym verwendet. Ein Quantil drückt denselben Gedanken als Bruch von 0 bis 1 statt als Prozentsatz von 0 bis 100 aus:

• Das 25. Perzentil = das 0,25-Quantil
• Das 75. Perzentil = das 0,75-Quantil

NumPy stellt sowohl np.percentile() als auch np.quantile() bereit. Sie verhalten sich identisch; wählen Sie, was Ihren Code lesbarer macht.

Berechnung eines Perzentils mit NumPy

numpy.percentile(a, q) nimmt ein array-ähnliches a und ein Perzentil q (0–100) entgegen und gibt den interpolierten Wert an dieser Position zurück.

Das 75. Perzentil eines Datensatzes berechnen

import numpy as np

data = [10, 20, 30, 40, 50]
result = np.percentile(data, 75)
print(result)  # Output: 40.0

Übergeben Sie q eine Liste, um mehrere Perzentile in einem Aufruf zu berechnen — NumPy gibt sie als array zurück:

Das 25., 50. und 75. Perzentil auf einmal berechnen

import numpy as np

data = [10, 20, 30, 40, 50]
p25, p50, p75 = np.percentile(data, [25, 50, 75])
print(f'Q1 = {p25}')  # Output: Q1 = 20.0
print(f'Q2 = {p50}')  # Output: Q2 = 30.0
print(f'Q3 = {p75}')  # Output: Q3 = 40.0

Verwendung von np.quantile()

np.quantile() akzeptiert einen Bruch (0,0–1,0) anstelle eines Prozentsatzes:

np.quantile() mit einem Bruchargument verwenden

import numpy as np

data = [10, 20, 30, 40, 50]
q1 = np.quantile(data, 0.25)
q3 = np.quantile(data, 0.75)
print(f'Q1 = {q1}')  # Output: Q1 = 20.0
print(f'Q3 = {q3}')  # Output: Q3 = 40.0

Quartile und die Fünf-Punkte-Zusammenfassung

Die drei Quartile (Q1, Q2, Q3) bilden zusammen mit Minimum und Maximum die Fünf-Punkte-Zusammenfassung — eine kompakte Übersicht der Streuung eines beliebigen Datensatzes. Alle fünf Werte lassen sich in einem einzigen Aufruf berechnen:

Die Fünf-Punkte-Zusammenfassung berechnen

import numpy as np

data = [10, 20, 30, 40, 50]
minimum, q1, median, q3, maximum = np.percentile(data, [0, 25, 50, 75, 100])

print(f'Min    = {minimum}')   # Output: Min    = 10.0
print(f'Q1     = {q1}')        # Output: Q1     = 20.0
print(f'Median = {median}')    # Output: Median = 30.0
print(f'Q3     = {q3}')        # Output: Q3     = 40.0
print(f'Max    = {maximum}')   # Output: Max    = 50.0

Die Fünf-Punkte-Zusammenfassung ist die Grundlage eines Boxplots, den Sie mit Matplotlib zeichnen können (verwandte Visualisierungstechniken finden Sie unter Matplotlib Histograms).

Interquartilsabstand und Ausreißererkennung

Der Interquartilsabstand (IQR) ist die Distanz zwischen Q1 und Q3:

IQR = Q3 − Q1

Er beschreibt die Streuung der mittleren 50 % der Daten. Da die oberen und unteren Viertel ignoriert werden, ist der IQR robust gegenüber Extremwerten — was ihn zum Standardwerkzeug für regelbasierte Ausreißererkennung macht.

Die Tukey-Grenz-Regel kennzeichnet jeden Wert, der mehr als das 1,5-fache des IQR über ein Quartil hinausgeht, als potenziellen Ausreißer:

• Untere Grenze: Q1 − 1,5 × IQR
• Obere Grenze: Q3 + 1,5 × IQR

Ausreißer mit der IQR-Methode erkennen

import numpy as np

data = [5, 7, 8, 9, 10, 11, 12, 13, 14, 80]

q1 = np.percentile(data, 25)
q3 = np.percentile(data, 75)
iqr = q3 - q1

lower_fence = q1 - 1.5 * iqr
upper_fence = q3 + 1.5 * iqr

outliers = [x for x in data if x < lower_fence or x > upper_fence]

print(f'Q1 = {q1}, Q3 = {q3}, IQR = {iqr}')
# Output: Q1 = 8.25, Q3 = 12.75, IQR = 4.5

print(f'Lower fence = {lower_fence}, Upper fence = {upper_fence}')
# Output: Lower fence = 1.5, Upper fence = 19.5

print(f'Outliers: {outliers}')
# Output: Outliers: [80]

Der Wert 80 liegt weit oberhalb der oberen Grenze von 19,5 und wird daher als Ausreißer markiert. Die IQR-Methode wird häufig verwendet, weil sie keine Annahmen über die zugrundeliegende Datenverteilung erfordert.

Interpolationsmethoden

Wenn das angeforderte Perzentil zwischen zwei Datenpunkten liegt, interpoliert NumPy. Der Parameter method (in NumPy 1.22 hinzugefügt, ersetzt den älteren Parameter interpolation) steuert, wie dies geschieht.

Interpolationsmethoden beim 35. Perzentil vergleichen

import numpy as np

data = [10, 20, 30, 40, 50]
# The 35th percentile falls between 20 (index 1) and 30 (index 2)

print(np.percentile(data, 35, method='linear'))    # Output: 24.0  (default)
print(np.percentile(data, 35, method='lower'))     # Output: 20
print(np.percentile(data, 35, method='higher'))    # Output: 30
print(np.percentile(data, 35, method='midpoint'))  # Output: 25.0
print(np.percentile(data, 35, method='nearest'))   # Output: 20

Für die meisten Datenanalysen und ML-Aufgaben ist die Standardmethode linear die richtige Wahl.

Perzentilrang eines Werts bestimmen

Manchmal stellt sich die umgekehrte Frage: Welches Perzentil nimmt ein gegebener Wert ein? Verwenden Sie hierfür scipy.stats.percentileofscore():

Den Perzentilrang eines bestimmten Werts ermitteln

from scipy import stats

data = [10, 20, 30, 40, 50]

rank = stats.percentileofscore(data, 30)
print(rank)  # Output: 60.0

rank_of_25 = stats.percentileofscore(data, 25)
print(rank_of_25)  # Output: 40.0

Ein Wert von 30 befindet sich beim 60. Perzentil — das bedeutet, 60 % der Werte in data liegen bei oder unter 30.

Praktische ML-Anwendung: Winsorisierung

Winsorisierung (auch Clipping genannt) begrenzt Extremwerte auf eine gewählte Perzentilgrenze, anstatt sie zu entfernen. Dadurch bleibt die Zeilenanzahl erhalten, während der Einfluss von Ausreißern auf das Modelltraining begrenzt wird.

Ausreißer auf den Bereich des 10. bis 90. Perzentils begrenzen

import numpy as np

data = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 200]

lower = np.percentile(data, 10)
upper = np.percentile(data, 90)

clipped = np.clip(data, lower, upper)

print(f'Lower bound (10th): {lower}')  # Output: Lower bound (10th): 20.0
print(f'Upper bound (90th): {upper}')  # Output: Upper bound (90th): 100.0
print('Clipped:', list(clipped))
# Output: Clipped: [20.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0, 100.0]

Beide Extremwerte — 10 (unterhalb der 10. Perzentilgrenze von 20) und 200 (oberhalb der 90. Perzentilgrenze von 100) — werden auf den Grenzwert begrenzt. Winsorisierung ist ein verbreiteter Vorverarbeitungsschritt vor dem Training linearer Modelle oder neuronaler Netze, insbesondere bei Finanz- oder Sensordaten, bei denen extreme Messwerte häufig vorkommen.

Weitere Informationen zu Feature-Skalierungsansätzen, die das perzentilbasierte Clipping ergänzen, finden Sie im Kapitel Scale.

Schnellreferenz

Verwandte Themen

• Mittelwert, Median und Modus — Maße der zentralen Tendenz; das 50. Perzentil ist der Median.
• Standardabweichung — Streuung um den Mittelwert messen; ergänzt den IQR.
• Datenverteilung — Schiefe und Ausreißer verstehen, bevor Zusammenfassungsstatistiken gewählt werden.
• Scale — Feature-Skalierungstechniken für die ML-Vorverarbeitung.
• NumPy Tutorial — grundlegende NumPy-Kenntnisse, die in diesem Kapitel verwendet werden.

Fazit

Perzentile ordnen Werte in einem Datensatz und legen dessen Form offen, auf eine Weise, die Mittelwert und Standardabweichung nicht können. Mit numpy.percentile() lassen sich Q1, Q2, Q3 und IQR in einer einzigen Python-Zeile berechnen. Im Machine Learning tauchen Perzentile in jeder Phase auf: in der explorativen Datenanalyse zum Aufspüren von Ausreißern, bei der Vorverarbeitung zur Winsorisierung von Extremwerten und in der Auswertung, um die Modellgenauigkeit über die Verteilung der Daten hinweg zu verstehen. Wer sie beherrscht, verfügt über ein zuverlässiges, annahmenfreies Werkzeug, das auf jeden Datensatz unabhängig von seiner Verteilung anwendbar ist.