Les percentiles en Python avec NumPy

Un percentile indique la valeur en dessous de laquelle tombe un pourcentage donné d'observations dans votre jeu de données. Si un étudiant se situe au 80e percentile d'un examen, 80 % des notes sont inférieures à la sienne. Les percentiles constituent un pilier de l'analyse exploratoire des données et sont utilisés en machine learning pour la détection des valeurs aberrantes, l'écrêtage des features et la mesure des performances d'un modèle sur des sous-groupes.

Ce chapitre couvre :

• Ce qu'est un percentile et comment il est calculé
• Comment utiliser numpy.percentile() et numpy.quantile()
• Les quartiles et le résumé en cinq chiffres
• L'intervalle interquartile (IQR) pour la détection des valeurs aberrantes
• Les méthodes d'interpolation et leur importance
• Comment trouver le rang percentile d'une valeur spécifique avec SciPy
• Cas d'usage ML pratiques : winsorisation et écrêtage des données

Qu'est-ce qu'un percentile ?

Un percentile divise un jeu de données trié en 100 parties égales. Le P-ième percentile est la valeur en dessous de laquelle se situent P pour cent des données.

Les percentiles sont étroitement liés à la moyenne, la médiane et le mode : le 50e percentile correspond exactement à la médiane.

Percentile vs. quantile

Ces termes sont souvent utilisés de manière interchangeable. Un quantile exprime la même idée en utilisant une fraction de 0 à 1 plutôt qu'un pourcentage de 0 à 100 :

• Le 25e percentile = le quantile 0,25
• Le 75e percentile = le quantile 0,75

NumPy fournit à la fois np.percentile() et np.quantile(). Ils se comportent de façon identique ; choisissez celui qui rend votre code plus lisible.

Calculer un percentile avec NumPy

numpy.percentile(a, q) prend un array a et un percentile q (0–100) et retourne la valeur interpolée à cette position.

Calculer le 75e percentile d'un jeu de données

import numpy as np

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

Passez une liste à q pour calculer plusieurs percentiles en un seul appel — NumPy les retourne dans un array :

Calculer les 25e, 50e et 75e percentiles en une seule fois

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

Utiliser np.quantile()

np.quantile() accepte une fraction (0.0–1.0) au lieu d'un pourcentage :

Utiliser np.quantile() avec un argument fraction

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

Quartiles et résumé en cinq chiffres

Les trois quartiles (Q1, Q2, Q3) associés au minimum et au maximum forment le résumé en cinq chiffres — un instantané compact de la dispersion de tout jeu de données. Vous pouvez calculer les cinq valeurs en un seul appel :

Calculer le résumé en cinq chiffres

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

Le résumé en cinq chiffres est le fondement d'un diagramme en boîte (box plot), que vous pouvez tracer avec Matplotlib (voir Histogrammes Matplotlib pour des techniques de visualisation connexes).

L'intervalle interquartile et la détection des valeurs aberrantes

L'intervalle interquartile (IQR) est la distance entre Q1 et Q3 :

IQR = Q3 − Q1

Il décrit la dispersion des 50 % centraux des données. Comme il ignore les quartiles supérieur et inférieur, l'IQR est robuste aux valeurs extrêmes — ce qui en fait l'outil standard pour la détection des valeurs aberrantes basée sur des règles.

La règle des clôtures de Tukey signale toute valeur supérieure à 1,5 × IQR au-delà de l'un ou l'autre quartile comme une valeur aberrante potentielle :

• Clôture inférieure : Q1 − 1,5 × IQR
• Clôture supérieure : Q3 + 1,5 × IQR

Détecter les valeurs aberrantes avec la méthode IQR

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]

La valeur 80 est bien au-delà de la clôture supérieure de 19,5, elle est donc signalée comme valeur aberrante. La méthode IQR est largement utilisée car elle ne nécessite aucune hypothèse sur la distribution des données sous-jacente.

Méthodes d'interpolation

Lorsque le percentile demandé se situe entre deux points de données, NumPy interpole. Le paramètre method (ajouté dans NumPy 1.22, remplaçant l'ancien paramètre interpolation) contrôle comment cela est effectué.

Comparer les méthodes d'interpolation au 35e percentile

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

Pour la plupart des analyses de données et des travaux ML, la méthode linear par défaut est le bon choix.

Trouver le rang percentile d'une valeur

Parfois, la question est inverse : étant donné une valeur, à quel percentile se trouve-t-elle ? Utilisez scipy.stats.percentileofscore() :

Trouver le rang percentile qu'occupe une valeur spécifique

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

Un score de 30 se situe au 60e percentile — ce qui signifie que 60 % des valeurs dans data sont inférieures ou égales à 30.

Cas d'usage ML pratique : la winsorisation

La winsorisation (aussi appelée clipping) plafonne les valeurs extrêmes à une limite de percentile choisie plutôt que de les supprimer. Cela préserve le nombre de lignes tout en limitant l'influence des valeurs aberrantes sur l'entraînement du modèle.

Écrêter les valeurs aberrantes dans la plage 10e–90e percentile

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]

Les deux valeurs extrêmes — 10 (en dessous de la limite du 10e percentile de 20) et 200 (au-dessus de la limite du 90e percentile de 100) — sont plafonnées à la valeur de clôture. La winsorisation est une étape de prétraitement courante avant l'entraînement de modèles linéaires ou de réseaux de neurones, notamment sur des données financières ou de capteurs où les lectures extrêmes sont fréquentes.

Pour en savoir plus sur les approches de mise à l'échelle des features qui complètent l'écrêtage basé sur les percentiles, consultez le chapitre Scale.

Référence rapide

Sujets connexes

• Moyenne, médiane et mode — mesures de tendance centrale ; le 50e percentile est la médiane.
• Écart type — mesurer la dispersion autour de la moyenne ; complète l'IQR.
• Distribution des données — comprendre l'asymétrie et les valeurs aberrantes avant de choisir des statistiques descriptives.
• Scale — techniques de mise à l'échelle des features pour le prétraitement ML.
• Tutoriel NumPy — compétences NumPy fondamentales utilisées tout au long de ce chapitre.

Conclusion

Les percentiles classent les valeurs au sein d'un jeu de données et révèlent sa forme d'une façon que la moyenne et l'écart type ne peuvent pas. Avec numpy.percentile(), calculer Q1, Q2, Q3 et l'IQR ne prend qu'une seule ligne de Python. En machine learning, les percentiles apparaissent à chaque étape : dans l'analyse exploratoire des données pour repérer les valeurs aberrantes, dans le prétraitement pour winsoriser les valeurs extrêmes, et dans l'évaluation pour comprendre la précision d'un modèle sur l'ensemble de la distribution de vos données. Les maîtriser vous donne un outil fiable et sans hypothèse qui fonctionne sur tout jeu de données quelle que soit sa distribution.