Erkennen und ausschließen von Ausreißern in der Pandas-Daten-frame

Wenn Sie mehrere Spalten in den dataframe und möchten, entfernen Sie alle Zeilen, die "Ausreißer" in mindestens einer Spalte den folgenden Ausdruck machen würde, in einem Schuss.

df = pd.DataFrame(np.random.randn(100, 3))

from scipy import stats
df[(np.abs(stats.zscore(df)) < 3).all(axis=1)]

Beschreibung:

• Für jede Spalte, ersten es berechnet die Z-score für jeden Wert in der
  Spalte, bezogen auf die Spalte Mittelwert und die Standardabweichung.
• Dann ist die absolute, Z-score, weil die Richtung nicht
  egal, nur wenn es unter der Schwelle.
• alle(axis=1) sorgt dafür, dass für jede Zeile, Spalte alle erfüllen
  - Einschränkung.
• Schließlich, das Ergebnis dieser Bedingung wird verwendet, um den index der dataframe.

Für jede Ihrer dataframe Spalte, die Sie bekommen konnte quantile mit:

q = df["col"].quantile(0.99)

werden und dann der filter mit:

df[df["col"] < q]

#------------------------------------------------------------------------------
# accept a dataframe, remove outliers, return cleaned data in a new dataframe
# see http://www.itl.nist.gov/div898/handbook/prc/section1/prc16.htm
#------------------------------------------------------------------------------
def remove_outlier(df_in, col_name):
    q1 = df_in[col_name].quantile(0.25)
    q3 = df_in[col_name].quantile(0.75)
    iqr = q3-q1 #Interquartile range
    fence_low  = q1-1.5*iqr
    fence_high = q3+1.5*iqr
    df_out = df_in.loc[(df_in[col_name] > fence_low) & (df_in[col_name] < fence_high)]
    return df_out

Da habe ich nicht gesehen, eine Antwort, die sich mit numerische und nicht-numerische Attribute, hier ist eine Ergänzung der Antwort.

Möchten Sie vielleicht fallen die Ausreißer nur auf numerische Attribute (kategoriale Variablen können kaum Ausreißer).

Funktion definition

Ich verlängert @tanemaki Vorschlag, um Daten zu behandeln, wenn nicht-numerische Attribute sind auch vorhanden:

from scipy import stats

def drop_numerical_outliers(df, z_thresh=3):
    # Constrains will contain `True` or `False` depending on if it is a value below the threshold.
    constrains = df.select_dtypes(include=[np.number]) \
        .apply(lambda x: np.abs(stats.zscore(x)) < z_thresh, reduce=False) \
        .all(axis=1)
    # Drop (inplace) values set to be rejected
    df.drop(df.index[~constrains], inplace=True)

Nutzung

drop_numerical_outliers(df)

Beispiel

Vorstellen, ein dataset df mit einigen Werten über Häuser: alley -, land-Kontur -, Verkaufspreis, ... E. g: Daten-Dokumentation

Ersten, die Sie wollen, visualisieren Sie die Daten auf einem Punktdiagramm (mit z-score-Schwelle=3):

# Plot data before dropping those greater than z-score 3. 
# The scatterAreaVsPrice function's definition has been removed for readability's sake.
scatterAreaVsPrice(df)

# Drop the outliers on every attributes
drop_numerical_outliers(train_df)

# Plot the result. All outliers were dropped. Note that the red points are not
# the same outliers from the first plot, but the new computed outliers based on the new data-frame.
scatterAreaVsPrice(train_df)

Weitere option ist, um wandeln Sie Ihre Daten so, dass die Wirkung von Ausreißern abgeschwächt. Sie können dies tun, indem winsorizing Ihre Daten.

import pandas as pd
from scipy.stats import mstats
%matplotlib inline

test_data = pd.Series(range(30))
test_data.plot()

# Truncate values to the 5th and 95th percentiles
transformed_test_data = pd.Series(mstats.winsorize(test_data, limits=[0.05, 0.05])) 
transformed_test_data.plot()

Da ich in einem sehr frühen Stadium meiner Daten Wissenschaft Reise, ich bin der Behandlung von Ausreißern mit dem code unten.

#Outlier Treatment

def outlier_detect(df):
    for i in df.describe().columns:
        Q1=df.describe().at['25%',i]
        Q3=df.describe().at['75%',i]
        IQR=Q3 - Q1
        LTV=Q1 - 1.5 * IQR
        UTV=Q3 + 1.5 * IQR
        x=np.array(df[i])
        p=[]
        for j in x:
            if j < LTV or j>UTV:
                p.append(df[i].median())
            else:
                p.append(j)
        df[i]=p
    return df

Meine Funktion zum löschen von Ausreißern

def drop_outliers(df, field_name):
    distance = 1.5 * (np.percentile(df[field_name], 75) - np.percentile(df[field_name], 25))
    df.drop(df[df[field_name] > distance + np.percentile(df[field_name], 75)].index, inplace=True)
    df.drop(df[df[field_name] < np.percentile(df[field_name], 25) - distance].index, inplace=True)

Holen Sie sich die 98 und 2. Perzentil als die Grenzen unserer Ausreißer

upper_limit = np.percentile(X_train.logerror.values, 98) 
lower_limit = np.percentile(X_train.logerror.values, 2) # Filter the outliers from the dataframe
data[‘target’].loc[X_train[‘target’]>upper_limit] = upper_limit data[‘target’].loc[X_train[‘target’]<lower_limit] = lower_limit

Löschen und ablegen von Ausreißern, die ich glaube, ist statistisch falsch.
Es macht die Daten vom original abweichen Daten.
Auch macht die Daten ungleich geformt und damit beste Weg ist, zu reduzieren oder zu vermeiden den Effekt von Ausreißern durch log-Transformation der Daten.
Dieser arbeitete für mich:

np.log(data.iloc[:, :])