每行numpy的快速列洗牌

Posted 2023-02-23

【中文标题】每行numpy的快速列洗牌

【英文标题】：Fast column shuffle of each row numpy

【发布时间】：2014-01-27 10:57:18

【问题描述】：

我有一个包含行的 10,000,000+ 长度的大型数组。我需要单独洗牌这些行。例如：

[[1,2,3]
 [1,2,3]
 [1,2,3]
 ...
 [1,2,3]]

到

[[3,1,2]
 [2,1,3]
 [1,3,2]
 ...
 [1,2,3]]

我正在使用

map(numpy.random.shuffle, array)

但这是一个 python（不是 NumPy）循环，它占用了我 99% 的执行时间。可悲的是，PyPy JIT 没有实现numpypy.random，所以我不走运。有没有更快的方法？我愿意使用任何库（pandas、scikit-learn、scipy、theano 等，只要它使用 Numpy ndarray 或派生类。）

如果没有，我想我会求助于 Cython 或 C++。

【问题讨论】：

numpy.apply_along_axis(numpy.random.shuffle, 1, array) 可能会快一点。我还没计时。

谢谢，我会调查的。

它实际上要慢很多（≈10x），因为它需要内存复制（shuffle 已到位，因此您需要使用 permutation 代替）。

【参考方案1】：

如果列的排列是可枚举的，那么你可以这样做：

import itertools as IT
import numpy as np

def using_perms(array):
    nrows, ncols = array.shape
    perms = np.array(list(IT.permutations(range(ncols))))
    choices = np.random.randint(len(perms), size=nrows)
    i = np.arange(nrows).reshape(-1, 1)
    return array[i, perms[choices]]

N = 10**7
array = np.tile(np.arange(1,4), (N,1))
print(using_perms(array))

产量（类似）

[[3 2 1]
 [3 1 2]
 [2 3 1]
 [1 2 3]
 [3 1 2]
 ...
 [1 3 2]
 [3 1 2]
 [3 2 1]
 [2 1 3]
 [1 3 2]]

这是一个比较它的基准

def using_shuffle(array):
    map(numpy.random.shuffle, array)
    return array

In [151]: %timeit using_shuffle(array)
1 loops, best of 3: 7.17 s per loop

In [152]: %timeit using_perms(array)
1 loops, best of 3: 2.78 s per loop

---

编辑：CT Zhu的方法比我的快：

def using_Zhu(array):
    nrows, ncols = array.shape    
    all_perm = np.array((list(itertools.permutations(range(ncols)))))
    b = all_perm[np.random.randint(0, all_perm.shape[0], size=nrows)]
    return (array.flatten()[(b+3*np.arange(nrows)[...,np.newaxis]).flatten()]
            ).reshape(array.shape)

In [177]: %timeit using_Zhu(array)
1 loops, best of 3: 1.7 s per loop

这里是朱的方法的一个轻微变化，可能会更快一点：

def using_Zhu2(array):
    nrows, ncols = array.shape    
    all_perm = np.array((list(itertools.permutations(range(ncols)))))
    b = all_perm[np.random.randint(0, all_perm.shape[0], size=nrows)]
    return array.take((b+3*np.arange(nrows)[...,np.newaxis]).ravel()).reshape(array.shape)

In [201]: %timeit using_Zhu2(array)
1 loops, best of 3: 1.46 s per loop

【讨论】：

你的答案需要大量的时间和内存，np.array(list(IT.permutations(range(ncols)))) 在我为我的机器学习算法做这件事时让我的程序崩溃了

使用np.array(list(itertools.permutations(range(ncols))))会在阶乘时间内产生所有排列，所以对于ncols大的数组是不可行的

【参考方案2】：

你也可以试试pandas中的apply函数

import pandas as pd

df = pd.DataFrame(array)
df = df.apply(lambda x:np.random.shuffle(x) or x, axis=1)

然后从dataframe中提取numpy数组

print df.values

【讨论】：

不幸的是，它慢了 70 倍。我怀疑 pandas 增加了更多开销，并且正在发生内存复制（可能是两个）。不过，or 的把戏很酷。

【参考方案3】：

这里有一些想法：

In [10]: a=np.zeros(shape=(1000,3))

In [12]: a[:,0]=1

In [13]: a[:,1]=2

In [14]: a[:,2]=3

In [17]: %timeit map(np.random.shuffle, a)
100 loops, best of 3: 4.65 ms per loop

In [21]: all_perm=np.array((list(itertools.permutations([0,1,2]))))

In [22]: b=all_perm[np.random.randint(0,6,size=1000)]

In [25]: %timeit (a.flatten()[(b+3*np.arange(1000)[...,np.newaxis]).flatten()]).reshape(a.shape)
1000 loops, best of 3: 393 us per loop

如果只有几列，那么所有可能排列的数量远小于数组中的行数（在这种情况下，当只有 3 列时，只有 6 种可能排列）。使其更快的一种方法是首先一次进行所有排列，然后通过从所有可能的排列中随机选择一个排列来重新排列每一行。

即使尺寸更大，它似乎仍然快 10 倍：

#adjust a accordingly
In [32]: b=all_perm[np.random.randint(0,6,size=1000000)]

In [33]: %timeit (a.flatten()[(b+3*np.arange(1000000)[...,np.newaxis]).flatten()]).reshape(a.shape)
1 loops, best of 3: 348 ms per loop

In [34]: %timeit map(np.random.shuffle, a)
1 loops, best of 3: 4.64 s per loop

【讨论】：

不错。这比我的方法快。

@unutbu，我的灵感来自你的perms=...，必须承认，我的机器上有 MKL，所以也许它会稍微快一点。你的大约是 6 倍。

不错！让计算机做更少的工作总是更好，因为每次实施都会获胜。 @CT Zhu，我在 Fedora BLAS 上得到 ≈12x，所以这是完全合理的。

这些都没有使用 BLAS。随机数由 NumPy 的 randomkit 分支处理。

我怀疑。我正在做的任何事情都不需要 BLAS 例程。但是，只是为了确定。 （因为我真的不知道）。

【参考方案4】：

我相信我有一个替代的等效策略，基于之前的答案：

# original sequence
a0 = np.arange(3) + 1

# length of original sequence
L = a0.shape[0]

# number of random samples/shuffles
N_samp = 1e4

# from above
all_perm = np.array( (list(itertools.permutations(np.arange(L)))) )
b = all_perm[np.random.randint(0, len(all_perm), size=N_samp)]

# index a with b for each row of b and collapse down to expected dimension
a_samp = a0[np.newaxis, b][0]

我不确定这在性能方面如何比较，但我喜欢它的可读性。