Pythonic moyen de détection de valeurs aberrantes dans une dimensions de l'observation de données

Pour les données fournies, je veux mettre les valeurs aberrantes (défini par 95% confidense niveau ou 95% quantile de la fonction ou de ce qui est nécessaire) comme des valeurs nan. Voici mes données et le code que j'utilise actuellement. Je serais heureux si quelqu'un pouvait m'expliquer davantage.

import numpy as np, matplotlib.pyplot as plt

data = np.random.rand(1000)+5.0

plt.plot(data)
plt.xlabel('observation number')
plt.ylabel('recorded value')
plt.show()

Vous savez que vos données mieux, mais je pense que Winsorising de mieux que de suppression. En outre, si l'ensemble de ces données que nan, et puis vous avez à gérer cela. Jetez un oeil à np.percentile de la fonction.
Pour info: Détecter et exclure les valeurs aberrantes dans les Pandas dataframe

InformationsquelleAutor | 2014-03-12

114

Le problème avec l'aide de percentile est que les points identifiés comme des valeurs aberrantes est une fonction de la taille de votre échantillon.

Il y a un grand nombre de moyens de test pour les valeurs aberrantes, et vous devriez réfléchir à la façon dont vous les classer. Idéalement, vous devriez utiliser une information a priori (par exemple, "rien au-dessus/en-dessous de cette valeur est irréaliste parce que...")

Toutefois, une commune, pas trop déraisonnable aberrantes test est de supprimer des points en fonction de leur "median absolute deviation".

Voici une implémentation pour la N-dimensionnelle de cas (à partir de quelques lignes de codes pour un papier ici: https://github.com/joferkington/oost_paper_code/blob/master/utilities.py):
```
def is_outlier(points, thresh=3.5):
    """
    Returns a boolean array with True if points are outliers and False 
    otherwise.

    Parameters:
    -----------
        points : An numobservations by numdimensions array of observations
        thresh : The modified z-score to use as a threshold. Observations with
            a modified z-score (based on the median absolute deviation) greater
            than this value will be classified as outliers.

    Returns:
    --------
        mask : A numobservations-length boolean array.

    References:
    ----------
        Boris Iglewicz and David Hoaglin (1993), "Volume 16: How to Detect and
        Handle Outliers", The ASQC Basic References in Quality Control:
        Statistical Techniques, Edward F. Mykytka, Ph.D., Editor. 
    """
    if len(points.shape) == 1:
        points = points[:,None]
    median = np.median(points, axis=0)
    diff = np.sum((points - median)**2, axis=-1)
    diff = np.sqrt(diff)
    med_abs_deviation = np.median(diff)

    modified_z_score = 0.6745 * diff / med_abs_deviation

    return modified_z_score > thresh
```
Ceci est très similaire à une de mes précédentes réponses, mais je voulais illustrer la taille de l'échantillon effets en détail.

Comparons un percentile basée sur des valeurs aberrantes test (similaire à @CTZhu réponse) avec une médiane de-absolu-de déviation (MAD) de test pour différentes tailles d'échantillon:
```
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
def main():
for num in [10, 50, 100, 1000]:
# Generate some data
x = np.random.normal(0, 0.5, num-3)
# Add three outliers...
x = np.r_[x, -3, -10, 12]
plot(x)
plt.show()
def mad_based_outlier(points, thresh=3.5):
if len(points.shape) == 1:
points = points[:,None]
median = np.median(points, axis=0)
diff = np.sum((points - median)**2, axis=-1)
diff = np.sqrt(diff)
med_abs_deviation = np.median(diff)
modified_z_score = 0.6745 * diff / med_abs_deviation
return modified_z_score > thresh
def percentile_based_outlier(data, threshold=95):
diff = (100 - threshold) / 2.0
minval, maxval = np.percentile(data, [diff, 100 - diff])
return (data < minval) | (data > maxval)
def plot(x):
fig, axes = plt.subplots(nrows=2)
for ax, func in zip(axes, [percentile_based_outlier, mad_based_outlier]):
sns.distplot(x, ax=ax, rug=True, hist=False)
outliers = x[func(x)]
ax.plot(outliers, np.zeros_like(outliers), 'ro', clip_on=False)
kwargs = dict(y=0.95, x=0.05, ha='left', va='top')
axes[0].set_title('Percentile-based Outliers', **kwargs)
axes[1].set_title('MAD-based Outliers', **kwargs)
fig.suptitle('Comparing Outlier Tests with n={}'.format(len(x)), size=14)
main()
```
Avis que le FOU à base de classificateur fonctionne correctement indépendamment de l'échantillon de la taille, tandis que le percentile en fonction de classificateur de classe le plus de points, plus la taille de l'échantillon est, indépendamment de si oui ou non ils sont en fait des valeurs aberrantes.
- Joe,+1,C'est une excellente réponse. Bien que je me demande, si l'OP de données toujours uniformément perturbé (random.rand()), ou pouvez toujours suivre certaines autres distributions, la plupart du temps. Si les données sont toujours uniformément dérangé, je ne suis pas sûr à propos de l'utilisation MAD.
- Bon point, surtout si l'OP de données est, disons, connectez-vous normalement distribuées. Pour vaguement distributions symétriques, les écarts par rapport à une distribution normale ne devrait pas trop, mais fortement asymétrique des distributions comme suivant une loi lognormale, MAD n'est pas un bon choix. (Bien que vous puissiez toujours l'appliquer dans le journal de l'espace pour obtenir autour de cela.) Tout cela sert juste à souligner que vous devriez mettre une certaine pensée dans ce que aberrantes test que vous choisissez.
- par où vous êtes à l'aide de la médiane, mais diff est calculé de la norme L2 ( **2 ); la médiane est la valeur qui minimise la norme L1, alors que dans L2 norme "moyenne" est le centre; je m'attendais à ce que si vous commencez avec une médiane de séjour en norme L1. avez-vous des raisons **2 fonctionnerait mieux que des valeurs absolues dans le calcul de diff?
- Maintenant que vous le dites, il semble très étrange d'utiliser la norme L2 pour cela (et ce n'est pas, en fait, la médiane, l'écart absolu, à l'époque). Si je me souviens bien, j'ai vaguement basé sur un couple de mises en œuvre dans diverses autres langues qui a fait la même chose. Je vais avoir besoin de prendre un autre regard en arrière à l'original de référence. Si je viens de changer les choses pour la norme L1, il ne fonctionne pas correctement, en tout cas...
- Kingston portant je vous Remercie beaucoup dans l'acte. Pourriez-vous svp m'expliquer si je peux utiliser la méthode fournie dans le lien suivant pour la détection des valeurs aberrantes?stats.stackexchange.com/questions/28593/... C'est juste pour des fins de comparaison.
- dans votre mad en fonction de détection de valeurs aberrantes, comment avez-vous définissez les valeurs 0.6745 et 3,5 pour quel but, comment déterminer ces valeurs? il est très déroutant
- Vous aurez à voir la référence. Ils sont dérivés. Fondamentalement, la 0.6745 est de rendre les valeurs à peu près équivalent en unités d'écarts-types et la 3.5 est le seuil recommandé (à peu près équivalent à 3,5 écarts-types). Désolé, je n'ai pas eu la réponse à beaucoup ces derniers temps!
- Je n'ai qu'une copie de la référence, mais il y a une bonne discussion ici: habcam.whoi.edu/HabCamData/HAB/processed/...
- Ainsi, ces valeurs devraient être obtenus à partir de nos données, plutôt que d'attribuer 0.6745 et 3,5 pour les données, droit?
- Eh bien, la 0.6745 doit être constante, quel que soit le jeu de données. Vous pouvez ajuster la 3.5 en fonction de la distance que vous attendez les valeurs aberrantes à être pour le reste si les données.
- La modification de la valeur Z calculée en fonction mad_based_outlier semble différent de l'original en nist.gov. Le med_abs_deviation calculé dans le code est différent de la définition de la moyenne de l'écart absolu.
- Comparatif des parcelles sont TRÈS utiles pour avoir une idée de la façon dont au moins deux de ces méthodes diffèrent. Merci pour gong à travers l'effort de les créer.
- Il y a quelque chose que je ne comprends pas dans is_outlier. diff est une valeur unique (à cause de la np.somme) - ensuite, vous utilisez np.médiane sur les diff -- c'est que faute de frappe? Pourquoi voulez-vous calculer le np.la médiane d'une valeur unique. Suis-je manqué quelque chose?
- Avis de la axis kwarg à np.sum - Ce n'est pas de retourner une seule valeur, c'est le retour de la somme sur le dernier axe, qui est un tableau. Par exemple: np.sum(np.ones((3, 4)), axis=-1) rendements array([4, 4, 4]).
- Mon mauvais, .. j'ai passé un (L, ) tableau numpy au lieu de (L, 1). Je n'ai pas lu les docs Merci.
- Cette réponse (et du code) échoue si plus de la moitié des articles dans le jeu ont la même valeur, puisque la médiane(points - médiane(points)) sera égal à zéro, la division par zéro entraînera dans tous les np.inf.
- Alternative miroir pour @JoeKington 's PDF de papier pdf-archive.com/2016/07/29/outlier-methods-external/...
- Je vais avoir du mal à obtenir votre MAD de mise en œuvre de correspondre avec MAD à partir de statsmodel.robust.mad ici. Êtes-vous au courant de divergence?
- Une grande Réponse, mais d'où vient la valeur : 0.6745 vient?
- Pourriez-vous nous expliquer pourquoi vous êtes en utilisant np.sqrt(diff) avant le calcul de la médiane de diff?
- J'ai compris pourquoi. Il en fait, d'essayer de faire abs(points - median) mais il a compliqué les choses!
InformationsquelleAutor Joe Kington
15

