10

我有一个大的一维整数数组，我需要去掉切片。那是微不足道的，我只是这样做a[start:end]。问题是我需要更多这些切片。a[start:end]如果 start 和 end 是数组，则不起作用。可以为此使用 for 循环，但我需要它尽可能快（这是一个瓶颈），因此欢迎使用本机 numpy 解决方案。

为了进一步说明，我有这个：

a = numpy.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], numpy.int16)
start = numpy.array([1, 5, 7], numpy.int16)
end   = numpy.array([2, 10, 9], numpy.int16)

并且需要以某种方式使它变成这样：

[[1], [5, 6, 7, 8, 9], [7, 8]]
4

5 回答 5

9

这可以（几乎？）numpy使用掩码数组和步幅技巧以纯方式完成。首先，我们创建我们的面具：

>>> indices = numpy.arange(a.size)
>>> mask = ~((indices >= start[:,None]) & (indices < end[:,None]))

或者更简单地说：

>>> mask = (indices < start[:,None]) | (indices >= end[:,None])

对于开始值和结束值False的那些索引，掩码是（即未掩码的值）。（用(aka )切片增加了一个新维度，启用广播。）现在我们的掩码看起来像这样：>=<Nonenumpy.newaxis

>>> mask
array([[ True, False,  True,  True,  True,  True,  True,  True,  True,
         True,  True,  True],
       [ True,  True,  True,  True,  True, False, False, False, False,
        False,  True,  True],
       [ True,  True,  True,  True,  True,  True,  True, False, False,
         True,  True,  True]], dtype=bool)

现在我们必须使用以下方法拉伸数组以适应掩码stride_tricks：

>>> as_strided = numpy.lib.stride_tricks.as_strided
>>> strided = as_strided(a, mask.shape, (0, a.strides[0]))
>>> strided
array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11],
       [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11],
       [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11]], dtype=int16)

这看起来像一个 3x12 数组，但每一行都指向同一个内存。现在我们可以将它们组合成一个掩码数组：

>>> numpy.ma.array(strided, mask=mask)
masked_array(data =
 [[-- 1 -- -- -- -- -- -- -- -- -- --]
 [-- -- -- -- -- 5 6 7 8 9 -- --]
 [-- -- -- -- -- -- -- 7 8 -- -- --]],
             mask =
 [[ True False  True  True  True  True  True  True  True  True  True  True]
 [ True  True  True  True  True False False False False False  True  True]
 [ True  True  True  True  True  True  True False False  True  True  True]],
       fill_value = 999999)

这与您所要求的并不完全相同，但它的行为应该相似。

于 2012-09-25T20:58:58.577 回答
6

没有 numpy 方法可以做到这一点。请注意，由于它是不规则的，因此无论如何它只会是数组/切片的列表。但是我想补充一点，对于ufuncs几乎所有 numpy 中的函数（或者它们至少基于它们）的所有（二进制），有一种reduceat方法可以帮助您避免实际创建切片列表，因此，如果切片很小，也可以加快计算速度：

In [1]: a = np.arange(10)

In [2]: np.add.reduceat(a, [0,4,7]) # add up 0:4, 4:7 and 7:end
Out[2]: array([ 6, 15, 24])

In [3]: np.maximum.reduceat(a, [0,4,7]) # maximum of each of those slices
Out[3]: array([3, 6, 9])

In [4]: w = np.asarray([0,4,7,10]) # 10 for the total length

In [5]: np.add.reduceat(a, w[:-1]).astype(float)/np.diff(w) # equivalent to mean
Out[5]: array([ 1.5,  5. ,  8. ])

编辑：由于您的切片重叠，我将补充一点，这也可以：

# I assume that start is sorted for performance reasons.
reductions = np.column_stack((start, end)).ravel()
sums = np.add.reduceat(a, reductions)[::2]

通常在这里[::2]应该没什么大不了的，因为没有为重叠切片做真正的额外工作。

这里还有一个关于切片的问题stop==len(a)。必须避免这种情况。如果你只有一个切片，你可以这样做reductions = reductions[:-1]（如果它是最后一个切片），否则你只需要附加一个值a来欺骗reduceat：

 a = np.concatenate((a, [0]))

因为无论如何你都在切片上工作，所以在末尾添加一个值并不重要。

于 2012-09-25T20:29:32.153 回答
1

这不是一个“纯”的 numpy 解决方案（尽管正如@mgilson 的评论所指出的，很难看出不规则输出如何成为一个 numpy 数组），但是：

a = numpy.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], numpy.int16)
start = numpy.array([1, 5, 7], numpy.int16)
end   = numpy.array([2, 10, 9], numpy.int16)

map(lambda range: a[range[0]:range[1]],zip(start,end))

得到你：

[array([1], dtype=int16), array([5, 6, 7, 8, 9], dtype=int16),  array([7, 8], dtype=int16)]

按要求。

于 2012-09-25T19:50:37.090 回答
1

如果你想要它在一行中，它将是：

x=[list(a[s:e]) for (s,e) in zip(start,end)]
于 2016-05-30T19:47:12.127 回答
0

类似的解决方案，如 timday。类似速度：

a = np.random.randint(0,20,1e6)
start = np.random.randint(0,20,1e4)
end = np.random.randint(0,20,1e4)

def my_fun(arr,start,end):
        return arr[start:end]

%timeit [my_fun(a,i[0],i[1]) for i in zip(start,end)]
%timeit map(lambda range: a[range[0]:range[1]],zip(start,end))

100 loops, best of 3: 7.06 ms per loop 100 loops, best of 3: 6.87 ms per loop

于 2015-05-25T12:10:35.170 回答