Question

对包含NaN值的数据执行np.percentile(ndarr, axis=0)是否有相当快的方法？

对于np.median，相应的bottleneck.nanmedian（https://pypi.python.org/pypi/Bottleneck）相当不错。

我提出的最好的百分位数是不完整的，目前不正确的是：

   from bottleneck import nanrankdata, nanmax, nanargmin
   def nanpercentile(x, q, axis):
       ranks = nanrankdata(x, axis=axis)
       peak = nanmax(ranks, axis=axis)
       pct = ranks/peak / 100. # to make a percentile
       wh = nanargmin(abs(pct-q),axis=axis)
       return x[wh]

这不起作用;真正需要的是采用axis的第n个元素的一些方法，但我还没有找到这样的numpy切片技巧。

“合理快速”意味着比循环索引更好，例如：

q = 40
x = np.array([[[1,2,3],[6,np.nan,4]],[[0.5,2,1],[9,3,np.nan]]])
out = np.empty(x.shape[:-1])
for i in range(x.shape[0]):
   for j in range(x.shape[1]):
      d = x[i,j,:]
      out[i,j] = np.percentile(d[np.isfinite(d)], q)

print out

#array([[ 1.8,  4.8],
#       [ 0.9,  5.4]])

虽然有效但可能非常慢。

np.ma似乎没有按预期工作;它会将nan值视为inf：

xm = np.ma.masked_where(np.isnan(x),x)
print np.percentile(xm,40,axis=2)

# array([[ 1.8,  5.6],
#        [ 0.9,  7.8]])

Answer 1

url = "http://www.basketball-reference.com/players/a/acyqu01/gamelog/2015/" driver = webdriver.Firefox() driver.get(url) driver.find_element_by_link_text("Switch to Advanced Game Log").click() driver.find_element_by_link_text("CSV").click()包含在numpy 1.9.0

中

http://docs.scipy.org/doc/numpy/reference/generated/numpy.nanpercentile.html

Answer 2

您可以使用as_strided()中的numpy.lib.stride_tricks来操纵数组的步幅以更快地迭代它。

您的计算可以视为在阵列的（1,1,3）窗口上运行。我喜欢使用sliding_window()通过n个窗口使用as_strided()来创建创建 n的广义函数。我在这里找到它 - Efficient Overlapping Windows with Numpy;功能显然是到johnvinyard。那个博客页面很好地描述了正在发生的事情。

制作一些1x1x3窗口

import numpy as np
x = np.array([[[1,2,3],[6,np.nan,4]],[[0.5,2,1],[9,3,np.nan]]])
for thing in sliding_window(x, (1,1,3)):
    print thing

# [ 1.  2.  3.]
# [  6.  nan   4.]
# [ 0.5  2.   1. ]
# [  9.   3.  nan]

申请```np.percentile（）＆＃39;＆＃39; - 无视NaN＆＃39>

for thing in sliding_window(x, (1,1,3)):
    print np.percentile(thing[np.isfinite(thing)], 40)

# 1.8
# 4.8
# 0.9
# 5.4

制作一个结果数组：

per_s = [np.percentile(thing[np.isfinite(thing)], 40)
         for thing in sliding_window(x, (1,1,3))]

print per_s
# [1.8, 4.8000000000000007, 0.90000000000000002, 5.4000000000000004]

per_s = np.array(per_s)
print per_s
# array([ 1.8,  4.8,  0.9,  5.4])

让它恢复到您期望的形状

print per_s.reshape((2,2))
# array([[ 1.8,  4.8],
#        [ 0.9,  5.4]])

print per_s.reshape(x.shape[:-1])
# array([[ 1.8,  4.8],
#        [ 0.9,  5.4]])

这应该更快。我很好奇它是否会 - 我没有任何现实世界的问题来测试它。

google搜索numpy as_strided会产生一些好结果：我将这个标记为http://scipy-lectures.github.io/advanced/advanced_numpy/

来自Efficient Overlapping Windows with Numpy

的

sliding_window()

from numpy.lib.stride_tricks import as_strided as ast
from itertools import product

def norm_shape(shape):
    '''
    Normalize numpy array shapes so they're always expressed as a tuple, 
    even for one-dimensional shapes.

    Parameters
        shape - an int, or a tuple of ints

    Returns
        a shape tuple
    '''
    try:
        i = int(shape)
        return (i,)
    except TypeError:
        # shape was not a number
        pass

    try:
        t = tuple(shape)
        return t
    except TypeError:
        # shape was not iterable
        pass

    raise TypeError('shape must be an int, or a tuple of ints')


def sliding_window(a,ws,ss = None,flatten = True):
    '''
    Return a sliding window over a in any number of dimensions

    Parameters:
        a  - an n-dimensional numpy array
        ws - an int (a is 1D) or tuple (a is 2D or greater) representing the size 
             of each dimension of the window
        ss - an int (a is 1D) or tuple (a is 2D or greater) representing the 
             amount to slide the window in each dimension. If not specified, it
             defaults to ws.
        flatten - if True, all slices are flattened, otherwise, there is an 
                  extra dimension for each dimension of the input.

    Returns
        an array containing each n-dimensional window from a
    '''

    if None is ss:
        # ss was not provided. the windows will not overlap in any direction.
        ss = ws
    ws = norm_shape(ws)
    ss = norm_shape(ss)

    # convert ws, ss, and a.shape to numpy arrays so that we can do math in every 
    # dimension at once.
    ws = np.array(ws)
    ss = np.array(ss)
    shape = np.array(a.shape)


    # ensure that ws, ss, and a.shape all have the same number of dimensions
    ls = [len(shape),len(ws),len(ss)]
    if 1 != len(set(ls)):
        raise ValueError(\
        'a.shape, ws and ss must all have the same length. They were %s' % str(ls))

    # ensure that ws is smaller than a in every dimension
    if np.any(ws > shape):
        raise ValueError('ws cannot be larger than a in any dimension. a.shape was %s and ws was %s' % (str(a.shape),str(ws)))

    # how many slices will there be in each dimension?
    newshape = norm_shape(((shape - ws) // ss) + 1)
    # the shape of the strided array will be the number of slices in each dimension
    # plus the shape of the window (tuple addition)
    newshape += norm_shape(ws)
    # the strides tuple will be the array's strides multiplied by step size, plus
    # the array's strides (tuple addition)
    newstrides = norm_shape(np.array(a.strides) * ss) + a.strides
    strided = ast(a,shape = newshape,strides = newstrides)
    if not flatten:
        return strided

    # Collapse strided so that it has one more dimension than the window.  I.e.,
    # the new array is a flat list of slices.
    meat = len(ws) if ws.shape else 0
    firstdim = (np.product(newshape[:-meat]),) if ws.shape else ()
    dim = firstdim + (newshape[-meat:])
    # remove any dimensions with size 1
    #dim = filter(lambda i : i != 1,dim)
    dim = tuple(thing for thing in dim if thing != 1)
    return strided.reshape(dim)

Answer 3

如果您不需要超快速解决方案，您可以先将数组转移到pandas DataFrame并进行分位数处理，然后再返回numpy数组。

{{1}}

Answer 4

你可以在numpy 1.8中使用partition()沿着轴取第n个元素，这是获取沿最后一个轴的第二个元素的代码：

x = np.array([[[1,2,3],[6,np.nan,4]],[[0.5,2,1],[9,3,np.nan]]])
np.partition(x, 1)[..., 1]

输出：

array([[ 2.,  6.],
       [ 1.,  9.]])

沿着轴忽略nans的np.percentile的最佳方法是什么？

4 个答案: