Comment dois-je calculer les percentiles avec python/numpy?

Est-il un moyen pratique de calculer les percentiles pour une séquence ou mono-dimensionnelle tableau numpy?

Je suis à la recherche de quelque chose de similaire à Excel percentile de la fonction.

J'ai regardé dans NumPy de référence pour les statistiques, et ne pouvait pas en trouver un. Tout ce que je pouvais trouver est la médiane (50e percentile), mais pas quelque chose de plus spécifique.

InformationsquelleAutor Uri | 2010-03-03

237

Vous pourriez être intéressé par le SciPy Stats paquet. Il a le percentile de la fonction vous êtes après, et de nombreuses autres statistiques goodies.

percentile() est disponible dans numpy trop.
```
import numpy as np
a = np.array([1,2,3,4,5])
p = np.percentile(a, 50) # return 50th percentile, e.g median.
print p
3.0
```
~~Ce billet m'amène à croire qu'ils ne seront pas intégrer percentile() dans numpy n'importe quand bientôt.~~
- Merci!!!! C'est de là qu'il est caché. J'étais au courant de scipy, mais je suppose que j'ai supposé des choses simples comme les percentiles devrait être intégré dans numpy.
- Maintenant, un percentile de la fonction existe dans numpy: docs.scipy.org/doc/numpy/reference/generated/...
- Vous pouvez l'utiliser comme une fonction d'agrégation ainsi, par exemple, pour calculer le dixième percentile de chaque groupe de la colonne de valeur par l'utilisation de clés, df.groupby('key')[['value']].agg(lambda g: np.percentile(g, 10))
- Notez que SciPy recommande d'utiliser des np.percentile pour NumPy 1,9 et plus
InformationsquelleAutor Jon W
64

Par le façon, il ya un pur Python de mise en œuvre de percentile de la fonction, dans le cas où l'on ne veut pas dépendre de l'scipy. La fonction est copié ci-dessous:
```
## {{{ http://code.activestate.com/recipes/511478/(r1)
import math
import functools

def percentile(N, percent, key=lambda x:x):
    """
    Find the percentile of a list of values.

    @parameter N - is a list of values. Note N MUST BE already sorted.
    @parameter percent - a float value from 0.0 to 1.0.
    @parameter key - optional key function to compute value from each element of N.

    @return - the percentile of the values
    """
    if not N:
        return None
    k = (len(N)-1) * percent
    f = math.floor(k)
    c = math.ceil(k)
    if f == c:
        return key(N[int(k)])
    d0 = key(N[int(f)]) * (c-k)
    d1 = key(N[int(c)]) * (k-f)
    return d0+d1

# median is 50th percentile.
median = functools.partial(percentile, percent=0.5)
## end of http://code.activestate.com/recipes/511478/}}}
```
- Je suis l'auteur de la recette ci-dessus. Un intervenant dans l'ASPN a souligné le code original a un bug. La formule devrait être d0 = clé(N[int(f)]) * (c-k); d1 = clé(N[int(c)]) * (k-f). Il a été corrigé sur les ASPN.
- Yip Tong, j'ai corrigé le bug dans le code
- Comment percentile savoir quoi utiliser pour N? Il n'est pas spécifié dans l'appel de fonction.
- pour ceux qui ne l'ont même pas lu le code, avant de l'utiliser, N doit être triée
- Je suis confus par l'expression lambda. Que fait-il et comment faut-il faire? Je sais ce que lambda de l'expression, donc je ne te demande pas ce que lambda est. Je me demande ce que fait cette expression lambda de faire et comment le faire, étape par étape? Merci!
InformationsquelleAutor Boris Gorelik

import numpy as np
a = [154, 400, 1124, 82, 94, 108]
print np.percentile(a,95) # gives the 95th percentile

InformationsquelleAutor richie

Voici comment le faire sans numpy, en utilisant uniquement python pour calculer le percentile.

import math

def percentile(data, percentile):
    size = len(data)
    return sorted(data)[int(math.ceil((size * percentile) / 100)) - 1]