De détection de valeurs aberrantes dans un dimensionnelle des données dépend de sa distribution

1- Distribution Normale :
1. Les valeurs de données sont presque également répartis sur toute la plage :
  Dans ce cas, vous pouvez facilement utiliser toutes les méthodes qui incluent veux dire ,comme l'intervalle de confiance de 3 ou de 2 déviations standard(ic à 95% ou à 99,7%) en conséquence pour une distribution normale des données (théorème de la limite centrale et de l'échantillonnage et de la distribution de la moyenne d'échantillon).Je est une méthode très efficace.
  Expliqué dans la Khan Academy, des statistiques et des Probabilités d'échantillonnage de la distribution de la bibliothèque.
Un autre moyen est l'intervalle de prédiction si vous voulez de l'intervalle de confiance de points de données plutôt que de les dire.
1. Les valeurs de données sont distribuées de façon aléatoire sur une plage:
  signifie peut-être pas une juste représentation des données, car la moyenne est facilement influencé par les valeurs aberrantes (très petites ou les grandes valeurs du jeu de données qui ne sont pas typiques)
  La médiane est une autre façon de mesurer le centre numérique de l'ensemble de données.
  
  Median Absolute deviation - une méthode qui mesure la distance de tous les points de la médiane en termes de distance médiane
  http://www.itl.nist.gov/div898/handbook/eda/section3/eda35h.htm - a une bonne explication, comme expliqué dans Joe kingston portant la réponse ci-dessus
2 - Distribution Symétrique : Nouveau Median Absolute Deviation est une bonne méthode si le z-score de calcul et le seuil est modifié en conséquence

Explication :
http://eurekastatistics.com/using-the-median-absolute-deviation-to-find-outliers/

3 - Distribution Asymétrique : Double MAD - Double Median Absolute Deviation
Dans l'explication ci-dessus lien

