Как найти выбросы в серии, векторизованные?

Ответ 1

Здесь мое оригинальное "векторизованное" решение:

Вы можете получить last_valid с помощью shift и numpy where:

In [1]: s = pd.Series([10, 10, 10, 14, 10, 10, 10, 14, 100, 14, 10])

In [2]: last_valid = pd.Series(np.where((s - s.shift()).abs() < 3, s, np.nan))
        last_valid.iloc[0] = s.iloc[0]  # initialize with first value of s
        last_valid.ffill(inplace=True)

In [3]: last_valid
Out[3]:
0      7
1      8
2      9
3     10
4     10
5     10
6     10
7     10
8     10
9     10
10    10
dtype: float64

Это значительно облегчает задачу. Вы можете сравнить это с s:

In [4]: s - last_valid  # alternatively use (s - last_valid).abs()
Out[4]: 
0      0
1      0
2      0
3      0
4      4
5      0
6      0
7      4
8     90
9      4
10     0
dtype: float64

Те элементы, которые отличаются более чем на +3:

In [5]: (s - last_valid).abs() >= 3
Out[5]: 
0     False
1     False
2     False
3     False
4      True
5     False
6     False
7      True
8      True
9      True
10    False
dtype: bool

In [6]: s[(s - last_valid).abs() >= 3]
Out[6]: 
4     14
7     14
8    100
9     14
dtype: int64

По желанию.... или так, казалось бы, пример @alko показывает, что это не совсем правильно.

Update

Как указано в @alko, приведенный ниже подход не совсем корректен, особенно для примера s = pd.Series([10, 14, 11, 10, 10, 12, 14, 100, 100, 14, 10]), мой "векторный" подход включал второй 100 как "не outling", даже если он находится в базовой линии.

Это заставляет меня (вместе с @alko) думать, что это невозможно векторизовать. В качестве альтернативы я включил простую реализацию cython (см. раздел cython pandas docs), который значительно быстрее, чем собственный python:

%%cython
cimport numpy as np
import numpy as np
cimport cython
@cython.wraparound(False)
@cython.boundscheck(False)
cpdef _outliers(np.ndarray[double] s):
    cdef np.ndarray[Py_ssize_t] indexes
    cdef np.ndarray[double] vals
    cdef double last, val
    cdef Py_ssize_t count
    indexes = np.empty(len(s), dtype='int')
    vals = np.empty(len(s))
    last = s[0]
    count = 0
    for idx, val in enumerate(s):
        if abs(val - last) >= 3:
            indexes[count] = idx
            vals[count] = val
            count += 1
        else:
            last = val
    return vals[:count], indexes[:count]

def outliers(s):
    return pd.Series(*_outliers(s.values.astype('float')))

Некоторая индикация таймингов:

In [11]: s = pd.Series([10,10,12,14,100,100,14,10])

In [12]: %timeit baseline(s)
10000 loops, best of 3: 132 µs per loop

In [13]: %timeit outliers(s)
10000 loops, best of 3: 46.8 µs per loop

In [21]: s = pd.Series(np.random.randint(0, 100, 100000))

In [22]: %timeit baseline(s)
10 loops, best of 3: 161 ms per loop

In [23]: %timeit outliers(s)
100 loops, best of 3: 9.43 ms per loop

Подробнее см. раздел cython (повышение производительности) документов pandas.

Ответ 2

Моя попытка решить проблему состоит в том, чтобы сформулировать ее как повторяющееся выражение для last_valid, а затем следовать по пути Энди Хейдена. Выражение для last_valid будет:

lv[i] = lv[i-1] if diff >= 3 else v[i]

где

diff = abs(v[i] - lv[i-1]))

где я - номер итерации. Чтобы реализовать это в DataFrame, я использую указатель из ctype. С помощью разыменования на сдвинутом столбце указателей на столбец lv (last_valid) значение, рассчитанное на одном шаге итерации, доступно на следующем.

from ctypes import *
import pandas as pd

df = pd.DataFrame({'s_num': [7,8,9,10,14,10,10,14,100,14,10]})
df['s'] = df['s_num'].apply(c_long)
df['lv'] = [c_long(0) for x in range(len(df))]
df.ix[0, 'lv'] = df.ix[0, 's']
df['p_lv'] = df['lv'].apply(pointer)
df['p_lv_m1'] = df['p_lv'].shift()

def ff(x):
    if not pd.isnull(x['p_lv_m1']):
        diff = abs(x['s'].value - x['p_lv_m1'].contents.value)
        x['p_lv'][0] = x['s'] if diff < 3 else x['p_lv_m1'][0]
    return None

df.apply(ff, 1)
df['lv_num'] = df['lv'].apply(lambda x: x.value)
df = df[['s_num', 'lv_num']]

print df.ix[(df['s_num'] - df['lv_num']).abs() >= 3, 's_num']