numpy - 使用numpy 1d数组的置换副本构建2d数组的最快方法

时间:2015-01-01 15:33:56

标签: python arrays numpy scipy permutation

>>> import numpy as np
>>> a = np.arange(5)
>>> b = desired_function(a, 4)
array([[0, 3, 4, 1],
...    [1, 2, 1, 3],
...    [2, 4, 2, 4],
...    [3, 1, 3, 0],
...    [4, 0, 0, 2]])

到目前为止我尝试了什么

def repeat_and_shuffle(a, ncols):
    nrows, = a.shape
    m = np.tile(a.reshape(nrows, 1), (1, ncols))
    return m

不知何故,我必须按列有效地改变m[:,1:ncols]

4 个答案:

答案 0 :(得分:3)

以下是创建此类数组的一种方法:

>>> a = np.arange(5)
>>> perms = np.argsort(np.random.rand(a.shape[0], 3), axis=0) # 3 columns
>>> np.hstack((a[:,np.newaxis], a[perms]))
array([[0, 3, 1, 4],
       [1, 2, 3, 0],
       [2, 1, 4, 1],
       [3, 4, 0, 3],
       [4, 0, 2, 2]])

这将创建所需形状的随机值数组,然后按相应的值对每列中的索引进行排序。然后使用这个索引数组来索引a

(使用np.argsort创建置换索引列数组的想法来自@ jme的答案here。)

答案 1 :(得分:2)

使用原始的随机排列构建新数组。

>>> a = np.arange(5)
>>> n = 4
>>> z = np.array([a]+[np.random.permutation(a) for _ in xrange(n-1)])
>>> z.T
array([[0, 0, 4, 3],
       [1, 1, 3, 0],
       [2, 3, 2, 4],
       [3, 2, 0, 2],
       [4, 4, 1, 1]])
>>> 

由于随机性,可能会出现重复列。

答案 2 :(得分:2)

这是Ashwini Chaudhary解决方案的一个版本:

>>> a = numpy.array(['a', 'b', 'c', 'd', 'e'])
>>> a = numpy.tile(a[:,None], 5)
>>> a[:,1:] = numpy.apply_along_axis(numpy.random.permutation, 0, a[:,1:])
>>> a
    array([['a', 'c', 'a', 'd', 'c'],
       ['b', 'd', 'b', 'e', 'a'],
       ['c', 'e', 'd', 'a', 'e'],
       ['d', 'a', 'e', 'b', 'd'],
       ['e', 'b', 'c', 'c', 'b']], 
      dtype='|S1')

我认为它构思精良且教学上有用(我希望他能够取消它)。但有些令人惊讶的是,在我所进行的测试中,它始终是最慢的。定义:

>>> def column_perms_along(a, cols):
...     a = numpy.tile(a[:,None], cols)
...     a[:,1:] = numpy.apply_along_axis(numpy.random.permutation, 0, a[:,1:])
...     return a
... 
>>> def column_perms_argsort(a, cols):
...     perms = np.argsort(np.random.rand(a.shape[0], cols - 1), axis=0)
...     return np.hstack((a[:,None], a[perms]))
... 
>>> def column_perms_lc(a, cols):
...     z = np.array([a] + [np.random.permutation(a) for _ in xrange(cols - 1)])
...     return z.T
... 

对于小数组和少数列:

>>> %timeit column_perms_along(a, 5)
1000 loops, best of 3: 272 µs per loop
>>> %timeit column_perms_argsort(a, 5)
10000 loops, best of 3: 23.7 µs per loop
>>> %timeit column_perms_lc(a, 5)
1000 loops, best of 3: 165 µs per loop

对于小数组和许多列:

>>> %timeit column_perms_along(a, 500)
100 loops, best of 3: 29.8 ms per loop
>>> %timeit column_perms_argsort(a, 500)
10000 loops, best of 3: 185 µs per loop
>>> %timeit column_perms_lc(a, 500)
100 loops, best of 3: 11.7 ms per loop

对于大型数组和少数列:

>>> A = numpy.arange(1000)
>>> %timeit column_perms_along(A, 5)
1000 loops, best of 3: 2.97 ms per loop
>>> %timeit column_perms_argsort(A, 5)
1000 loops, best of 3: 447 µs per loop
>>> %timeit column_perms_lc(A, 5)
100 loops, best of 3: 2.27 ms per loop

对于大型阵列和许多列:

>>> %timeit column_perms_along(A, 500)
1 loops, best of 3: 281 ms per loop
>>> %timeit column_perms_argsort(A, 500)
10 loops, best of 3: 71.5 ms per loop
>>> %timeit column_perms_lc(A, 500)
1 loops, best of 3: 269 ms per loop

故事的寓意:永远测试!我想,对于大型数组,n log n解决方案的缺点就像排序一样。但根据我的经验,numpy的排序实施非常好。我敢打赌,在注意到效果之前,你可以上升几个数量级。

答案 3 :(得分:0)

假设您最终打算循环遍历多个1D输入数组,您可能能够缓存排列索引,然后在使用时缓存take而不是permute。即使1D阵列的长度不同,这也可以工作:您只需要丢弃过大的置换索引。

粗略(部分测试)的实施代码:

def permute_multi(X, k, _cache={}):
    """For 1D input `X` of len `n`, it generates an `(k,n)` array
    giving `k` permutations of `X`."""
    n = len(X)
    cached_inds = _cache.get('inds',np.array([[]]))

    # make sure that cached_inds has shape >= (k,n)
    if cached_inds.shape[1] < n:
        _cache['inds'] = cached_inds = np.empty(shape=(k,n),dtype=int)
        for i in xrange(k):
            cached_inds[i,:] = np.random.permutation(n)
    elif cached_inds.shape[0] < k:
        pass # TODO: need to generate more rows

    inds = cached_inds[:k,:] # dispose of excess rows

    if n < cached_inds.shape[1]:
        # dispose of high indices
        inds = inds.compress(inds.ravel()<n).reshape((k,n))

    return X[inds]

根据您的使用情况,您可能希望提供一些清除缓存的方法,或至少一些可以发现缓存nk比大多数常见内容大得多的启发式方法投入。请注意,上面的函数给出了(k,n)而不是(n,k),这是因为numpy默认为连续的行,我们希望n - 维度是连续的 - 如果你强迫Fortran风格的话希望,或者只是转置输出(在数组中翻转一个标志而不是真正移动数据)。

就这个缓存概念在统计上是否有效而言,我相信在大多数情况下它可能很好,因为它大致相当于将函数开头的种子重置为固定常量......但如果你在使用这种方法之前,您可能需要仔细考虑返回的数组。

快速基准测试表示n=1000k=1000(一旦预热)这需要2.2 ms,而完整150 ms则为k - 循环遍历np.random.permutation。这大约快了70倍......但在最简单的情况下,我们不会拨打compress。对于n=999k=1000,已经预热了n=1000,需要额外的几毫秒,总时间8ms,这仍然是k的约19倍1}} - 环