python在numpy数组的子维上的操作

许多numpy函数提供了在axis = parameter的特定轴上运行的选项。我的问题是python在numpy数组的子维上的操作

如何实现这种“沿轴”操作？或者，更直接的问题
如何有效地编写我自己的函数来提供类似的选项？

我注意到numpy提供了一个函数numpy.apply_along_axis，如果基函数输入是一维数组，那么它将作为答案。

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

我目前的解决方案是使用numpy.swapaxes和numpy.reshape来实现这一点。一维移动平均函数的示例代码是：

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（）方法能够正确处理nan数据。

编辑：我想问问题的另一种方式可能是：循环“动态”维数的语法是什么？

来源

2016-12-24 Shichu Zhu

我们可以有使用2D convolution的方法。

的基本步骤是：

作为预处理步骤，与0s取代NaNs，我们需要做的输入数据窗口总和。
对于数据值以及NaNs的掩码，获得与Scipy's convolve2d的加窗求和。我们将使用边界元素作为零。
从窗口大小减去窗口计数NaNs以获得负责求和的有效元素的计数。
对于边界元素，我们会逐渐减少求和的元素。

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

有了Scipy的2D convolution和1D 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

来源

2016-12-24 11:56:27 Divakar

没有得到太多的进入你的问题，这里的apply_along_axis功能（通过IPython的观看）

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

他们兴建两个索引对象，i和ind这是多种多样的重要组成部分。假设我们指定axis=2，那么这段代码

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

为i，j，并l所有可能的值。所以有很多代码用于基本的迭代计算。

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可能有用。还使用了np.lib.stride_tricks.as_strided。

你想用reshape和swapaxis（或transpose）来降低维度空间的复杂度也不错。

（这不是一个解决方案，而是抛出一些想法浮现在脑海中，记忆等“移动平均”问题，这是为时已晚，以开发更多的。）

来源

2016-12-24 08:07:25 hpaulj

我不哪里看apply_along_axis的代码，但它如何构造我和ind？ –

@ShichuZhu如果你正在寻找性能，'apply_along_axis'将无济于事。 – Divakar

@Divakar如果基本函数只处理1D，那么循环遍历所有其他维度是唯一的方法。除非修改基本函数以包含向量化操作，我猜？ –

python在numpy数组的子维上的操作

回答

相关问题