p5 = percentile(mylist, 5)
p25 = percentile(mylist, 25)
p50 = percentile(mylist, 50)
p75 = percentile(mylist, 75)
p95 = percentile(mylist, 95)

cela ne fonctionnera que si les données sont commandés
Oui, vous avez pour trier la liste avant: maliste=sorted(...)

InformationsquelleAutor Ashkan

10

La définition de percentile j'ai l'habitude de voir s'attend en conséquence, la valeur à partir de la liste fournie ci-dessous qui P % des valeurs sont trouvées... ce qui signifie que le résultat doit être de l'ensemble, pas une interpolation entre les éléments. Pour l'obtenir, vous pouvez utiliser une simple fonction.
```
def percentile(N, P):
    """
    Find the percentile of a list of values

    @parameter N - A list of values.  N must be sorted.
    @parameter P - A float value from 0.0 to 1.0

    @return - The percentile of the values.
    """
    n = int(round(P * len(N) + 0.5))
    return N[n-1]

# A = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
# B = (15, 20, 35, 40, 50)
#
# print percentile(A, P=0.3)
# 4
# print percentile(A, P=0.8)
# 9
# print percentile(B, P=0.3)
# 20
# print percentile(B, P=0.8)
# 50
```
Si vous préférez obtenir la valeur à partir de la liste fournie à ou au-dessous de laquelle P % des valeurs sont ensuite utiliser cette simple modification:
```
def percentile(N, P):
    n = int(round(P * len(N) + 0.5))
    if n > 1:
        return N[n-2]
    else:
        return N[0]
```
Ou avec la simplification proposée par @ijustlovemath:
```
def percentile(N, P):
    n = max(int(round(P * len(N) + 0.5)), 2)
    return N[n-2]
```
- merci, moi aussi j'attends percentile/médiane pour résultat des valeurs réelles à partir des ensembles et non pas des interpolations
- Salut @mpounsett. Merci pour le code supérieur. Pourquoi est-ce que votre percentile toujours le retour des valeurs entières? Le centile de la fonction doit retourner la N-ième centile d'une liste de valeurs, et cela peut être un nombre à virgule de trop. Par exemple, Excel PERCENTILE fonction retourne la suite des percentiles pour le haut de votre exemples: 3.7 = percentile(A, P=0.3),0.82 = percentile(A, P=0.8), 20 = percentile(B, P=0.3), 42 = percentile(B, P=0.8).
- C'est expliqué dans la première phrase. Le plus de définition commune de la notion de percentile, c'est que c'est le numéro de série ci-dessous qui P pour cent des valeurs de la série sont trouvés. Puisque c'est le numéro d'index d'un élément dans une liste, il ne peut pas être un float.
- Cela ne fonctionne pas pour le 0 ième percentile. Elle retourne la valeur maximale. Une solution rapide serait pour envelopper le n = int(...) dans un max(int(...), 1) fonction
- Pour clarifier, voulez-vous dire dans le deuxième exemple? Je obtenir 0 à la place de la valeur maximale. Le bug est en fait dans la clause else.. j'ai imprimé le numéro d'index plutôt que la valeur que j'ai prévu. Habillage de l'affectation des 'n' dans un max() qui permettrait également de régler le problème, mais vous voulez la deuxième valeur de 2, pas 1. Vous pouvez ensuite éliminer l'ensemble des si/d'autre de la structure et il suffit d'imprimer le résultat de N - [n-2]. 0e percentile fonctionne bien dans le premier exemple, le retour de '1' et '15', respectivement.
InformationsquelleAutor mpounsett
7

vérifier scipy.statistiques module:
```
 scipy.stats.scoreatpercentile
```
InformationsquelleAutor Evert

Pour calculer le percentile d'une série, exécutez:

from scipy.stats import rankdata
import numpy as np

def calc_percentile(a, method='min'):
    if isinstance(a, list):
        a = np.asarray(a)
    return rankdata(a, method=method) / float(len(a))

Par exemple:

a = range(20)
print {val: round(percentile, 3) for val, percentile in zip(a, calc_percentile(a))}
>>> {0: 0.05, 1: 0.1, 2: 0.15, 3: 0.2, 4: 0.25, 5: 0.3, 6: 0.35, 7: 0.4, 8: 0.45, 9: 0.5, 10: 0.55, 11: 0.6, 12: 0.65, 13: 0.7, 14: 0.75, 15: 0.8, 16: 0.85, 17: 0.9, 18: 0.95, 19: 1.0}

InformationsquelleAutor Roei Bahumi

De départ Python 3.8, de la bibliothèque standard est livré avec le quantiles fonction dans le cadre de la statistiques module:

from statistics import quantiles

quantiles([1, 2, 3, 4, 5], n=100)
# [0.06, 0.12, 0.18, 0.24, 0.3, 0.36, 0.42, 0.48, 0.54, 0.6, 0.66, 0.72, 0.78, 0.84, 0.9, 0.96, 1.02, 1.08, 1.14, 1.2, 1.26, 1.32, 1.38, 1.44, 1.5, 1.56, 1.62, 1.68, 1.74, 1.8, 1.86, 1.92, 1.98, 2.04, 2.1, 2.16, 2.22, 2.28, 2.34, 2.4, 2.46, 2.52, 2.58, 2.64, 2.7, 2.76, 2.82, 2.88, 2.94, 3.0, 3.06, 3.12, 3.18, 3.24, 3.3, 3.36, 3.42, 3.48, 3.54, 3.6, 3.66, 3.72, 3.78, 3.84, 3.9, 3.96, 4.02, 4.08, 4.14, 4.2, 4.26, 4.32, 4.38, 4.44, 4.5, 4.56, 4.62, 4.68, 4.74, 4.8, 4.86, 4.92, 4.98, 5.04, 5.1, 5.16, 5.22, 5.28, 5.34, 5.4, 5.46, 5.52, 5.58, 5.64, 5.7, 5.76, 5.82, 5.88, 5.94]
quantiles([1, 2, 3, 4, 5], n=100)[49] # 50th percentile (e.g median)
# 3.0

quantiles retourne pour une distribution donnée dist une liste de n - 1 les points de coupure séparant les n quantile intervalles (division de la dist en n en continu des intervalles de probabilité égale):

statistiques.les quantiles(dist, *, n=4, method= "exclusif")

où n, dans notre cas (percentiles) est 100.

InformationsquelleAutor Xavier Guihot

1

Dans le cas où vous besoin d'une réponse à un membre de l'entrée un tableau numpy:

Juste pour ajouter que le centile de la fonction numpy par défaut calcule la sortie d'un linéaire de la moyenne pondérée des deux voisins entrées dans le vecteur d'entrée. Dans certains cas, les gens veulent le retour de l'percentile pour être un véritable élément du vecteur, dans ce cas, à partir de v1.9.0, vous pouvez utiliser le bouton "interpolation" option, avec soit "inférieur", "supérieur" ou "le plus proche".
```
import numpy as np
x=np.random.uniform(10,size=(1000))-5.0

np.percentile(x,70) # 70th percentile

2.075966046220879

np.percentile(x,70,interpolation="nearest")

2.0729677997904314
```
Ce dernier est un véritable entrée dans le vecteur, alors que le premier est une interpolation linéaire de deux vecteurs d'entrées qui sont en bordure de la percentile

InformationsquelleAutor Adrian Tompkins
0

pour une série: permet de décrire les fonctions

supposons que vous avez df avec les colonnes suivantes ventes et id. vous souhaitez calculer les percentiles pour les ventes, alors il fonctionne comme ceci,
```
df['sales'].describe(percentiles = [0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1])

0.0: .0: minimum
1: maximum 
0.1 : 10th percentile and so on
```
InformationsquelleAutor ashwini

Vous devez vous connecter pour publier un commentaire.