对numpy数组

时间:2016-12-24 07:23:12

标签: performance pandas numpy multidimensional-array

许多numpy函数提供了使用axis =参数在某个轴上运行的选项。我的问题是

  1. 这个'沿着轴'运作是否实施?或者,更直接的问题
  2. 如何有效地编写自己的功能,提供类似的选项?
  3. 我注意到numpy提供了一个函数numpy.apply_along_axis,如果基函数输入是1-D数组,它将作为答案。

    但是如果我的基本功能需要多维输入呢?例如。找到沿前两个维度(5,6)的形状(5,6,2,3,4)的np矩阵A的二维移动平均值B?像通用函数B = f_moving_mean(A,axis =(0,1))

    我目前的解决方案是使用numpy.swapaxes和numpy.reshape来完成此任务。 1-D移动平均函数的示例代码为:

    import pandas as pd
    import numpy as np
    def nanmoving_mean(data,window,axis=0):
        kw = {'center':True,'window':window,'min_periods':1}
        if len(data.shape)==1:
            return pd.Series(data).rolling(**kw).mean().as_matrix()
        elif len(data.shape)>=2:
            tmp = np.swapaxes(data,0,axis)
            tmpshp = tmp.shape
            tmp = np.reshape( tmp, (tmpshp[0],-1), order='C' )
            tmp = pd.DataFrame(tmp).rolling(**kw).mean().as_matrix()
            tmp = np.reshape( tmp, tmpshp, order='C' )
            return np.swapaxes(tmp,0,axis)
        else:
            print('Invalid dimension!')
            return None
    
    data = np.random.randint(10,size=(2,3,6))
    print(data)
    nanmoving_mean(data,window=3,axis=2)
    

    这是问题2的常见/有效实施方式吗?任何改进/建议/新方法都是受欢迎的。

    PS。我在这里涉及大熊猫的原因是它的滚动(...)。mean()方法能够正确处理纳米数据。

    编辑: 我想另一种提问的方式可能是:什么是循环的动态语法'尺寸数量?

2 个答案:

答案 0 :(得分:1)

没有太多问题,这是apply_along_axis函数的关键部分(通过Ipython查看)

        res = func1d(arr[tuple(i.tolist())], *args, **kwargs)
        outarr[tuple(ind)] = res

它们构造了两个索引对象iind,它们各不相同。假设我们指定axis=2,则此代码执行

outarr[i,j,l] = func1d( arr[i,j,:,l], ...)

表示ijl的所有可能值。所以有很多代码用于相当基本的迭代计算。

ind = [0]*(nd-1)   # ind is just a nd-1 list

i = zeros(nd, 'O')        # i is a 1d array with a `slice` object
i[axis] = slice(None, None)

我不熟悉大熊猫rolling。但是有许多numpy滚动问题。 scipy.signal.convolve2d可能有用。 <{1}}也被使用。

您想要使用np.lib.stride_tricks.as_stridedreshape(或swapaxis)来降低维度空间的复杂性也很好。

(这不是一个解决方案;而是抛出一些浮现在脑海中的想法,记住其他'移动平均'问题。开发更多问题为时已晚。)

答案 1 :(得分:1)

我们可以使用2D convolution

基本步骤如下:

  • 作为预处理步骤,将NaNs替换为0s,因为我们需要对输入数据进行窗口求和。
  • 获取数据值为Scipy's convolve2d的窗口摘要 以及NaNs的面具。我们将边界元素用作零。
  • 从窗口大小中减去NaNs的窗口计数,以计算负责求和的有效元素的数量。
  • 对于边界元素,我们会逐渐减少要求总和的元素。

现在,这些intervaled-summations也可以通过相对更高效的Scipy's1Duniform-filter获得。其他好处是我们可以指定执行这些求和/平均的轴。

混合使用Scipy 2D convolution1D uniform filter,我们接下来会列出几种方法。

导入相关的Scipy函数 -

from scipy.signal import convolve2d as conv2
from scipy.ndimage.filters import uniform_filter1d as uniff

方法#1:

def nanmoving_mean_numpy(data, W): # data: input array, W: Window size
    N = data.shape[-1]
    hW = (W-1)//2

    nan_mask = np.isnan(data)
    data1 = np.where(nan_mask,0,data)

    value_sums = conv2(data1.reshape(-1,N),np.ones((1,W)),'same', boundary='fill')
    nan_sums = conv2(nan_mask.reshape(-1,N),np.ones((1,W)),'same', boundary='fill')

    value_sums.shape = data.shape
    nan_sums.shape = data.shape

    b_sizes = hW+1+np.arange(hW) # Boundary sizes
    count = np.hstack(( b_sizes , W*np.ones(N-2*hW), b_sizes[::-1] ))
    return value_sums/(count - nan_sums)

方法#2:

def nanmoving_mean_numpy_v2(data, W): # data: input array, W: Window size    
    N = data.shape[-1]
    hW = (W-1)//2

    nan_mask = np.isnan(data)
    data1 = np.where(nan_mask,0,data)

    value_sums = uniff(data1,size=W, axis=-1, mode='constant')*W
    nan_sums = conv2(nan_mask.reshape(-1,N),np.ones((1,W)),'same', boundary='fill')
    nan_sums.shape = data.shape

    b_sizes = hW+1+np.arange(hW) # Boundary sizes
    count = np.hstack(( b_sizes , W*np.ones(N-2*hW,dtype=int), b_sizes[::-1] ))
    out =  value_sums/(count - nan_sums)
    out = np.where(np.isclose( count, nan_sums), np.nan, out)
    return out

方法#3:

def nanmoving_mean_numpy_v3(data, W): # data: input array, W: Window size
    N = data.shape[-1]
    hW = (W-1)//2

    nan_mask = np.isnan(data)
    data1 = np.where(nan_mask,0,data)    
    nan_avgs = uniff(nan_mask.astype(float),size=W, axis=-1, mode='constant')

    b_sizes = hW+1+np.arange(hW) # Boundary sizes
    count = np.hstack(( b_sizes , W*np.ones(N-2*hW), b_sizes[::-1] ))
    scale = ((count/float(W)) - nan_avgs)
    out = uniff(data1,size=W, axis=-1, mode='constant')/scale
    out = np.where(np.isclose( scale, 0), np.nan, out)
    return out

运行时测试

数据集#1:

In [807]: # Create random input array and insert NaNs
     ...: data = np.random.randint(10,size=(20,30,60)).astype(float)
     ...: 
     ...: # Add 10% NaNs across the data randomly
     ...: idx = np.random.choice(data.size,size=int(data.size*0.1),replace=0)
     ...: data.ravel()[idx] = np.nan
     ...: 
     ...: W = 5 # Window size
     ...: 

In [808]: %timeit nanmoving_mean(data,window=W,axis=2)
     ...: %timeit nanmoving_mean_numpy(data, W)
     ...: %timeit nanmoving_mean_numpy_v2(data, W)
     ...: %timeit nanmoving_mean_numpy_v3(data, W)
     ...: 
10 loops, best of 3: 22.3 ms per loop
100 loops, best of 3: 3.31 ms per loop
100 loops, best of 3: 2.99 ms per loop
1000 loops, best of 3: 1.76 ms per loop

数据集#2 [更大的数据集]:

In [811]: # Create random input array and insert NaNs
 ...: data = np.random.randint(10,size=(120,130,160)).astype(float)
 ...: 
 ...: # Add 10% NaNs across the data randomly
 ...: idx = np.random.choice(data.size,size=int(data.size*0.1),replace=0)
 ...: data.ravel()[idx] = np.nan
 ...: 

In [812]: %timeit nanmoving_mean(data,window=W,axis=2)
     ...: %timeit nanmoving_mean_numpy(data, W)
     ...: %timeit nanmoving_mean_numpy_v2(data, W)
     ...: %timeit nanmoving_mean_numpy_v3(data, W)
     ...: 
1 loops, best of 3: 796 ms per loop
1 loops, best of 3: 486 ms per loop
1 loops, best of 3: 275 ms per loop
10 loops, best of 3: 161 ms per loop