Attacher mon code python pour la référence :
```
 def is_outlier_doubleMAD(self,points):
"""
FOR ASSYMMETRIC DISTRIBUTION
Returns : filtered array excluding the outliers
Parameters : the actual data Points array
Calculates median to divide data into 2 halves.(skew conditions handled)
Then those two halves are treated as separate data with calculation same as for symmetric distribution.(first answer) 
Only difference being , the thresholds are now the median distance of the right and left median with the actual data median
"""
if len(points.shape) == 1:
points = points[:,None]
median = np.median(points, axis=0)
medianIndex = (points.size/2)
leftData = np.copy(points[0:medianIndex])
rightData = np.copy(points[medianIndex:points.size])
median1 = np.median(leftData, axis=0)
diff1 = np.sum((leftData - median1)**2, axis=-1)
diff1 = np.sqrt(diff1)
median2 = np.median(rightData, axis=0)
diff2 = np.sum((rightData - median2)**2, axis=-1)
diff2 = np.sqrt(diff2)
med_abs_deviation1 = max(np.median(diff1),0.000001)
med_abs_deviation2 = max(np.median(diff2),0.000001)
threshold1 = ((median-median1)/med_abs_deviation1)*3
threshold2 = ((median2-median)/med_abs_deviation2)*3
#if any threshold is 0 -> no outliers
if threshold1==0:
threshold1 = sys.maxint
if threshold2==0:
threshold2 = sys.maxint
#multiplied by a factor so that only the outermost points are removed
modified_z_score1 = 0.6745 * diff1 / med_abs_deviation1
modified_z_score2 = 0.6745 * diff2 / med_abs_deviation2
filtered1 = []
i = 0
for data in modified_z_score1:
if data < threshold1:
filtered1.append(leftData[i])
i += 1
i = 0
filtered2 = []
for data in modified_z_score2:
if data < threshold2:
filtered2.append(rightData[i])
i += 1
filtered = filtered1 + filtered2
return filtered
```
- En Python 3, il convient de medianIndex = int(points.size/2). Aussi, si j'exécute le code et de définir un seuil à zéro, il se bloque avec le message name 'sys' is not defined. Dernièrement, le self dans l'appel de fonction n'est jamais utilisée.
InformationsquelleAutor shivangi dhakad
12

J'ai adapté le code de http://eurekastatistics.com/using-the-median-absolute-deviation-to-find-outliers et il donne les mêmes résultats que Joe kingston portant, mais utilise L1 de distance au lieu de L2 de distance, et a un support pour les distributions asymétriques. L'original R code n'a pas eu de Joe 0.6745 multiplicateur, donc j'ai aussi ajouté que, pour des raisons de cohérence au sein de ce thread. Pas sûr à 100% si c'est nécessaire, mais rend la comparaison des pommes avec des pommes.
```
def doubleMADsfromMedian(y,thresh=3.5):
# warning: this function does not check for NAs
# nor does it address issues when 
# more than 50% of your data have identical values
m = np.median(y)
abs_dev = np.abs(y - m)
left_mad = np.median(abs_dev[y <= m])
right_mad = np.median(abs_dev[y >= m])
y_mad = left_mad * np.ones(len(y))
y_mad[y > m] = right_mad
modified_z_score = 0.6745 * abs_dev / y_mad
modified_z_score[y == m] = 0
return modified_z_score > thresh
```
- Comment utiliser MAD approche fondée sur les données multidimensionnelles? L'article que vous avez mentionné est grand, mais fonctionne sur des dimensions données, je suppose. Je voudrais savoir la façon la plus simple de le modifier afin de le rendre applicable pour multivariée des données.
- Il n'y a pas de moyen facile de le faire pour multivariée des données. Un moyen simple est de simplement appliquer la méthode à une seule variable à la fois et voir si certains échantillons sont des valeurs aberrantes dans toutes les dimensions.
- Comment choisir le seuil ? Lire le post original , ne pouvait pas creuser là .
- l'habitude et malheureux réponse est d'essayer un tas de différents seuils de vos données et de voir ce qui est laissé de côté. Depuis c'est 1-D, vous pouvez faire des visualisations comme ceux de Joe kingston portant la réponse. Si cela rend plus facile que vous pouvez penser le seuil comme un peu comme le nombre d'écarts-types. Donc, 3.5, c'est beaucoup. Mais j'ai utilisé des nombres de plus près à 6 avant - tout dépend de vos données.
- Je pense que vous devriez remplacer y_mad[y < m] avec y_mad[y <= m],et y_mad[y > m] avec y_mad[y >= m], sinon lors de la y égal à m, y_mad est égal à zéro.
- Merci @Jin - j'ai corrigé!
- Il y a un problème avec cet algo. Je suis en essais avec 11724, 21513, 20536, 16386, 17586, 11736, 11212, 7861, 8515, 9046, 7016, 90 ensemble. Il ne retourne True si la valeur aberrante, soit le premier ou le dernier élément de la série.
- Dans votre exemple, la médiane est d'environ 11k, et 20k est aussi loin de 11k 90 est, donc, je ne suis pas sûr de ce que la valeur aberrante devrait en fait être ici. Ce sont toutes triées réelle absolue des écarts à partir de la médiane: [256.0, 256.0, 268.0, 2422.0, 2953.0, 3607.0, 4452.0, 4918.0, 6118.0, 9068.0, 10045.0, 11378.0]. Qui sont les valeurs aberrantes dans votre pensée?
- Je ne pense pas qu'il y est une valeur aberrante dans cette série. Je suis vraiment pas sûr à ce sujet. J'ai pensé à des valeurs aberrantes est quelque chose qui s'écarte de la série. Mon problème est que je dois trouver soit en baisse soudaine ou relance d'une série de données.
InformationsquelleAutor sergeyf
3

Utilisation np.percentile comme @Martin a suggéré:
```
percentiles = np.percentile(data, [2.5, 97.5])
# or =>, <= for within 95%
data[(percentiles[0]<data) & (percentiles[1]>data)]
# set the outliners to np.nan
data[(percentiles[0]>data) | (percentiles[1]<data)] = np.nan
```
- À l'aide de centiles des données comme une valeur aberrante test est raisonnable d'abord passer, mais ce n'est pas idéal. Le problème, c'est 1) que vous allez supprimer certaines données, même si elle n'est pas aberrant, et 2) les valeurs aberrantes ont une forte influence sur la variance, et donc le centile des valeurs. Le plus commun de valeurs aberrantes tests d'utilisation "median absolute deviation", qui est moins sensible à la présence de valeurs aberrantes.
- Kingston portant, je vous serais reconnaissant si vous pouviez mettre en œuvre votre chemin à l'aide du code python.
- Voir: stackoverflow.com/a/11886564/325565
- Kingston portant, j'ai vu le lien que vous avez répondu. Cependant, n'est pas un moyen plus facile de le faire en utilisant principalement les fonctions disponibles dans numpy
- Cette fonction utilise de manière intensive numpy (il faut un tableau numpy en entrée et retourne un tableau numpy). Une valeur aberrante test est présent au-delà de la portée de numpy. (numpy lui-même ne contient que les données de base de la structure et de quelques opérations de base. C'est délibérément réduite). Vous pouvez faire un argument qui scipy.stats serait un bon endroit pour une valeur aberrante test, mais il ya beaucoup d'entre eux, et il n'y a pas de meilleur test. Par conséquent, il n'y a pas actuellement d'une seule fonction de valeurs aberrantes d'essai.
- merci pour suggérer scipy.stats
- Statsmodels a une médiane écart absolu de la fonction dans sm.robust.mad. Je ne suis pas sûr qu'il y a des installations pour univariée des valeurs aberrantes, les tests, mais il y en a pour influence/de valeurs aberrantes dans un cadre de régression. Va voir sur l'ajout de certains outils pour univariée de détection de valeurs aberrantes.
- Ne savais pas qui était là! Merci!
InformationsquelleAutor CT Zhu

Bien une solution simple peut aussi être, en supprimant quelque chose qui, en dehors de 2 écarts-types(ou 1,96):

import random
def outliers(tmp):
"""tmp is a list of numbers"""
outs = []
mean = sum(tmp)/(1.0*len(tmp))
var = sum((tmp[i] - mean)**2 for i in range(0, len(tmp)))/(1.0*len(tmp))
std = var**0.5
outs = [tmp[i] for i in range(0, len(tmp)) if abs(tmp[i]-mean) > 1.96*std]
return outs
lst = [random.randrange(-10, 55) for _ in range(40)]
print lst
print outliers(lst)

est-ce pour python 2 ?
que dois-je utiliser à la place de xrange en python 3 ?
xrange en python 2 est la même que la gamme en python 3. Pas plus xrange en python 3.

InformationsquelleAutor jimseeve

Vous devez vous connecter pour publier un commentaire.